use std::fmt::Write as _;
use std::path::PathBuf;
use sapphire_backend::protocol as proto;
use sapphire_bridge_api::{
DevicePrioritySetParams, DeviceRetireParams, InviteParams, JoinParams, WorkgroupCreateParams,
};
use sapphire_bridge_client::BridgeClient;
use sapphire_framework_service::{Environment, ServiceCommand, SystemManager};
use sapphire_ipc::{ClientInfo, Endpoint};
use crate::AppServer;
use crate::error::{Error, Result};
pub use sapphire_backend::protocol::{StatusReport, StatusRow};
#[derive(Debug, Default, clap::Subcommand)]
pub enum FrameworkCommand {
#[default]
Serve,
Status,
#[command(subcommand)]
Service(ServiceCommand),
#[command(subcommand)]
Workspace(WorkspaceCommand),
#[command(subcommand)]
Workgroup(WorkgroupCommand),
#[command(subcommand)]
Device(DeviceCommand),
#[command(subcommand)]
Embedding(sapphire_bridge_api::EmbeddingCommand),
#[command(subcommand)]
ExternalDevice(sapphire_bridge_api::ExternalDeviceCommand),
}
impl FrameworkCommand {
pub async fn dispatch(self, server: AppServer, version: &'static str) -> Result<i32> {
match self {
FrameworkCommand::Serve => {
server.run().await?;
Ok(0)
}
FrameworkCommand::Status => crate::command::status(&server, version).await,
FrameworkCommand::Service(command) => {
let spec = server.service_spec();
command
.run(&spec, &Environment::detect(), &SystemManager)
.map_err(Error::from)
}
FrameworkCommand::Workspace(command) => {
command.dispatch(server.app_name(), version).await
}
FrameworkCommand::Workgroup(command) => command.dispatch(version).await,
FrameworkCommand::Device(command) => command.dispatch(version).await,
FrameworkCommand::Embedding(command) => embedding(command, version).await,
FrameworkCommand::ExternalDevice(command) => {
external_device(command, server.app_name(), version).await
}
}
}
}
#[derive(Debug, clap::Subcommand)]
pub enum WorkspaceCommand {
Init {
dir: Option<PathBuf>,
#[arg(long)]
sync: bool,
},
Select {
dir: Option<PathBuf>,
},
Show,
Map {
selector: String,
dir: Option<PathBuf>,
},
}
impl WorkspaceCommand {
pub async fn dispatch(self, app: &'static str, version: &'static str) -> Result<i32> {
match self {
WorkspaceCommand::Init { dir, sync } => workspace_init(app, version, dir, sync).await,
WorkspaceCommand::Select { dir } => workspace_select(app, version, dir).await,
WorkspaceCommand::Show => workspace_show(app, version).await,
WorkspaceCommand::Map { selector, dir } => {
workspace_map(app, version, &selector, dir).await
}
}
}
}
#[derive(Debug, clap::Subcommand)]
pub enum WorkgroupCommand {
Create {
name: String,
#[arg(long)]
device_name: String,
},
List,
Join {
ticket: String,
#[arg(long)]
device_name: Option<String>,
},
}
impl WorkgroupCommand {
pub async fn dispatch(self, version: &'static str) -> Result<i32> {
match self {
WorkgroupCommand::Create { name, device_name } => {
let client = connect_running(version).await?;
let created = client
.workgroup_create(WorkgroupCreateParams { name, device_name })
.await?;
println!(
"created workgroup {} ({}); this device is {}",
created.name, created.workgroup_id, created.device_id
);
Ok(0)
}
WorkgroupCommand::List => {
let client = connect_running(version).await?;
match client.status().await?.workgroup {
Some(workgroup) => {
println!("{} ({})", workgroup.name, workgroup.workgroup_id);
Ok(0)
}
None => {
println!("this host has not joined a workgroup");
Ok(1)
}
}
}
WorkgroupCommand::Join {
ticket,
device_name,
} => {
let client = connect_running(version).await?;
let joined = client
.join(JoinParams {
ticket,
device_name,
})
.await?;
println!(
"joined workgroup {} ({}); this device is {}",
joined.workgroup_name, joined.workgroup_id, joined.device_id
);
Ok(0)
}
}
}
}
#[derive(Debug, clap::Subcommand)]
pub enum DeviceCommand {
List,
Invite {
#[arg(long)]
name: String,
#[arg(long)]
ttl: Option<u64>,
#[arg(long)]
workgroup: Option<String>,
},
Retire {
selector: String,
},
Priority {
selector: String,
priority: Option<u8>,
},
}
impl DeviceCommand {
pub async fn dispatch(self, version: &'static str) -> Result<i32> {
match self {
DeviceCommand::List => {
let client = connect_running(version).await?;
let peers = client.peers().await?;
if peers.peers.is_empty() {
println!("no devices");
return Ok(0);
}
for peer in peers.peers {
println!(
"{} {} p{}{}{}",
peer.name,
peer.device_id,
peer.priority,
peer.availability
.map(|a| format!(" a{a}"))
.unwrap_or_default(),
if peer.connected { " (online)" } else { "" }
);
}
Ok(0)
}
DeviceCommand::Invite {
name,
ttl,
workgroup,
} => {
let client = connect_running(version).await?;
let invite = client
.invite(InviteParams {
name,
ttl,
workgroup,
})
.await?;
println!("{}", invite.ticket);
Ok(0)
}
DeviceCommand::Retire { selector } => {
let client = connect_running(version).await?;
let retired = client
.device_retire(DeviceRetireParams { selector })
.await?;
println!("retired device {} ({})", retired.name, retired.device_id);
Ok(0)
}
DeviceCommand::Priority { selector, priority } => {
let client = connect_running(version).await?;
match priority {
Some(priority) => {
let set = client
.device_priority_set(DevicePrioritySetParams { selector, priority })
.await?;
println!("{} ({}) priority {}", set.name, set.device_id, set.priority);
}
None => {
let peers = client.peers().await?;
match peers
.peers
.iter()
.find(|p| p.name == selector || p.device_id.to_string() == selector)
{
Some(p) => {
println!("{} ({}) priority {}", p.name, p.device_id, p.priority)
}
None => {
println!("no device {selector:?}");
return Ok(1);
}
}
}
}
Ok(0)
}
}
}
}
async fn connect_running(version: &str) -> Result<BridgeClient> {
BridgeClient::connect_running("cli", version)
.await
.map_err(Error::from)
}
async fn embedding(command: sapphire_bridge_api::EmbeddingCommand, version: &str) -> Result<i32> {
let client = connect_running(version).await?;
let request = command.request()?;
let report = client.embed_request(request).await?;
for line in sapphire_bridge_api::describe(&report) {
println!("{line}");
}
Ok(0)
}
async fn external_device(
command: sapphire_bridge_api::ExternalDeviceCommand,
app: &str,
version: &str,
) -> Result<i32> {
let client = connect_running(version).await?;
let outcome = client
.external_device_request(command.request(Some(app)))
.await?;
for line in sapphire_bridge_api::describe_external_outcome(&outcome) {
println!("{line}");
}
Ok(0)
}
async fn workspace_init(
app: &'static str,
version: &'static str,
dir: Option<PathBuf>,
sync: bool,
) -> Result<i32> {
let endpoint = Endpoint::for_app(app)?;
let client_info = ClientInfo {
kind: "cli".to_owned(),
version: version.to_owned(),
api: proto::API_VERSION,
app_api: None,
pid: std::process::id(),
};
let Some((client, _)) = sapphire_ipc::connect_or_absent(&endpoint, app, client_info).await?
else {
println!("no {app} server is running");
return Ok(1);
};
let dir = std::env::current_dir()?.join(dir.unwrap_or_else(|| PathBuf::from(".")));
let result: proto::WorkspaceInitResult = client
.call(proto::WORKSPACE_INIT, proto::WorkspaceInitParams { dir })
.await?;
if result.created {
println!("initialized {app} workspace in {}", result.root.display());
} else {
println!(
"{} already exists (workspace {})",
result.root.display(),
result.workspace_id
);
}
println!("the {app} server now serves {}", result.root.display());
if sync {
let enabled: proto::SyncEnableResult = client
.call(proto::SYNC_ENABLE, serde_json::json!({}))
.await?;
let status: proto::SyncStatusResult = client
.call(proto::SYNC_STATUS, serde_json::json!({}))
.await
.unwrap_or(proto::SyncStatusResult {
enabled: true,
workspace_id: Some(enabled.workspace_id),
..proto::SyncStatusResult::not_synced()
});
println!(
"syncing as {} ({} peer{})",
enabled.workspace_id,
status.peers,
if status.peers == 1 { "" } else { "s" }
);
}
Ok(0)
}
pub async fn render_workspace(client: &sapphire_ipc::Client, out: &mut String) -> Result<i32> {
let current: proto::WorkspaceCurrentResult = client
.call(proto::WORKSPACE_CURRENT, serde_json::json!({}))
.await?;
let Some(ws) = current.workspace else {
writeln!(
out,
"no workspace yet; run `workspace init <dir>` or `workspace select <dir>`"
)
.expect("writing to a String cannot fail");
return Ok(1);
};
writeln!(out, "{} {}", ws.root.display(), describe_state(&ws))
.expect("writing to a String cannot fail");
Ok(0)
}
fn describe_state(ws: &proto::CurrentWorkspace) -> String {
let state = if !ws.reachable {
"unreachable"
} else if ws.sync.enabled {
"synced"
} else {
"not synced"
};
let star = if matches!(ws.sync.topology, proto::Topology::Star { .. }) {
" (star)"
} else {
""
};
let pending = match &ws.sync.embedding {
Some(e) if e.pending > 0 => format!(", embedding {} pending", e.pending),
_ => String::new(),
};
format!("{state}{star}{pending}")
}
async fn connect_app(app: &str, version: &str) -> Result<Option<sapphire_ipc::Client>> {
let endpoint = Endpoint::for_app(app)?;
let client_info = ClientInfo {
kind: "cli".to_owned(),
version: version.to_owned(),
api: proto::API_VERSION,
app_api: None,
pid: std::process::id(),
};
let client = sapphire_ipc::connect_or_absent(&endpoint, app, client_info).await?;
if client.is_none() {
println!("no {app} server is running");
}
Ok(client.map(|(c, _)| c))
}
async fn workspace_select(
app: &'static str,
version: &'static str,
dir: Option<PathBuf>,
) -> Result<i32> {
let Some(client) = connect_app(app, version).await? else {
return Ok(1);
};
let dir = std::env::current_dir()?.join(dir.unwrap_or_else(|| PathBuf::from(".")));
let ws: proto::CurrentWorkspace = client
.call(
proto::WORKSPACE_SELECT,
proto::WorkspaceSelectParams { dir },
)
.await?;
println!("{} {}", ws.root.display(), describe_state(&ws));
Ok(0)
}
async fn workspace_show(app: &'static str, version: &'static str) -> Result<i32> {
let Some(client) = connect_app(app, version).await? else {
return Ok(1);
};
let mut out = String::new();
let code = render_workspace(&client, &mut out).await?;
for line in out.lines() {
println!("{line}");
}
let Some(client) = BridgeClient::connect_running("cli", version).await.ok() else {
println!("no sapphire-bridge is running");
return Ok(code);
};
let workspaces = client.workspaces().await.map_err(Error::from)?;
let mine: Vec<_> = workspaces
.workspaces
.into_iter()
.filter(|w| w.app_name == app)
.collect();
if !mine.is_empty() {
println!();
println!("in the workgroup:");
for workspace in mine {
println!("{} {}", workspace.name, workspace.workspace_id);
}
}
Ok(code)
}
async fn workspace_map(
app: &'static str,
version: &'static str,
selector: &str,
dir: Option<PathBuf>,
) -> Result<i32> {
let Some(client) = BridgeClient::connect_running("cli", version).await.ok() else {
println!("no sapphire-bridge is running");
return Ok(1);
};
let workspaces = client.workspaces().await.map_err(Error::from)?;
let wanted = workspaces
.workspaces
.iter()
.find(|w| w.name == selector || w.workspace_id.to_string() == selector)
.ok_or_else(|| Error::UnknownWorkspaceName(selector.to_owned()))?;
let endpoint = Endpoint::for_app(app)?;
let client_info = ClientInfo {
kind: "cli".to_owned(),
version: version.to_owned(),
api: proto::API_VERSION,
app_api: None,
pid: std::process::id(),
};
let Some((client, _)) = sapphire_ipc::connect_or_absent(&endpoint, app, client_info).await?
else {
println!("no {app} server is running");
return Ok(1);
};
let dir = std::env::current_dir()?.join(dir.unwrap_or_else(|| PathBuf::from(".")));
let mapped: proto::SyncEnableResult = client
.call(
proto::SYNC_MAP,
proto::SyncMapParams {
workspace: wanted.workspace_id.to_string(),
dir,
},
)
.await?;
println!(
"mapped {} as {}; the {app} server now serves it",
wanted.name, mapped.workspace_id
);
Ok(0)
}
async fn status(server: &AppServer, version: &str) -> Result<i32> {
let endpoint = Endpoint::for_app(server.app_name())?;
run_status(&endpoint, server.app_name(), version).await
}
async fn run_status(endpoint: &Endpoint, app: &str, version: &str) -> Result<i32> {
let mut out = String::new();
let code = run_status_into(endpoint, app, version, &mut out).await?;
for line in out.lines() {
println!("{line}");
}
Ok(code)
}
async fn run_status_into(
endpoint: &Endpoint,
app: &str,
version: &str,
out: &mut String,
) -> Result<i32> {
let client_info = ClientInfo {
kind: "cli".to_owned(),
version: version.to_owned(),
api: proto::API_VERSION,
app_api: None,
pid: std::process::id(),
};
let Some((client, _)) = sapphire_ipc::connect_or_absent(endpoint, app, client_info).await?
else {
writeln!(out, "no {app} server is running").expect("writing to a String cannot fail");
return Ok(1);
};
let report: StatusReport = client
.call(
sapphire_backend::protocol::SERVER_INFO,
serde_json::json!({}),
)
.await?;
writeln!(out, "running: {}", report.running).expect("writing to a String cannot fail");
if let Some(version) = &report.version {
writeln!(out, "version: {version}").expect("writing to a String cannot fail");
}
if let Some(pid) = report.pid {
writeln!(out, "pid: {pid}").expect("writing to a String cannot fail");
}
if let Some(managed_by) = &report.managed_by {
writeln!(out, "managed_by: {managed_by:?}").expect("writing to a String cannot fail");
}
for row in &report.app {
writeln!(out, "{}: {}", row.name, row.value).expect("writing to a String cannot fail");
}
Ok(0)
}
#[cfg(test)]
mod tests {
use super::*;
use clap::Parser;
#[derive(Parser)]
struct Probe {
#[command(subcommand)]
command: Command,
}
#[derive(Debug, clap::Subcommand)]
enum Command {
Greet,
#[command(flatten)]
Framework(FrameworkCommand),
}
#[test]
fn app_and_framework_commands_parse_side_by_side() {
let probe = Probe::try_parse_from(["app", "greet"]).unwrap();
assert!(matches!(probe.command, Command::Greet));
let probe = Probe::try_parse_from(["app", "serve"]).unwrap();
assert!(matches!(
probe.command,
Command::Framework(FrameworkCommand::Serve)
));
let probe = Probe::try_parse_from(["app", "status"]).unwrap();
assert!(matches!(
probe.command,
Command::Framework(FrameworkCommand::Status)
));
}
#[test]
fn the_service_subcommands_parse() {
for args in [
vec!["app", "service", "install"],
vec!["app", "service", "uninstall"],
vec!["app", "service", "status"],
] {
assert!(Probe::try_parse_from(&args).is_ok(), "{args:?}");
}
}
#[test]
fn the_workspace_and_bridge_commands_parse() {
for args in [
vec!["app", "workspace", "init"],
vec!["app", "workspace", "init", "papers"],
vec!["app", "workspace", "init", "--sync"],
vec!["app", "workspace", "show"],
vec!["app", "workspace", "select", "papers"],
vec!["app", "workspace", "map", "papers", "papers-remote"],
vec![
"app",
"workgroup",
"create",
"--device-name",
"laptop",
"home",
],
vec!["app", "workgroup", "list"],
vec![
"app",
"workgroup",
"join",
"--device-name",
"laptop",
"TICKET",
],
vec!["app", "device", "list"],
vec!["app", "device", "invite", "--name", "phone"],
vec!["app", "device", "retire", "phone"],
] {
assert!(Probe::try_parse_from(&args).is_ok(), "{args:?}");
}
}
#[test]
fn bare_invocation_defaults_to_serve() {
#[derive(Parser)]
struct Bare {
#[command(subcommand)]
command: Option<Command>,
}
let bare = Bare::try_parse_from(["app"]).unwrap();
assert!(bare.command.is_none());
assert!(matches!(
FrameworkCommand::default(),
FrameworkCommand::Serve
));
}
}
#[cfg(test)]
mod status_tests {
use super::*;
use sapphire_workspace::AppContext;
static CTX: AppContext = AppContext::new("sapphire-statustest");
async fn wait_until_listening(endpoint: &Endpoint) {
let deadline = tokio::time::Instant::now() + std::time::Duration::from_secs(5);
while !sapphire_ipc::probe(endpoint).await.unwrap() {
assert!(
tokio::time::Instant::now() < deadline,
"the server never started listening"
);
tokio::time::sleep(std::time::Duration::from_millis(10)).await;
}
}
#[tokio::test]
async fn status_reports_no_server_when_none_is_running() {
let tmp = tempfile::tempdir().unwrap();
let endpoint = sapphire_ipc::Endpoint::in_dir("status-test", tmp.path().to_path_buf());
let code = run_status(&endpoint, "status-test", "0.0.0").await.unwrap();
assert_eq!(code, 1, "no server is a non-zero exit");
}
#[tokio::test(flavor = "multi_thread")]
async fn status_shows_the_extension_rows_of_a_running_server() {
let tmp = tempfile::tempdir().unwrap();
let endpoint = sapphire_ipc::Endpoint::in_dir("status-test", tmp.path().to_path_buf());
let server = AppServer::new(&CTX, "0.0.0")
.endpoint(endpoint.clone())
.selection_file(tmp.path().join("workspace.toml"))
.status_rows(std::sync::Arc::new(|| {
vec![StatusRow {
name: "sync".into(),
value: "on".into(),
}]
}));
let handle = tokio::spawn(async move { server.run().await });
wait_until_listening(&endpoint).await;
let mut out = String::new();
let code = run_status_into(&endpoint, CTX.app_name, "0.0.0", &mut out)
.await
.unwrap();
assert_eq!(code, 0);
assert!(out.contains("running: true"), "output was: {out}");
assert!(out.contains("sync: on"), "output was: {out}");
let (client, _) = sapphire_ipc::connect_or_absent(
&endpoint,
CTX.app_name,
sapphire_ipc::ClientInfo {
kind: "test".into(),
version: "0.0.0".into(),
api: sapphire_backend::protocol::API_VERSION,
app_api: None,
pid: std::process::id(),
},
)
.await
.unwrap()
.expect("the server is listening");
let _: serde_json::Value = client
.call(sapphire_ipc::SHUTDOWN_METHOD, serde_json::json!({}))
.await
.unwrap();
handle.await.unwrap().unwrap();
}
}
#[cfg(test)]
mod service_spec_tests {
use super::*;
use sapphire_workspace::AppContext;
static CTX: AppContext = AppContext::new("sapphire-servicetest");
#[test]
fn the_generated_spec_runs_the_server_not_the_cli() {
let spec = AppServer::new(&CTX, "0.0.0").service_spec();
assert_eq!(spec.args, vec!["serve".to_owned()]);
}
#[test]
fn the_generated_spec_names_this_application() {
let spec = AppServer::new(&CTX, "0.0.0").service_spec();
assert_eq!(spec.app_name, CTX.app_name);
}
#[test]
fn the_generated_spec_describes_the_server() {
let spec = AppServer::new(&CTX, "0.0.0").service_spec();
assert!(
spec.description.contains(CTX.app_name),
"the unit's description should name the application: {:?}",
spec.description
);
assert!(spec.description.contains("0.0.0"));
}
}