use clap::Args;
use serde::Deserialize;
use std::fmt::Write;
use crate::fmt::{human_size, relative_time_rfc3339, short_id, until_rfc3339};
#[derive(Args, Debug)]
pub struct PsArgs {
#[arg(long)]
pub no_pager: bool,
#[arg(value_name = "PREFIX")]
pub prefix: Option<String>,
}
#[derive(Debug, Deserialize)]
struct PsResponse {
models: Vec<PsModel>,
}
#[derive(Debug, Deserialize)]
struct PsModel {
name: String,
digest: String,
size: u64,
processor: String,
context_length: Option<u64>,
started_at: String,
expires_at: Option<String>,
#[serde(default)]
node: Option<String>,
}
pub fn run(args: &PsArgs) -> anyhow::Result<()> {
if !crate::daemon::server_alive() {
anyhow::bail!(
"llmman serve is not running (nothing is loaded) — start it with `llmman serve`"
);
}
let resp: PsResponse = crate::daemon::get_json("/api/ps")?;
let mut models: Vec<_> = resp
.models
.into_iter()
.filter(|m| args.prefix.as_deref().is_none_or(|p| m.name.starts_with(p)))
.collect();
models.sort_by(|a, b| a.name.cmp(&b.name));
let rendered: Vec<(String, String)> = models
.iter()
.map(|m| {
let started = relative_time_rfc3339(&m.started_at);
let until = m
.expires_at
.as_deref()
.map(until_rfc3339)
.unwrap_or_else(|| "Forever".into());
(started, until)
})
.collect();
let name_w = models
.iter()
.map(|m| m.name.len())
.max()
.unwrap_or(4)
.max(4);
let proc_w = models
.iter()
.map(|m| m.processor.len())
.max()
.unwrap_or(9)
.max(9);
let started_w = rendered
.iter()
.map(|(started, _)| started.len())
.max()
.unwrap_or(7)
.max(7);
let nodes: Vec<&str> = models
.iter()
.map(|m| node_label(m.node.as_deref()))
.collect();
let node_w = models
.iter()
.any(|m| m.node.is_some())
.then(|| nodes.iter().map(|n| n.len()).max().unwrap_or(4).max(4));
let node_col = |node: &str| {
node_w
.map(|w| format!("{node:<w$} "))
.unwrap_or_default()
};
let mut out = String::new();
writeln!(
&mut out,
"{:<name_w$} {:<12} {:<10} {:<proc_w$} {:<9} {:<started_w$} {}UNTIL",
"NAME",
"ID",
"SIZE",
"PROCESSOR",
"CONTEXT",
"STARTED",
node_col("NODE"),
name_w = name_w,
proc_w = proc_w,
started_w = started_w,
)?;
for ((m, (started, until)), node) in models.iter().zip(rendered.iter()).zip(nodes) {
writeln!(
&mut out,
"{:<name_w$} {:<12} {:<10} {:<proc_w$} {:<9} {:<started_w$} {}{}",
m.name,
short_id(&m.digest),
human_size(m.size),
m.processor,
m.context_length.map(|c| c.to_string()).unwrap_or_default(),
started,
node_col(node),
until,
name_w = name_w,
proc_w = proc_w,
started_w = started_w,
)?;
}
crate::pager::emit("ps", &out, !args.no_pager)
}
fn node_label(node: Option<&str>) -> &str {
let Some(node) = node else {
return "local";
};
node.split_once("://").map_or(node, |(_, rest)| rest)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn node_label_drops_the_scheme_and_names_this_daemon_local() {
assert_eq!(node_label(None), "local");
assert_eq!(node_label(Some("http://spark:17434")), "spark:17434");
assert_eq!(node_label(Some("asahi:17434")), "asahi:17434");
}
}