Skip to content

Reason Network: your team's coding agents, talking to each other. The engine behind `reason network`.

Keep a team with its own relay off n0's servers

Lars Talian19e16681f668
diff --git a/Cargo.lock b/Cargo.lock
index b61664c..1e5ceb4 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -3616,6 +3616,7 @@ dependencies = [
"cliclack",
"console",
"data-encoding",
+ "futures-lite",
"getrandom 0.3.4",
"iroh",
"iroh-mdns-address-lookup",
diff --git a/Cargo.toml b/Cargo.toml
index 9c57f9b..ec32162 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -17,6 +17,7 @@ blake3 = "1"
clap = { version = "4", features = ["derive"] }
cliclack = "0.5"
data-encoding = "2"
+futures-lite = "2"
getrandom = "0.3"
iroh = "1.3"
iroh-mdns-address-lookup = "0.6"
diff --git a/DESIGN.md b/DESIGN.md
index 74e3cd4..092a96a 100644
--- a/DESIGN.md
+++ b/DESIGN.md
@@ -84,7 +84,11 @@ SDK) both exist and work today. Zig has neither, which is why agent-rpc's MCP sh
(`~/.tincan/machine.key`). Peers are dialed by `EndpointId`; iroh resolves addresses via n0 DNS/pkarr, finds
LAN peers with `iroh-mdns-address-lookup` (works with no internet), hole-punches, and falls back to a relay
over HTTPS. Default relays are n0's public ones (they only see encrypted QUIC). A team can set its own relay
-(`iroh-relay` binary on any VPS, Let's Encrypt on :443, access limited to the roster's endpoint ids).
+(`tincan relay <url>` or `tincan init --relay <url>`; the `iroh-relay` binary on any VPS, Let's Encrypt on :443,
+access limited to the roster's endpoint ids). Then its machines never contact n0: they use only that relay
+(teammates are dialed through it) and mDNS on the LAN, and invites come in the long form, since a four-word code
+needs n0's lookup. A machine that was off while the team switched relays can't find it on its own; `tincan doctor`
+there says to set the same relay with `tincan relay`.
That is the "HTTPS and local network, MagicDNS style" requirement with one stack and no server we must run.
**Roster (membership).** Replicated to every machine, every entry signed by a member machine's key:
@@ -209,7 +213,8 @@ not approve. Nothing changes how an agent works when it isn't messaging.
`crossSessionInbound` setting on top.
- Loop guard: rate limit per sender, and a cap on consecutive agent↔agent messages in a thread without
any human input.
-- Nothing is sent to any service we run. Relays see ciphertext only.
+- Nothing is sent to any service we run. Relays see ciphertext only. With its own relay, a team's machines never
+ contact n0 either.
## Install UX (M3)
@@ -276,7 +281,8 @@ edits): Claude Code plugin or `claude mcp add --scope user` + hooks, `~/.codex/c
- **`tincan doctor`** checks the daemon, the team connection (direct or relayed, per machine) and every agent.
- **An agent doesn't have the tincan tools:** restart that session; agents load MCP servers at startup.
- **A teammate shows as offline:** their machine is asleep or tincan isn't running there (`tincan doctor` on
- their side). Messages wait in your outbox and go out when they're back.
+ their side). Messages wait in your outbox and go out when they're back. If it was off while the team changed
+ relays, run `tincan relay` there with the team's relay (`tincan team` shows it).
- **macOS asks to let tincan find devices on your local network:** allow it for direct LAN connections. If you
don't, tincan still works over the internet.
- **Windows asks to let tincan through the firewall:** allow it for direct and LAN connections. If you don't,
diff --git a/README.md b/README.md
index 9a22eea..8193cfd 100644
--- a/README.md
+++ b/README.md
@@ -49,8 +49,9 @@ tincan setup # which agents are on tincan, and how messages are
Each machine runs a small daemon. Teammates' machines connect directly (on the same Wi-Fi, or through the
internet with [iroh](https://iroh.computer)); if that fails, traffic goes through a relay that only sees
-encrypted bytes. Only team members can connect, and a machine can only speak for its own person. Messages to
-someone offline wait and go out when they're back.
+encrypted bytes. That's one of n0's (the company behind iroh) unless your team runs its own (`tincan relay
+<url>`): then your machines never contact n0 at all. Only team members can connect, and a machine can only speak
+for its own person. Messages to someone offline wait and go out when they're back.
Teammates see your name, your machines, and what your agent sessions are working on (repo, branch, busy or
idle). Details: [DESIGN.md](DESIGN.md).
diff --git a/src/daemon/mod.rs b/src/daemon/mod.rs
index 9820f1a..c71a4cd 100644
--- a/src/daemon/mod.rs
+++ b/src/daemon/mod.rs
@@ -275,7 +275,7 @@ impl Daemon {
}
Request::Hook(h) => json!(self.hook(h).await?),
Request::Attach { agent, cwd } => json!(self.attach(&agent, &cwd)),
- Request::CreateTeam { name, person } => json!(self.create_team(&name, &person).await?),
+ Request::CreateTeam { name, person, relay } => json!(self.create_team(&name, &person, relay).await?),
Request::Join { ticket, person } => json!(self.join_team(&ticket, &person).await?),
Request::Invite { me, hours } => json!(self.invite(me, hours).await?),
Request::Team => json!(self.team_info()?),
diff --git a/src/daemon/teamops.rs b/src/daemon/teamops.rs
index 58edf84..7fd5f50 100644
--- a/src/daemon/teamops.rs
+++ b/src/daemon/teamops.rs
@@ -49,7 +49,8 @@ impl Daemon {
pub(super) async fn start_net(self: &Arc<Self>) -> Result<()> {
let team = self.team_state().ok_or_else(|| anyhow!("not in a team"))?;
- let endpoint = net::bind(self.key.clone(), team.meta.body.relay.as_deref(), self.cfg.lan()).await?;
+ let relay = team.meta.body.relay.as_deref();
+ let endpoint = net::bind(self.key.clone(), relay, self.cfg.lan()).await?;
// Last known presence of each machine, so `who --all` shows offline teammates after a restart.
let mut remote = HashMap::new();
{
@@ -60,7 +61,7 @@ impl Daemon {
}
}
}
- let net = Net::start(self, endpoint, remote);
+ let net = Net::start(self, endpoint, relay, remote);
log(&format!("team {} · machine {}", team.name(), net.id().fmt_short()));
*self.net.write().unwrap() = Some(net.clone());
// Invite codes made here that are still good: listen for them again.
@@ -70,7 +71,7 @@ impl Daemon {
};
for (code, expires) in codes {
if team.invite_unused(&invite::secret(&code)) {
- net.listen_invite(invite::key(&code), expires, team.meta.body.relay.as_deref(), self.cfg.lan()).await?;
+ net.listen_invite(invite::key(&code), expires, relay, self.cfg.lan()).await?;
} else {
self.inner.lock().unwrap().store.delete_prefix(&format!("code:{code}"))?;
}
@@ -158,7 +159,8 @@ impl Daemon {
Ok(state)
}
- pub(super) async fn create_team(self: &Arc<Self>, name: &str, person: &str) -> Result<TeamInfo> {
+ /// Starts a team, with its own relay from the first moment if `relay` is given.
+ pub(super) async fn create_team(self: &Arc<Self>, name: &str, person: &str, relay: Option<String>) -> Result<TeamInfo> {
if let Some(t) = self.team_state() {
bail!("already in team '{}'; run `tincan leave` first", t.name());
}
@@ -166,7 +168,11 @@ impl Daemon {
if name.is_empty() || person.is_empty() {
bail!("the team and your name need letters or digits");
}
- let state = TeamState::found(name, &person, &self.machine, &self.key);
+ let mut state = TeamState::found(name, &person, &self.machine, &self.key);
+ if let Some(u) = &relay {
+ net::check_relay(self.key.clone(), u).await?;
+ state.set_relay(&self.key, relay.clone());
+ }
{
let mut g = self.inner.lock().unwrap();
g.team = Some(state);
@@ -174,7 +180,7 @@ impl Daemon {
}
self.become_person(&person)?;
self.restart_soon();
- Ok(TeamInfo { name: name.into(), relay: None, person, machine: self.machine.clone(), machines: Vec::new() })
+ Ok(TeamInfo { name: name.into(), relay, relay_connected: None, person, machine: self.machine.clone(), machines: Vec::new() })
}
/// Joins with an invite code (`plum-tiger-lake-orbit`) or a long `tincan1…` ticket.
@@ -231,6 +237,7 @@ impl Daemon {
let info = TeamInfo {
name: state.name().into(),
relay: state.meta.body.relay.clone(),
+ relay_connected: None,
person: person.clone(),
machine: self.machine.clone(),
machines: Vec::new(),
@@ -268,11 +275,18 @@ impl Daemon {
let ticket = self.ticket(team, secret);
let state = team.clone();
self.save_team(&g)?;
- g.store.set(&format!("code:{code}"), &expires.to_string())?;
+ if state.meta.body.relay.is_none() {
+ g.store.set(&format!("code:{code}"), &expires.to_string())?;
+ }
(state, ticket)
};
let relay = state.meta.body.relay.clone();
net.broadcast(&Wire::State { state: Box::new(state) });
+ // Finding the machine behind a code takes n0's address lookup: a team with its own relay gets the long form.
+ if relay.is_some() {
+ let ticket = ticket.encode();
+ return Ok(InviteInfo { code: ticket.clone(), ticket, hours });
+ }
net.listen_invite(invite::key(&code), expires, relay.as_deref(), self.cfg.lan()).await?;
Ok(InviteInfo { code, ticket: ticket.encode(), hours })
}
@@ -325,6 +339,7 @@ impl Daemon {
Ok(TeamInfo {
name: team.name().into(),
relay: team.meta.body.relay.clone(),
+ relay_connected: self.net().map(|n| n.relay_connected()),
person: self.person.clone(),
machine: self.machine.clone(),
machines: self.machines(),
@@ -439,10 +454,8 @@ impl Daemon {
}
pub(super) async fn set_relay(self: &Arc<Self>, url: Option<String>) -> Result<String> {
- if let Some(u) = &url
- && u.parse::<iroh::RelayUrl>().is_err()
- {
- bail!("not a relay url: {u} (expected e.g. https://relay.example.com)");
+ if let Some(u) = &url {
+ net::check_relay(self.key.clone(), u).await?;
}
let state = {
let mut g = self.inner.lock().unwrap();
@@ -452,14 +465,24 @@ impl Daemon {
self.save_team(&g)?;
state
};
+ let me = self.key.public();
+ let online = |id: &EndpointId| self.net().is_some_and(|n| n.is_online(id));
+ let away: Vec<String> =
+ state.active().filter(|m| m.endpoint != me && !online(&m.endpoint)).map(|m| format!("{}/{}", m.person, m.machine)).collect();
if let Some(net) = self.net() {
net.broadcast(&Wire::State { state: Box::new(state) });
tokio::time::sleep(Duration::from_millis(800)).await;
}
self.restart_soon();
- Ok(match url {
- Some(u) => format!("The team now uses relay {u}."),
- None => "The team now uses n0's public relays.".into(),
- })
+ let (now, cmd) = match &url {
+ Some(u) => (format!("The team now uses relay {u}, and nothing of n0's."), format!("tincan relay {u}")),
+ None => ("The team now uses n0's public relays.".into(), "tincan relay default".into()),
+ };
+ let mut out = format!("{now} Team links from before stop working: `tincan link` shows the new one.");
+ // A machine that is off can't hear about it, and won't find the team where it looks when it's back.
+ if !away.is_empty() {
+ out += &format!("\nOffline now: {}. When back, each needs `{cmd}` too, unless it already uses that relay.", away.join(", "));
+ }
+ Ok(out)
}
}
diff --git a/src/main.rs b/src/main.rs
index 02a4742..247b261 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -115,6 +115,9 @@ enum Cmd {
/// Don't configure agents or install the background service
#[arg(long)]
no_setup: bool,
+ /// Your own iroh relay, from the start (see `tincan relay`)
+ #[arg(long)]
+ relay: Option<String>,
},
/// Show the team link to send friends (or, with --me / --code, a one-time code)
Invite {
@@ -153,7 +156,7 @@ enum Cmd {
#[arg(long)]
force: bool,
},
- /// Use your own iroh relay for the team (or `default` for n0's public ones)
+ /// Use your own iroh relay for the team, so its machines never contact n0 (or `default` for n0's public relays)
Relay { url: String },
/// List messages waiting for your approval (when `inbound` is `hold`)
Held,
@@ -328,7 +331,7 @@ async fn cli(cmd: Cmd) -> Result<()> {
let r: Registered = link.call(Request::SetStatus { key, doing, name }).await?;
println!("You are {}.", r.address);
}
- Cmd::Init { team, person, no_setup } if !no_setup && wizard::interactive() => {
+ Cmd::Init { team, person, no_setup, relay: None } if !no_setup && wizard::interactive() => {
wizard::guided(wizard::onboard(Some(true), team, None, person)).await?
}
Cmd::Join { invite, person, no_setup } if !no_setup && wizard::interactive() => {
@@ -345,9 +348,9 @@ async fn cli(cmd: Cmd) -> Result<()> {
Cmd::Setup { dry_run: false, remove: false, no_service: false } if wizard::interactive() => {
wizard::guided(wizard::setup_agents()).await?
}
- Cmd::Init { team, person, no_setup } => {
+ Cmd::Init { team, person, no_setup, relay } => {
let Some(team) = team else { bail!("name the team: `tincan init <team>` (or run it in a terminal to be asked)") };
- let t: TeamInfo = link.call(Request::CreateTeam { name: team, person: default_person(person) }).await?;
+ let t: TeamInfo = link.call(Request::CreateTeam { name: team, person: default_person(person), relay }).await?;
wait_exit(daemon_pid()).await;
println!("Created team {}. You are {} on {}.", t.name, t.person, t.machine);
if !no_setup {
diff --git a/src/net.rs b/src/net.rs
index eb3df38..0216d07 100644
--- a/src/net.rs
+++ b/src/net.rs
@@ -9,8 +9,10 @@ use crate::{
util,
};
use anyhow::{Result, anyhow, bail};
+use futures_lite::{StreamExt, stream::Boxed};
use iroh::{
- Endpoint, EndpointAddr, EndpointId, RelayMap, RelayMode, RelayUrl, SecretKey,
+ Endpoint, EndpointAddr, EndpointId, RelayMode, RelayUrl, SecretKey, Watcher,
+ address_lookup::{self, AddressLookup, EndpointData, EndpointInfo, Item},
endpoint::{ConnectError, ConnectWithOptsError, Connection, RecvStream, SendStream, presets},
protocol::{AcceptError, ProtocolHandler, Router},
};
@@ -90,6 +92,8 @@ struct Link {
pub struct Net {
endpoint: Endpoint,
+ /// The team's own relay, if it has one: teammates are dialed through it, as nothing looks them up on n0's DNS.
+ relay: Option<RelayUrl>,
router: Mutex<Option<Router>>,
/// Endpoints listening for joins on behalf of invite codes, by their (code-derived) id.
invites: Mutex<HashMap<EndpointId, Router>>,
@@ -106,20 +110,56 @@ pub struct Net {
}
pub async fn bind(key: SecretKey, relay: Option<&str>, lan: bool) -> Result<Endpoint> {
- let mut b = Endpoint::builder(presets::N0).secret_key(key);
+ let Some(url) = relay else {
+ let mut b = Endpoint::builder(presets::N0).secret_key(key);
+ if lan {
+ b = b.address_lookup(MdnsAddressLookup::builder());
+ }
+ return Ok(b.bind().await?);
+ };
+ // The team's own relay and nothing of n0's: none of its relays, no publishing or looking up addresses in its DNS.
+ // Teammates are dialed through the relay instead.
+ let url: RelayUrl = url.parse().map_err(|_| anyhow!("not a relay url: {url} (expected e.g. https://relay.example.com)"))?;
+ let mut b = Endpoint::builder(presets::Minimal).secret_key(key.clone()).relay_mode(RelayMode::custom([url]));
if lan {
- b = b.address_lookup(MdnsAddressLookup::builder());
- }
- if let Some(url) = relay {
- // The team's own relay, with n0's public ones as a fallback in case it is down or mistyped.
- let url: RelayUrl = url.parse().map_err(|e| anyhow!("bad relay url {url}: {e}"))?;
- let map = RelayMap::from_iter([url]);
- map.extend(&iroh::defaults::prod::default_relay_map());
- b = b.relay_mode(RelayMode::Custom(map));
+ b = b.address_lookup(NoRelays(MdnsAddressLookup::builder().build(key.public())?));
}
Ok(b.bind().await?)
}
+/// Makes sure this machine reaches `url` as a relay. Nothing falls back to n0's, so a mistyped or unreachable relay
+/// would cut the team off.
+pub async fn check_relay(key: SecretKey, url: &str) -> Result<()> {
+ let endpoint = bind(key, Some(url), false).await?;
+ let reached = tokio::time::timeout(Duration::from_secs(10), endpoint.online()).await.is_ok();
+ endpoint.close().await;
+ if !reached {
+ bail!("couldn't reach relay {url} from this machine: is it running, and is the address right?");
+ }
+ Ok(())
+}
+
+/// mDNS, minus the relay a neighbour advertises: a teammate still on n0's relays (it missed a switch, or runs an older
+/// tincan) must not draw this machine onto them.
+#[derive(Debug)]
+struct NoRelays(MdnsAddressLookup);
+
+impl AddressLookup for NoRelays {
+ fn publish(&self, data: &EndpointData) {
+ self.0.publish(data);
+ }
+
+ fn resolve(&self, id: EndpointId) -> Option<Boxed<Result<Item, address_lookup::Error>>> {
+ let strip = |item: Item| {
+ let (from, at) = (item.provenance(), item.last_updated());
+ let mut info = EndpointInfo::from(item);
+ info.data.clear_relay_urls();
+ Item::new(info, from, at)
+ };
+ Some(self.0.resolve(id)?.map(move |r| r.map(strip)).boxed())
+ }
+}
+
fn log(msg: &str) {
eprintln!("[{}] net: {msg}", util::now_ms());
}
@@ -256,7 +296,7 @@ impl ProtocolHandler for JoinProto {
}
impl Net {
- pub fn start(daemon: &Arc<Daemon>, endpoint: Endpoint, remote: HashMap<EndpointId, Remote>) -> Arc<Net> {
+ pub fn start(daemon: &Arc<Daemon>, endpoint: Endpoint, relay: Option<&str>, remote: HashMap<EndpointId, Remote>) -> Arc<Net> {
let net = Arc::new_cyclic(|weak: &Weak<Net>| Net {
me: endpoint.id(),
router: Mutex::new(Some(
@@ -267,6 +307,7 @@ impl Net {
)),
invites: Default::default(),
endpoint,
+ relay: relay.and_then(|u| u.parse().ok()),
daemon: Arc::downgrade(daemon),
links: Default::default(),
remote: Mutex::new(remote),
@@ -294,6 +335,11 @@ impl Net {
let _ = tokio::time::timeout(limit, self.endpoint.online()).await;
}
+ /// Whether this machine is connected to its relay right now.
+ pub fn relay_connected(&self) -> bool {
+ self.endpoint.home_relay_status().get().iter().any(|s| s.is_connected())
+ }
+
pub async fn shutdown(&self) {
let router = self.router.lock().unwrap().take();
if let Some(r) = router {
@@ -418,7 +464,11 @@ impl Net {
}
async fn dial(self: Arc<Self>, id: EndpointId) {
- match tokio::time::timeout(Duration::from_secs(20), self.endpoint.connect(id, ALPN)).await {
+ let mut addr = EndpointAddr::new(id);
+ if let Some(url) = &self.relay {
+ addr = addr.with_relay_url(url.clone());
+ }
+ match tokio::time::timeout(Duration::from_secs(20), self.endpoint.connect(addr, ALPN)).await {
Ok(Ok(conn)) => {
self.dialing.lock().unwrap().remove(&id);
if let Err(e) = self.clone().run_link(conn, true).await {
diff --git a/src/proto.rs b/src/proto.rs
index ef59ef1..2cb7059 100644
--- a/src/proto.rs
+++ b/src/proto.rs
@@ -144,6 +144,8 @@ pub enum Request {
CreateTeam {
name: String,
person: String,
+ #[serde(default)]
+ relay: Option<String>,
},
Join {
ticket: String,
@@ -276,6 +278,9 @@ pub struct MachineInfo {
pub struct TeamInfo {
pub name: String,
pub relay: Option<String>,
+ /// Whether this machine is on its relay right now (`None` while the network isn't up).
+ #[serde(default)]
+ pub relay_connected: Option<bool>,
pub person: String,
pub machine: String,
pub machines: Vec<MachineInfo>,
@@ -291,7 +296,8 @@ pub struct LinkInfo {
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct InviteInfo {
- /// Four words, like `plum-tiger-lake-orbit`.
+ /// Four words, like `plum-tiger-lake-orbit`. For a team with its own relay, the long form (a code would need n0's
+ /// address lookup to find this machine).
pub code: String,
/// The same invite as a long `tincan1…` string, for when the inviting machine will be offline.
pub ticket: String,
diff --git a/src/setup.rs b/src/setup.rs
index b904c2e..284af7d 100644
--- a/src/setup.rs
+++ b/src/setup.rs
@@ -861,8 +861,16 @@ pub async fn doctor() -> Result<()> {
let others = t.machines.len().saturating_sub(1);
println!("✓ daemon running; team {} with {others} other machine(s), {online} connected", t.name);
print!("{}", render::team(&t).lines().skip(1).map(|l| format!("{l}\n")).collect::<String>());
+ if let Some(relay) = &t.relay
+ && t.relay_connected == Some(false)
+ {
+ println!(" ! can't reach the team's relay {relay}: until it's up, teammates are only found on this network");
+ }
if others > 0 && online == 0 {
println!(" ! no teammate connected: check your internet, or that their machines are on (`tincan doctor` there)");
+ // Nothing tells a machine that was off when the team changed relays where the team went.
+ println!(" ! if the team changed relays while this machine was off, set the same one here: `tincan relay <url>`");
+ println!(" (or `default` for n0's); `tincan team` on a teammate's machine shows which");
}
}
Err(e) if e.to_string().contains("not in a team") => {
diff --git a/src/team.rs b/src/team.rs
index f8413e2..596e0a6 100644
--- a/src/team.rs
+++ b/src/team.rs
@@ -42,7 +42,8 @@ impl<T: Serialize> Signed<T> {
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Meta {
pub name: String,
- /// A self-hosted iroh relay for the team (`https://relay.example.com`); n0's public relays otherwise.
+ /// A self-hosted iroh relay for the team (`https://relay.example.com`), which is then all its machines use: they
+ /// never contact n0. n0's public relays otherwise.
pub relay: Option<String>,
pub ts: i64,
}
@@ -509,17 +510,18 @@ impl Ticket {
Ok(Ticket { team, name, secret, relay, hint_relay, hint_ips, peers })
}
- /// The peers to dial, the first with its hints.
+ /// The peers to dial, the first with its hints. With the team's own relay, all of them are found there.
pub fn addrs(&self) -> Vec<EndpointAddr> {
self.peers
.iter()
.enumerate()
.map(|(i, id)| {
let mut a = EndpointAddr::new(*id);
+ let relay = self.relay.as_deref().or(self.hint_relay.as_deref().filter(|_| i == 0));
+ if let Some(url) = relay.and_then(|u| u.parse().ok()) {
+ a = a.with_relay_url(url);
+ }
if i == 0 {
- if let Some(url) = self.hint_relay.as_deref().and_then(|u| u.parse().ok()) {
- a = a.with_relay_url(url);
- }
for ip in &self.hint_ips {
a = a.with_ip_addr(*ip);
}
@@ -718,6 +720,10 @@ mod tests {
let enc = t.encode();
assert!(enc.len() < 300, "short enough for a link: {}", enc.len());
assert_eq!(t.addrs()[0].ip_addrs().count(), 2);
+ // Every peer through the team's own relay, never the n0 relay the hint names.
+ for a in t.addrs() {
+ assert_eq!(a.relay_urls().map(|u| u.to_string()).collect::<Vec<_>>(), ["https://relay.example.com/"]);
+ }
assert_eq!(Ticket::decode(&format!(" {enc}\n")).unwrap(), t);
assert_eq!(Ticket::decode(&format!("https://example.com/join/#{enc}")).unwrap(), t, "a whole link works too");
assert!(Ticket::decode(&enc[..enc.len() - 10]).is_err());
diff --git a/src/wizard.rs b/src/wizard.rs
index e8bfb77..4549e15 100644
--- a/src/wizard.rs
+++ b/src/wizard.rs
@@ -71,7 +71,7 @@ pub async fn onboard(start: Option<bool>, team: Option<String>, invite: Option<S
};
let sp = spinner();
sp.start("Creating the team...");
- let t: TeamInfo = link.call(Request::CreateTeam { name, person }).await.inspect_err(|e| sp.error(format!("{e:#}")))?;
+ let t: TeamInfo = link.call(Request::CreateTeam { name, person, relay: None }).await.inspect_err(|e| sp.error(format!("{e:#}")))?;
crate::wait_exit(crate::daemon_pid()).await;
sp.stop(format!("Created team {}. You are {} on {}.", t.name, t.person, t.machine));
} else {