feat: add headless agent management to CLI and both desktop clients

This commit is contained in:
tongtong committed 2026-11-12 21:17:44 +08:00
1 parent e91fa0235c
commit 6916dd54fb
50 files changed
+4837 -148

No files matched your search

+57 -113
View File
@@ -1,34 +1,34 @@
use ads_core::{
adb_tcp_connect, dial, init_logging, next_control, relay, tcp_connect, valid_device_id,
validate_token, NetworkArgs,
};
mod gateway;
mod managed;
mod supervisor;
use ads_core::{valid_device_id, validate_token, NetworkArgs};
use ads_management::{credential, AgentConfig};
use anyhow::{bail, Context, Result};
use clap::Parser;
use std::{sync::Arc, time::Duration};
use tokio::{net::TcpStream, task::JoinSet, time::sleep};
use tracing::{info, warn};
use std::{path::PathBuf, sync::Arc};
#[derive(Parser)]
#[command(
version,
about = "Remote device gateway: outbound-only connection to the ADS relay"
about = "ADS agent: managed multi-device gateway or legacy single-device worker"
)]
struct Args {
#[command(flatten)]
network: NetworkArgs,
#[arg(long, env = "ADS_AGENT_TOKEN", hide_env_values = true)]
token: String,
/// Stable public device alias, e.g. home-phone
token: Option<String>,
#[arg(long)]
device: String,
/// Direct phone adbd address reachable from this gateway, e.g. 192.168.100.141:5555
#[arg(
long,
required_unless_present = "adb_serial",
conflicts_with = "adb_serial"
)]
config: Option<PathBuf>,
/// Supervise the headless child; required for management restart
#[arg(long, requires = "config")]
supervise: bool,
/// Retain managed logs in memory without console output
#[arg(long)]
quiet: bool,
#[arg(long)]
device: Option<String>,
#[arg(long, conflicts_with = "adb_serial")]
target: Option<String>,
/// Alternative: choose a transport from an existing ADB server (phone must have TCP adbd enabled)
#[arg(long)]
adb_serial: Option<String>,
#[arg(long, default_value = "127.0.0.1:5037")]
@@ -36,105 +36,49 @@ struct Args {
#[arg(long, default_value_t = 5555)]
device_port: u16,
}
async fn upstream(args: &Args) -> Result<TcpStream> {
match &args.target {
Some(address) => tcp_connect(address).await,
None => {
adb_tcp_connect(
&args.adb_server,
args.adb_serial.as_deref().context("missing serial")?,
args.device_port,
)
.await
}
}
}
async fn serve_session(args: Arc<Args>, session: String, signal_key: Option<String>) -> Result<()> {
let tcp = upstream(&args).await.context("cannot reach phone adbd")?;
if let Some(key) = signal_key {
let signal = dial(
args.network
.url("/v2/signal", &[("session", &session), ("key", &key)])?,
&args.token,
args.network.connect_address.as_deref(),
)
.await?;
return ads_core::transport::agent_session(tcp, signal, &args.network).await;
}
let ws = dial(
args.network.url(
"/v1/data",
&[("device", &args.device), ("session", &session)],
)?,
&args.token,
args.network.connect_address.as_deref(),
)
.await?;
relay(tcp, ws).await
}
async fn online(args: Arc<Args>) -> Result<()> {
let mut ws = dial(
args.network
.url("/v1/agent", &[("device", &args.device), ("v", "2")])?,
&args.token,
args.network.connect_address.as_deref(),
)
.await?;
let hello = next_control(&mut ws).await?;
if hello.kind != "registered" {
bail!("expected registered response");
}
info!(device = %args.device, "gateway registered");
let mut tasks = JoinSet::new();
loop {
tokio::select! {
message = next_control(&mut ws) => {
let message = message?;
if message.kind != "open" && message.kind != "open_v2" { bail!("unexpected gateway control message"); }
let signal_key = if message.kind == "open_v2" { Some(message.signal_key.context("missing signal key")?) } else { None };
let session = message.session.context("missing session ticket")?;
if tasks.len() >= 32 { warn!("gateway stream limit reached"); continue; }
let args = args.clone();
tasks.spawn(async move {
if let Err(error) = serve_session(args, session, signal_key).await { warn!(%error, "device stream ended"); }
});
},
_ = tasks.join_next(), if !tasks.is_empty() => {},
}
}
// JoinSet drop aborts all streams when the control connection is lost.
}
async fn run(args: Arc<Args>) {
let mut delay = 1;
loop {
let started = std::time::Instant::now();
if let Err(error) = online(args.clone()).await {
warn!(%error, "gateway offline; reconnecting");
}
if started.elapsed() > Duration::from_secs(30) {
delay = 1;
}
sleep(Duration::from_secs(delay)).await;
delay = (delay * 2).min(30);
}
}
#[tokio::main]
async fn main() -> Result<()> {
init_logging();
let args = Args::parse();
validate_token(&args.token)?;
if !valid_device_id(&args.device) {
bail!("invalid device ID (use letters, digits, -, _, .; max 128 bytes)");
if args.quiet {
std::env::set_var("ADS_LOG_STDOUT", "0");
}
args.network.url("/v1/agent", &[])?;
tokio::select! {
_ = run(Arc::new(args)) => {},
result = tokio::signal::ctrl_c() => { result?; info!("gateway stopping"); },
if let Some(path) = args.config {
if args.device.is_some() || args.target.is_some() || args.adb_serial.is_some() {
bail!("managed config cannot be combined with single-device arguments")
}
let path = std::fs::canonicalize(path).context("agent config not found")?;
if args.supervise {
return supervisor::run(path).await;
}
let config = AgentConfig::load(&path)?;
let token = match args.token {
Some(value) => value,
None => credential(&path.with_file_name("agent.env"), "ADS_AGENT_TOKEN")?,
};
validate_token(&token)?;
let restart = managed::run(path, config, token).await?;
if restart {
std::process::exit(75)
}
} else {
ads_core::init_logging();
let token = args.token.context("provide ADS_AGENT_TOKEN")?;
validate_token(&token)?;
let device = args.device.context("provide --device or --config")?;
if !valid_device_id(&device) || args.target.is_none() == args.adb_serial.is_none() {
bail!("valid device and exactly one of --target / --adb-serial are required")
}
args.network.url("/v1/agent", &[])?;
let worker = gateway::Gateway {
network: args.network,
token,
device,
target: args.target,
adb_serial: args.adb_serial,
adb_server: args.adb_server,
device_port: args.device_port,
};
tokio::select! {_=gateway::run(Arc::new(worker),None)=>{},result=tokio::signal::ctrl_c()=>{result?;}}
}
Ok(())
}