use std::io::Read;
use std::path::PathBuf;
use std::time::{Duration, Instant};
use anyhow::{anyhow, Result};
use clap::Subcommand;
use supercode_harness::claude_relay::{gate_decision, gate_denial, QueuedSend};
use supercode_harness::mail_route::{resolve_caller, Caller, Door};
use supercode_harness::mailbox::{
local_machine_name, mail_root, Envelope, MailAddress, MailKind, Mailbox,
};
use supercode_harness::HarnessHomes;
use supercode_harness::mail_send::{EXIT_FAILED, EXIT_REFUSED, EXIT_UNKNOWN};
const EXIT_TIMEOUT: i32 = 6;
const MAX_WAIT: Duration = Duration::from_secs(100);
#[derive(Subcommand)]
pub(crate) enum MessageAction {
#[command(alias = "ls")]
List {
#[arg(long)]
json: bool,
},
Send {
to: String,
body: Option<String>,
#[arg(long)]
subject: Option<String>,
#[arg(long, value_name = "PATH", conflicts_with = "body")]
file: Option<PathBuf>,
#[arg(long = "re", value_name = "MESSAGE_ID")]
in_reply_to: Option<String>,
#[arg(long)]
notify_when_idle: bool,
#[arg(long)]
queue: bool,
#[arg(long, value_name = "KEY")]
id: Option<String>,
},
Reply {
id: String,
body: Option<String>,
#[arg(long, value_name = "PATH", conflicts_with = "body")]
file: Option<PathBuf>,
#[arg(long)]
notify_when_idle: bool,
#[arg(long)]
queue: bool,
},
Thread {
id: String,
#[arg(long)]
json: bool,
},
Delegate {
root: String,
#[arg(long, value_name = "DIR")]
folder: Option<PathBuf>,
#[arg(long, value_name = "PROGRAM")]
harness: Option<String>,
},
Threads {
#[arg(long)]
agent: Option<String>,
#[arg(long)]
json: bool,
},
Inbox {
#[arg(long)]
all: bool,
#[arg(long)]
json: bool,
#[arg(long, value_name = "SESSION")]
session: Option<String>,
#[arg(long, value_name = "N")]
recent: Option<usize>,
},
Show {
#[arg(required = true, value_name = "ID")]
ids: Vec<String>,
#[arg(long)]
json: bool,
#[arg(long)]
replies: bool,
},
Wait {
#[arg(long, value_name = "TO")]
from: Option<String>,
#[arg(long, default_value_t = 100)]
timeout: u64,
},
Setup {
harness: String,
},
#[command(hide = true)]
Hook {
harness: String,
},
#[command(hide = true)]
RelayInbound {
represented: String,
directory: PathBuf,
},
#[command(hide = true)]
RemoteDeliver,
Mcp,
#[command(hide = true)]
Push {
address: String,
id: String,
},
#[command(hide = true)]
Gate {
directory: PathBuf,
},
#[command(hide = true)]
RelayReceipt {
directory: PathBuf,
},
#[command(hide = true)]
Watch,
#[command(hide = true)]
NativeQuestionHook { binding: PathBuf },
Questions,
}
pub(crate) async fn run(action: &MessageAction) -> Result<i32> {
let homes = HarnessHomes::default();
match action {
MessageAction::NativeQuestionHook { binding } => {
let mut text = String::new();
std::io::stdin().read_to_string(&mut text)?;
let output =
supercode_harness::mail_question::hook(binding, serde_json::from_str(&text)?)
.await?;
println!("{output}");
Ok(0)
}
MessageAction::Questions => {
supercode_harness::mail_question::poll().await;
Ok(0)
}
MessageAction::List { json } => list(&homes, *json),
MessageAction::Send {
to,
body,
subject,
file,
in_reply_to,
notify_when_idle,
queue,
id,
} => {
let body = read_body(body.as_deref(), file.as_ref())?;
send(
&homes,
to,
&body,
supercode_harness::mail_send::SendOptions {
subject: subject.clone(),
in_reply_to: in_reply_to.clone(),
notify_when_idle: *notify_when_idle,
queue: *queue,
idempotency_key: id.clone(),
notice: false,
},
)
.await
}
MessageAction::Inbox {
all,
json,
session,
recent,
} => match session {
Some(session) => inbox_of(&homes, session, *json, *recent),
None => inbox(&homes, *all || recent.is_some(), *json, *recent),
},
MessageAction::Show {
ids,
json,
replies: true,
} => show_replies(ids, *json),
MessageAction::Show { ids, json, .. } => show(&homes, ids, *json),
MessageAction::Reply {
id,
body,
file,
notify_when_idle,
queue,
} => {
let mailbox = match caller_mailbox(&homes) {
Ok(mailbox) => mailbox,
Err(message) => {
eprintln!("{message}");
return Ok(EXIT_REFUSED);
}
};
let found = mailbox.find_prefix(id)?;
let [answered] = found.as_slice() else {
eprintln!(
"Not sent: {id} names {} messages in your mailbox. Name the one you answer as \
its envelope shows it.",
found.len()
);
return Ok(EXIT_REFUSED);
};
if answered.envelope.kind == MailKind::Notice {
eprintln!("Not sent: {id} is an automated notice; nothing reads a reply to it.");
return Ok(EXIT_REFUSED);
}
let body = read_body(body.as_deref(), file.as_ref())?;
send(
&homes,
&answered.envelope.from.to_string(),
&body,
supercode_harness::mail_send::SendOptions {
subject: answered.envelope.subject.as_ref().map(|subject| {
if subject.starts_with("Re: ") {
subject.clone()
} else {
format!("Re: {subject}")
}
}),
in_reply_to: Some(answered.envelope.id.clone()),
notify_when_idle: *notify_when_idle,
queue: *queue,
idempotency_key: None,
notice: false,
},
)
.await
}
MessageAction::Thread { id, json } => thread(id, *json),
MessageAction::Delegate {
root,
folder,
harness,
} => delegate(&homes, root, folder.as_deref(), harness.as_deref()),
MessageAction::Threads { agent, json } => threads(&homes, agent.as_deref(), *json),
MessageAction::Wait { from, timeout } => wait(&homes, from.as_deref(), *timeout).await,
MessageAction::RelayInbound {
represented,
directory,
} => relay_inbound(&homes, represented, directory),
MessageAction::RemoteDeliver => remote_deliver(&homes).await,
MessageAction::Push { address, id } => push(&homes, address, id).await,
MessageAction::Mcp => {
let cwd = std::env::current_dir().unwrap_or_default();
supercode_harness::mcp::serve_stdio(
&supercode_harness::mail_mcp::registry(),
&supercode_harness::tools::ToolContext::new(cwd),
)
.await?;
Ok(0)
}
MessageAction::Gate { directory } => gate(directory),
MessageAction::RelayReceipt { directory } => relay_receipt(directory),
MessageAction::Setup { harness } => setup(harness),
MessageAction::Hook { harness } => hook(harness),
MessageAction::Watch => {
tokio::spawn(async {
if let Err(error) = supercode_harness::relay_endpoint::serve_relay_endpoint().await
{
eprintln!("supercode: the relay endpoint stopped: {error}");
std::process::exit(1);
}
});
let mut watcher = supercode_harness::mail_watch::IdleWatcher::new();
#[cfg(unix)]
let parent = std::os::unix::process::parent_id();
let mut ticks: u64 = 0;
loop {
#[cfg(unix)]
if std::os::unix::process::parent_id() != parent {
return Ok(0);
}
if ticks % 5 == 0 {
supercode_harness::mail_question::poll().await;
}
watcher.tick(&homes).await;
if ticks % 5 == 0 {
supercode_harness::mail_agent::register_folder_sessions(&homes);
supercode_harness::mail_agent::copy_typed_lines(&homes);
supercode_harness::mail_agent::close_idle_threads(&homes);
}
supercode_harness::mail_watch::deliver_waiting_user_turns(&homes).await;
supercode_harness::mail_watch::wake_waiting_hook_mail(&homes).await;
if ticks % 30 == 0 {
supercode_harness::claude_relay::retire_relays_of_ended_sessions(&homes).await;
}
ticks = ticks.wrapping_add(1);
tokio::time::sleep(Duration::from_secs(2)).await;
}
}
}
}
fn open_session(
homes: &HarnessHomes,
program: &str,
directory: &std::path::Path,
key: &str,
input: &str,
ready: &dyn Fn(&supercode_harness::mailbox::MailAddress) -> std::result::Result<(), String>,
) -> std::result::Result<supercode_harness::mailbox::MailAddress, String> {
let stem = std::path::Path::new(program)
.file_stem()
.and_then(|stem| stem.to_str())
.unwrap_or(program)
.to_string();
let claude = stem == "claude" || stem == "claude-code";
let mut extra = Vec::new();
let mut known = None;
if claude {
let mut random = [0u8; 16];
getrandom::getrandom(&mut random).map_err(|error| error.to_string())?;
random[6] = (random[6] & 0x0f) | 0x40;
random[8] = (random[8] & 0x3f) | 0x80;
let hex: String = random.iter().map(|byte| format!("{byte:02x}")).collect();
let session_id = format!(
"{}-{}-{}-{}-{}",
&hex[..8],
&hex[8..12],
&hex[12..16],
&hex[16..20],
&hex[20..]
);
known = Some(
supercode_harness::mailbox::MailAddress::new(
supercode_harness::mailbox::local_machine_name(),
"claude-code",
&session_id,
)
.map_err(|error| error.to_string())?,
);
extra = vec!["--".to_string(), "--session-id".to_string(), session_id];
}
if let Some(address) = &known {
ready(address)?;
}
let program_path =
supercode_harness::claude_relay::supercode_program().map_err(|error| error.to_string())?;
let output = std::process::Command::new(program_path)
.arg("--cwd")
.arg(directory)
.args([
"open", "--new", program, "--key", key, "--input", input, "--detach",
])
.args(&extra)
.stdin(std::process::Stdio::null())
.output()
.map_err(|error| error.to_string())?;
if !output.status.success() {
return Err(format!(
"the session did not start: {}",
String::from_utf8_lossy(&output.stderr).trim()
));
}
if let Some(address) = known {
return Ok(address);
}
let printed: serde_json::Value = serde_json::from_slice(&output.stdout).unwrap_or_default();
let pane = printed["pane"]
.as_str()
.ok_or_else(|| "the new pane was not reported".to_string())?
.to_string();
let started = Instant::now();
while started.elapsed() < Duration::from_secs(60) {
if let Some(session) = supercode_harness::mail_route::LiveSessions::read(homes)
.all()
.iter()
.find(|session| {
supercode_harness::mail_route::daemon_pane(session).as_deref() == Some(&pane)
})
{
ready(&session.address)?;
return Ok(session.address.clone());
}
std::thread::sleep(Duration::from_millis(500));
}
Err(format!(
"{program} started in pane {pane}, but no session appeared there within a minute"
))
}
fn delegate(
homes: &HarnessHomes,
root: &str,
folder: Option<&std::path::Path>,
harness: Option<&str>,
) -> Result<i32> {
use supercode_harness::mail_agent;
let mailbox = match caller_mailbox(homes) {
Ok(mailbox) => mailbox,
Err(message) => {
eprintln!("{message}");
return Ok(EXIT_REFUSED);
}
};
let found = mailbox.find_prefix(root)?;
let [stored] = found.as_slice() else {
eprintln!(
"Not delegated: {root} names {} messages in your mailbox. Name the root as your inbox \
shows it.",
found.len()
);
return Ok(EXIT_REFUSED);
};
let thread_id = stored.envelope.thread_id().to_string();
let opened = match mail_agent::thread(&thread_id) {
Some(thread) => Some(thread),
None => mail_agent::root_of_main(mailbox.address(), &stored.envelope)?,
};
let Some(thread) = opened else {
eprintln!(
"Not delegated: {} is not in a thread of an agent. Only a root an agent received can \
be delegated.",
supercode_harness::mailbox::short_id(&stored.envelope.id)
);
return Ok(EXIT_REFUSED);
};
let Some(agent) = mail_agent::load(&thread.agent) else {
eprintln!(
"Not delegated: agent {} is no longer declared.",
thread.agent
);
return Ok(EXIT_REFUSED);
};
let caller = mailbox.address().clone();
if agent.main_session != caller || thread.holder != caller {
eprintln!(
"Not delegated: only {}'s main session delegates a thread it holds.",
agent.name
);
return Ok(EXIT_REFUSED);
}
let program = harness
.map(str::to_string)
.or_else(|| agent.harness.clone())
.unwrap_or_else(|| "claude".to_string());
let directory = folder
.map(std::path::Path::to_path_buf)
.or_else(|| agent.folder.clone())
.or_else(|| std::env::current_dir().ok())
.ok_or_else(|| anyhow::anyhow!("no directory to start the session in"))?;
let shown_root = supercode_harness::mailbox::short_id(&thread.id);
let input = format!(
"You are a session of agent {name}, holding its thread {shown_root}. Read it: supercode \
message thread {shown_root}. Answer in it with supercode message reply <id>; what you \
send stays in this thread, and {name}'s main session is CC on it.",
name = agent.name
);
let thread_id = thread.id.clone();
let hand_over =
|holder: &supercode_harness::mailbox::MailAddress| -> std::result::Result<(), String> {
let holder_mailbox = Mailbox::open(&supercode_harness::mailbox::mail_root(), holder)
.map_err(|error| error.to_string())?;
for line in mailbox.list().map_err(|error| error.to_string())? {
if line.envelope.thread_id() == thread_id {
let mut envelope = line.envelope.clone();
if envelope.kind == supercode_harness::mailbox::MailKind::User {
envelope.kind = supercode_harness::mailbox::MailKind::Typed;
}
holder_mailbox
.deliver_read(&envelope)
.map_err(|error| error.to_string())?;
}
}
mail_agent::delegate_to(&thread_id, holder, true).map_err(|error| error.to_string())?;
Ok(())
};
let holder = match open_session(
homes,
&program,
&directory,
&format!("delegate:{}", thread.id),
&input,
&hand_over,
) {
Ok(holder) => holder,
Err(message) => {
mail_agent::delegate_to(&thread.id, &caller, false)?;
eprintln!("Not delegated: {message}");
return Ok(EXIT_FAILED);
}
};
let session_id = holder.session_id.clone();
println!(
"Delegated thread {shown_root} to a new session of {} ({holder}) in {}. You are CC on it. \
Continue there: supercode open {session_id}",
agent.name,
directory.display()
);
Ok(0)
}
fn threads(homes: &HarnessHomes, agent: Option<&str>, json: bool) -> Result<i32> {
use supercode_harness::mail_agent;
let name = match agent {
Some(name) => name.to_string(),
None => {
let caller = caller_mailbox(homes)
.map(|mailbox| mailbox.address().clone())
.ok();
match caller.as_ref().and_then(mail_agent::agent_of_session) {
Some(agent) => agent.name,
None => {
eprintln!(
"Name the agent with --agent: this session is not one of an agent's."
);
return Ok(EXIT_REFUSED);
}
}
}
};
let rows: Vec<serde_json::Value> = mail_agent::threads_of(&name)
.into_iter()
.map(|thread| {
let newest = supercode_harness::mail_transcript::find_messages(
&supercode_harness::mailbox::mail_root(),
&thread.id,
)
.ok()
.and_then(|found| found.into_iter().next())
.map(|(_, stored)| stored.envelope.body.lines().next().unwrap_or("").to_string());
serde_json::json!({
"id": thread.id,
"holder": thread.holder.to_string(),
"participants": thread.participants.iter().map(|p| serde_json::json!({
"address": p.address.to_string(),
"role": match p.role { mail_agent::Role::To => "to", mail_agent::Role::Cc => "cc" },
})).collect::<Vec<_>>(),
"surface": thread.surface,
"opened_at": supercode_interchange::sidecar::ms_to_rfc3339(thread.created_at_ms as i64),
"root": newest,
})
})
.collect();
if json {
println!("{}", serde_json::to_string_pretty(&rows)?);
return Ok(0);
}
if rows.is_empty() {
println!("Agent {name} has no threads.");
return Ok(0);
}
for row in rows {
let id = row["id"].as_str().unwrap_or_default();
let participants: Vec<String> = row["participants"]
.as_array()
.into_iter()
.flatten()
.map(|p| {
format!(
"{} ({})",
p["address"].as_str().unwrap_or_default(),
p["role"].as_str().unwrap_or_default()
)
})
.collect();
println!(
"{} opened {} held by {}\n {}\n {}",
supercode_harness::mailbox::short_id(id),
row["opened_at"].as_str().unwrap_or_default(),
row["holder"].as_str().unwrap_or_default(),
participants.join(", "),
row["root"].as_str().unwrap_or("(no root message)")
);
}
Ok(0)
}
#[derive(Subcommand)]
pub(crate) enum AgentAction {
Declare {
name: String,
#[arg(
long,
value_name = "SESSION",
required_unless_present = "open",
conflicts_with = "open"
)]
main: Option<String>,
#[arg(long, value_name = "PROGRAM")]
open: Option<String>,
#[arg(long, value_name = "TEXT", requires = "open")]
input: Option<String>,
#[arg(long, value_name = "DIR")]
folder: Option<PathBuf>,
#[arg(long, value_name = "PROGRAM")]
harness: Option<String>,
#[arg(long, value_name = "MINUTES")]
idle_minutes: Option<u64>,
#[arg(long)]
owners_account_manager: bool,
},
Show {
name: Option<String>,
#[arg(long)]
json: bool,
},
}
pub(crate) fn run_agent(action: &AgentAction) -> Result<i32> {
use supercode_harness::mail_agent;
let homes = HarnessHomes::default();
match action {
AgentAction::Declare {
name,
main,
open,
input,
folder,
harness,
idle_minutes,
owners_account_manager,
} => {
let main = match (main, open) {
(Some(main), _) => main.clone(),
(None, Some(program)) => {
let live = supercode_harness::mail_route::LiveSessions::read(&homes);
let kept = mail_agent::load(name)
.map(|agent| agent.main_session)
.filter(|main| {
live.all().iter().any(|session| &session.address == main)
|| mail_agent::resumable(main)
});
match kept {
Some(main) => main.to_string(),
None => {
let directory = match folder {
Some(folder) => std::fs::canonicalize(folder)?,
None => std::env::current_dir()?,
};
let first = input.clone().unwrap_or_else(|| {
format!(
"You are the main session of agent {name}. Roots addressed to it \
reach you: answer each or delegate it (supercode message delegate)."
)
});
match open_session(
&homes,
program,
&directory,
&format!("agent:{name}"),
&first,
&|_| Ok(()),
) {
Ok(address) => address.to_string(),
Err(message) => {
eprintln!("Not declared: {message}");
return Ok(EXIT_FAILED);
}
}
}
}
}
(None, None) => unreachable!("clap requires --main or --open"),
};
let main = &main;
let main_session = match supercode_harness::mailbox::MailAddress::parse(main) {
Ok(address) => address,
Err(_) => {
match supercode_harness::mail_route::LiveSessions::read(&homes).resolve(main) {
Ok(session) => session.address.clone(),
Err(
supercode_harness::mail_route::Unresolved::Stale(message)
| supercode_harness::mail_route::Unresolved::Unknown(message),
) => {
eprintln!("{message}");
return Ok(EXIT_UNKNOWN);
}
}
}
};
let folder = match folder {
Some(folder) => Some(std::fs::canonicalize(folder)?),
None => None,
};
let agent = mail_agent::Agent {
name: name.clone(),
main_session,
folder,
harness: harness.clone(),
idle_minutes: *idle_minutes,
};
mail_agent::declare(&agent)?;
if *owners_account_manager {
mail_agent::set_owners_account_manager(name)?;
}
println!(
"Declared agent {name} ({}): roots go to {}.{}",
agent.address()?,
agent.main_session,
if *owners_account_manager {
" It is the owner's account manager."
} else {
""
}
);
Ok(0)
}
AgentAction::Show { name, json } => {
let agents: Vec<mail_agent::Agent> = match name {
Some(name) => match mail_agent::load(name) {
Some(agent) => vec![agent],
None => {
eprintln!("No agent named {name} is declared on this machine.");
return Ok(EXIT_UNKNOWN);
}
},
None => mail_agent::all_agents(),
};
let account_manager = mail_agent::owners_account_manager().map(|agent| agent.name);
if *json {
println!("{}", serde_json::to_string_pretty(&agents)?);
return Ok(0);
}
if agents.is_empty() {
println!("No agents are declared on this machine.");
}
for agent in agents {
println!(
"{} {}\n main: {}\n folder: {}\n threads: {}{}",
agent.name,
agent.address()?,
agent.main_session,
agent
.folder
.as_ref()
.map_or("(none)".to_string(), |folder| folder.display().to_string()),
mail_agent::threads_of(&agent.name).len(),
if account_manager.as_deref() == Some(agent.name.as_str()) {
"\n the owner's account manager"
} else {
""
}
);
}
Ok(0)
}
}
}
fn session_rows(homes: &HarnessHomes) -> Vec<serde_json::Value> {
let panes_read = std::thread::spawn(daemon_pane_processes);
let live = supercode_harness::mail_route::LiveSessions::read(homes);
let mut panes = Some(panes_read.join().unwrap_or_default());
let mut parents = None;
live.all()
.iter()
.map(|peer| {
serde_json::json!({
"name": peer.name,
"harness": peer.address.harness,
"status": peer.status,
"delivery": peer.door.name(),
"address": peer.address.to_string(),
"pane": session_pane_in(peer.tmux.as_deref(), peer.pid, &mut panes, &mut parents),
"last_message_at_ms": peer.last_message_at_ms(homes),
"pending_request": peer.pending_request(homes),
})
})
.collect()
}
fn team_machines() -> Vec<String> {
supercode_harness::slow_log::timed("teams machines list", team_machines_now)
}
fn team_machines_now() -> Vec<String> {
let Ok(program) = supercode_harness::claude_relay::supercode_program() else {
return Vec::new();
};
let Ok(output) = std::process::Command::new(program)
.args(["teams", "machines", "list", "--json"])
.stdin(std::process::Stdio::null())
.stderr(std::process::Stdio::null())
.output()
else {
return Vec::new();
};
let local = supercode_harness::mailbox::local_machine_name();
let machines: Vec<String> = serde_json::from_slice::<serde_json::Value>(&output.stdout)
.ok()
.and_then(|value| value["items"].as_array().cloned())
.unwrap_or_default()
.into_iter()
.filter(|machine| machine["enrollment"] == "active" && machine["connection"] == "online")
.filter_map(|machine| machine["name"].as_str().map(str::to_string))
.filter(|name| *name != local)
.collect();
machines
}
fn team_rows() -> Vec<serde_json::Value> {
let handles: Vec<_> = team_machines()
.into_iter()
.map(|machine| {
std::thread::spawn(move || {
supercode_harness::mailbox::teams_mail(&machine, &serde_json::json!({"op": "list"}))
.ok()
.and_then(|answer| answer["sessions"].as_array().cloned())
.unwrap_or_default()
})
})
.collect();
handles
.into_iter()
.flat_map(|handle| handle.join().unwrap_or_default())
.collect()
}
fn list(homes: &HarnessHomes, json: bool) -> Result<i32> {
let team = std::thread::spawn(team_rows);
let mut rows = session_rows(homes);
rows.extend(team.join().unwrap_or_default());
if json {
println!("{}", serde_json::to_string_pretty(&rows)?);
return Ok(0);
}
println!(
"{:<34} {:<12} {:<8} {:<9} {:<16} ADDRESS",
"NAME", "HARNESS", "STATUS", "DELIVERY", "PANE"
);
let text =
|row: &serde_json::Value, key: &str| row[key].as_str().unwrap_or_default().to_string();
for row in &rows {
println!(
"{:<34} {:<12} {:<8} {:<9} {:<16} {}",
text(row, "name"),
text(row, "harness"),
text(row, "status"),
text(row, "delivery"),
text(row, "pane"),
text(row, "address")
);
}
Ok(0)
}
fn read_body(body: Option<&str>, file: Option<&PathBuf>) -> Result<String> {
let text = match (body, file) {
(Some(body), _) => body.to_string(),
(None, Some(path)) => std::fs::read_to_string(path)
.map_err(|error| anyhow!("could not read {}: {error}", path.display()))?,
(None, None) => {
let mut text = String::new();
std::io::stdin().read_to_string(&mut text)?;
text
}
};
let text = text.trim_end_matches('\n').to_string();
if text.trim().is_empty() {
return Err(anyhow!("Nothing was sent: the message is empty."));
}
Ok(text)
}
fn print_outcome(outcome: supercode_harness::mail_send::Outcome) -> i32 {
if outcome.code == 0 {
println!("{}", outcome.text);
} else {
eprintln!("{}", outcome.text);
}
outcome.code
}
async fn send(
homes: &HarnessHomes,
to: &str,
body: &str,
options: supercode_harness::mail_send::SendOptions,
) -> Result<i32> {
let caller = match resolve_caller(homes, &supercode_harness::mail_route::process_ancestry()) {
Ok(caller) => caller,
Err(message) => {
eprintln!("{message}");
return Ok(EXIT_REFUSED);
}
};
let to = team_address(homes, to).unwrap_or_else(|| to.to_string());
let outcome = supercode_harness::mail_send::send(homes, &caller, &to, body, options).await?;
Ok(print_outcome(outcome))
}
fn team_address(homes: &HarnessHomes, to: &str) -> Option<String> {
if to.contains('@') || to.starts_with("sc:") {
return None;
}
let short = |row: &serde_json::Value| {
row["name"]
.as_str()
.unwrap_or_default()
.split('@')
.next()
.unwrap_or_default()
.to_string()
};
if session_rows(homes).iter().any(|row| short(row) == to) {
return None;
}
let found: Vec<String> = team_rows()
.iter()
.filter(|row| short(row) == to)
.filter_map(|row| row["address"].as_str().map(str::to_string))
.collect();
match found.as_slice() {
[only] => Some(only.clone()),
_ => None,
}
}
pub(crate) fn session_pane(
tmux: Option<&str>,
pid: Option<u32>,
panes: &mut Option<Vec<(u32, String)>>,
) -> Option<String> {
session_pane_in(tmux, pid, panes, &mut None)
}
fn session_pane_in(
tmux: Option<&str>,
pid: Option<u32>,
panes: &mut Option<Vec<(u32, String)>>,
parents: &mut Option<std::collections::HashMap<u32, u32>>,
) -> Option<String> {
if let Some(pane) = tmux
.and_then(|tmux| tmux.split(':').next())
.filter(|session| crate::open::is_daemon_pane(session))
{
return Some(pane.to_string());
}
let pid = pid?;
let panes = panes.get_or_insert_with(daemon_pane_processes);
if panes.is_empty() {
return None;
}
let parents = parents.get_or_insert_with(supercode_harness::mail_route::parent_table);
let ancestry = supercode_harness::mail_route::ancestry_in(pid, parents);
ancestry.iter().find_map(|ancestor| {
panes
.iter()
.find(|(root, _)| root == ancestor)
.map(|(_, pane)| pane.clone())
})
}
fn daemon_pane_processes() -> Vec<(u32, String)> {
supercode_harness::slow_log::timed("teams panes ls --processes", daemon_pane_processes_now)
}
fn daemon_pane_processes_now() -> Vec<(u32, String)> {
let Ok(program) = std::env::current_exe() else {
return Vec::new();
};
let Ok(output) = std::process::Command::new(program)
.args(["teams", "panes", "ls", "--processes"])
.stdin(std::process::Stdio::null())
.stderr(std::process::Stdio::null())
.output()
else {
return Vec::new();
};
serde_json::from_slice::<Vec<serde_json::Value>>(&output.stdout)
.unwrap_or_default()
.into_iter()
.filter_map(|row| {
let pid = u32::try_from(row["pid"].as_u64()?).ok()?;
Some((pid, row["pane"].as_str()?.to_string()))
})
.collect()
}
pub(crate) fn team_session(homes: &HarnessHomes, wanted: &str) -> Option<serde_json::Value> {
let Some(machine) = other_machine(wanted) else {
let address = team_address(homes, wanted)?;
return team_rows()
.into_iter()
.find(|row| row["address"].as_str() == Some(&address));
};
let rows = supercode_harness::mailbox::teams_mail(&machine, &serde_json::json!({"op": "list"}))
.ok()?["sessions"]
.as_array()
.cloned()
.unwrap_or_default();
let address = MailAddress::parse(wanted)
.ok()
.map(|address| address.to_string());
rows.into_iter().find(|row| match &address {
Some(address) => row["address"].as_str() == Some(address),
None => {
row["name"].as_str().and_then(|name| name.split('@').next()) == wanted.split('@').next()
}
})
}
pub(crate) fn other_machine(wanted: &str) -> Option<String> {
let machine = match MailAddress::parse(wanted) {
Ok(address) => address.machine,
Err(_) => supercode_harness::mailbox::normal_machine_name(wanted.rsplit_once('@')?.1),
};
(machine != local_machine_name()).then_some(machine)
}
fn caller_mailbox(homes: &HarnessHomes) -> std::result::Result<Mailbox, String> {
let caller = resolve_caller(homes, &supercode_harness::mail_route::process_ancestry())?;
Mailbox::open(&mail_root(), &caller.address).map_err(|error| error.to_string())
}
fn inbox(homes: &HarnessHomes, all: bool, json: bool, last: Option<usize>) -> Result<i32> {
let mailbox = match caller_mailbox(homes) {
Ok(mailbox) => mailbox,
Err(message) => {
eprintln!("{message}");
return Ok(EXIT_REFUSED);
}
};
let transcript = supercode_harness::mail_transcript::read(homes, mailbox.address());
if all {
if let Some(mail) = &transcript {
supercode_harness::mail_transcript::file_typed_lines(&mailbox, mail)?;
}
}
let claimed = mailbox.claim_unread()?;
let stored = if all {
let mut stored: Vec<_> = mailbox
.list()?
.into_iter()
.filter(|stored| {
stored.state == supercode_harness::mailbox::MailState::Read
|| (stored.envelope.kind == MailKind::User
&& stored
.path
.parent()
.and_then(|dir| dir.file_name())
.is_some_and(|dir| dir == "claimed"))
})
.collect();
if let Some(last) = last {
stored.drain(..stored.len().saturating_sub(last));
}
stored.extend(claimed.iter().cloned());
stored.sort_by_key(|stored| stored.envelope.created_at_ms);
stored
} else {
claimed.clone()
};
let deliveries = supercode_harness::mail_transcript::deliveries(
mailbox.address(),
&stored,
transcript.as_ref(),
);
if json {
let rows: Vec<_> = stored
.iter()
.map(|stored| message_row(mailbox.address(), stored, &deliveries))
.collect();
println!("{}", serde_json::to_string_pretty(&rows)?);
} else if stored.is_empty() {
println!("No unread messages.");
} else {
for stored in &stored {
println!("{}\n", listed(&stored.envelope, &deliveries));
}
}
for stored in &claimed {
mailbox.acknowledge(stored)?;
}
Ok(0)
}
fn listed(envelope: &Envelope, deliveries: &Deliveries) -> String {
let sent = supercode_interchange::sidecar::ms_to_rfc3339(envelope.created_at_ms as i64);
let native = supercode_harness::mail_question::delivered_at(envelope)
.map(|at_ms| supercode_harness::mail_transcript::Delivery::Delivered { at_ms });
let delivered = native
.as_ref()
.or_else(|| deliveries.get(&envelope.id))
.map(supercode_harness::mail_transcript::Delivery::describe)
.unwrap_or_else(|| "unknown".to_string());
if envelope.kind == MailKind::Answer {
return format!("{}\n(sent {sent})", envelope.render());
}
if envelope.kind != MailKind::User {
return format!(
"{}\n(sent {sent}; delivered to the model: {delivered})",
envelope.render()
);
}
format!(
"<user-message id=\"{}\" from-name=\"{}\"{} sent=\"{sent}\" delivered=\"{delivered}\">\n{}\n</user-message>",
supercode_harness::mailbox::short_id(&envelope.id),
printable(&envelope.from_name),
envelope.in_reply_to.as_deref().map_or(String::new(), |parent| format!(
" in-reply-to=\"{}\"{}",
supercode_harness::mailbox::short_id(parent),
if envelope.in_reply_to_inferred { " in-reply-to-inferred=\"true\"" } else { "" }
)),
supercode_harness::mailbox::escape_body(&envelope.body),
)
}
type Deliveries = std::collections::BTreeMap<String, supercode_harness::mail_transcript::Delivery>;
fn message_row(
address: &MailAddress,
stored: &supercode_harness::mailbox::StoredEnvelope,
deliveries: &Deliveries,
) -> serde_json::Value {
serde_json::json!({
"session": address.to_string(),
"state": stored.state,
"delivery": supercode_harness::mail_question::delivered_at(&stored.envelope)
.map(|at_ms| supercode_harness::mail_transcript::Delivery::Delivered { at_ms })
.as_ref().or_else(|| deliveries.get(&stored.envelope.id)),
"envelope": stored.envelope,
"rendered": listed(&stored.envelope, deliveries),
})
}
fn inbox_of(homes: &HarnessHomes, session: &str, json: bool, last: Option<usize>) -> Result<i32> {
let address = match MailAddress::parse(session) {
Ok(address) => address,
Err(_) => match supercode_harness::mail_route::LiveSessions::read(homes).resolve(session) {
Ok(live) => live.address.clone(),
Err(_) => {
eprintln!(
"No running session here is named \"{session}\". Name it by its address \
(sc:<machine>:<harness>:<id>), which also works after it has ended and on \
the team's other machines; supercode message list shows the running ones."
);
return Ok(EXIT_UNKNOWN);
}
},
};
let rows = if address.machine == local_machine_name() {
inbox_rows(homes, &address, last)?
} else {
let request =
serde_json::json!({"op": "inbox", "session": address.to_string(), "recent": last});
match supercode_harness::mailbox::teams_mail(&address.machine, &request) {
Ok(answer) if answer["code"].as_i64() == Some(0) => {
answer["rows"].as_array().cloned().unwrap_or_default()
}
Ok(answer) => {
eprintln!(
"{}",
answer["text"].as_str().unwrap_or("its machine refused")
);
return Ok(EXIT_UNKNOWN);
}
Err(error) => {
eprintln!(
"{address} is on machine {}, which did not answer: {error}",
address.machine
);
return Ok(EXIT_UNKNOWN);
}
}
};
if json {
println!("{}", serde_json::to_string_pretty(&rows)?);
} else if rows.is_empty() {
println!("{address} has no messages.");
} else {
for row in &rows {
if row["direction"] == "out" {
println!("Sent to {}:", row["session"].as_str().unwrap_or_default());
}
println!("{}\n", row["rendered"].as_str().unwrap_or_default());
}
}
Ok(0)
}
const MAX_RECEIVERS_READ: usize = 6;
fn inbox_rows(
homes: &HarnessHomes,
address: &MailAddress,
last: Option<usize>,
) -> Result<Vec<serde_json::Value>> {
let name = supercode_harness::mail_route::LiveSessions::read(homes)
.all()
.iter()
.find(|session| &session.address == address)
.map(|session| session.name.clone())
.unwrap_or_else(|| {
let short: String = address.session_id.chars().take(8).collect();
format!("{}-{short}@{}", address.harness, address.machine)
});
let root = mail_root();
let mailbox = Mailbox::open(&root, address)?;
let transcript = supercode_harness::mail_transcript::read(homes, address);
if let Some(mail) = &transcript {
supercode_harness::mail_transcript::file_typed_lines(&mailbox, mail)?;
supercode_harness::mail_transcript::file_answers(&root, address, &name, mail)?;
}
let received: Vec<_> = mailbox
.list()?
.into_iter()
.filter(|stored| {
!(stored.envelope.kind == MailKind::Question && &stored.envelope.from == address)
})
.collect();
let mut deliveries =
supercode_harness::mail_transcript::deliveries(address, &received, transcript.as_ref());
let sent = supercode_harness::mail_transcript::sent_by(&root, address);
let mut timeline: Vec<(
&MailAddress,
&supercode_harness::mailbox::StoredEnvelope,
&str,
)> = received
.iter()
.map(|stored| (address, stored, "in"))
.chain(sent.iter().map(|(to, stored)| (to, stored, "out")))
.collect();
timeline.sort_by_key(|(_, stored, _)| stored.envelope.created_at_ms);
if let Some(last) = last {
timeline.drain(..timeline.len().saturating_sub(last));
}
let mut receivers: Vec<&MailAddress> = Vec::new();
for (to, _, direction) in timeline.iter().rev() {
if *direction == "out" && !receivers.contains(to) && receivers.len() < MAX_RECEIVERS_READ {
receivers.push(to);
}
}
for to in receivers {
let theirs: Vec<supercode_harness::mailbox::StoredEnvelope> = timeline
.iter()
.filter(|(receiver, _, direction)| *direction == "out" && *receiver == to)
.map(|(_, stored, _)| (*stored).clone())
.collect();
let mail = supercode_harness::mail_transcript::read(homes, to);
deliveries.extend(supercode_harness::mail_transcript::deliveries(
to,
&theirs,
mail.as_ref(),
));
}
for (_, stored, direction) in &timeline {
if *direction == "out" && !deliveries.contains_key(&stored.envelope.id) {
deliveries.insert(
stored.envelope.id.clone(),
supercode_harness::mail_transcript::Delivery::NotRead,
);
}
}
Ok(timeline
.iter()
.map(|(mailbox, stored, direction)| {
let mut row = message_row(mailbox, stored, &deliveries);
row["direction"] = serde_json::json!(direction);
row
})
.collect())
}
fn thread(id: &str, json: bool) -> Result<i32> {
let root_dir = mail_root();
let mut all: std::collections::HashMap<
String,
(MailAddress, supercode_harness::mailbox::StoredEnvelope),
> = std::collections::HashMap::new();
for mailbox in supercode_harness::mailbox::all_mailboxes(&root_dir) {
for stored in mailbox.list().unwrap_or_default() {
all.entry(stored.envelope.id.clone())
.or_insert((mailbox.address().clone(), stored));
}
}
let matches: Vec<&String> = all.keys().filter(|key| key.starts_with(id)).collect();
let [start] = matches.as_slice() else {
eprintln!(
"{id} names {} messages here; give one message's id.",
matches.len()
);
return Ok(EXIT_UNKNOWN);
};
let mut root = (*start).clone();
let mut seen = std::collections::HashSet::new();
while let Some(parent) = all
.get(&root)
.and_then(|(_, stored)| stored.envelope.in_reply_to.clone())
.filter(|parent| all.contains_key(parent))
{
if !seen.insert(parent.clone()) {
break;
}
root = parent;
}
let thread_of_root = all[&root].1.envelope.thread_id().to_string();
let mut children: std::collections::HashMap<&str, Vec<&str>> = std::collections::HashMap::new();
for (key, (_, stored)) in &all {
if let Some(parent) = &stored.envelope.in_reply_to {
children
.entry(parent.as_str())
.or_default()
.push(key.as_str());
}
}
let mut members: std::collections::HashSet<&str> = std::collections::HashSet::new();
let mut queue: Vec<&str> = vec![root.as_str()];
queue.extend(
all.iter()
.filter(|(_, (_, stored))| {
stored.envelope.thread.as_deref() == Some(thread_of_root.as_str())
})
.map(|(key, _)| key.as_str()),
);
while let Some(next) = queue.pop() {
if members.insert(next) {
queue.extend(children.get(next).cloned().unwrap_or_default());
}
}
let mut conversation: Vec<&(MailAddress, supercode_harness::mailbox::StoredEnvelope)> =
members.iter().map(|key| &all[*key]).collect();
conversation.sort_by_key(|(_, stored)| stored.envelope.created_at_ms);
let deliveries = Deliveries::new();
if json {
let rows: Vec<_> = conversation
.iter()
.map(|(mailbox, stored)| message_row(mailbox, stored, &deliveries))
.collect();
println!("{}", serde_json::to_string_pretty(&rows)?);
} else {
for (mailbox, stored) in &conversation {
println!("To {mailbox}:\n{}\n", listed(&stored.envelope, &deliveries));
}
}
Ok(0)
}
fn show(homes: &HarnessHomes, ids: &[String], json: bool) -> Result<i32> {
let mut rows = show_rows(homes, ids)?;
let wanted: Vec<String> = rows
.iter()
.filter(|row| row["found"] == false && row["ambiguous"].is_null())
.filter_map(|row| row["id"].as_str().map(str::to_string))
.collect();
if !wanted.is_empty() {
let handles: Vec<_> = team_machines()
.into_iter()
.map(|machine| {
let request = serde_json::json!({"op": "show", "ids": wanted});
std::thread::spawn(move || {
supercode_harness::mailbox::teams_mail(&machine, &request).ok()
})
})
.collect();
for handle in handles {
let Some(answer) = handle.join().ok().flatten() else {
continue;
};
for there in answer["rows"].as_array().cloned().unwrap_or_default() {
if there["found"] != true && there["ambiguous"].is_null() {
continue;
}
if let Some(row) = rows
.iter_mut()
.find(|row| row["id"] == there["id"] && row["found"] == false)
{
*row = there;
}
}
}
}
let missing = rows.iter().any(|row| row["found"] != true);
if json {
println!("{}", serde_json::to_string_pretty(&rows)?);
} else {
for row in &rows {
let id = row["id"].as_str().unwrap_or_default();
if row["found"] == true {
println!(
"In the inbox of {} on {}:\n{}\n",
row["message"]["session"].as_str().unwrap_or_default(),
row["machine"].as_str().unwrap_or_default(),
row["message"]["rendered"].as_str().unwrap_or_default()
);
} else if let Some(ambiguous) = row["ambiguous"].as_array() {
let ids: Vec<&str> = ambiguous.iter().filter_map(|id| id.as_str()).collect();
println!("{id} is ambiguous: {}. Give more of it.\n", ids.join(", "));
} else {
println!(
"{id}: no mailbox here or on the team's online machines holds it (a prefix \
needs the kind and at least {} hex digits).\n",
supercode_harness::mail_transcript::MIN_PREFIX_DIGITS
);
}
}
}
Ok(if missing { EXIT_UNKNOWN } else { 0 })
}
fn show_replies(ids: &[String], json: bool) -> Result<i32> {
let root = mail_root();
let mut rows = Vec::new();
for id in ids {
let mut found = supercode_harness::mail_transcript::find_messages(&root, id)?;
if found.len() != 1 {
rows.push(serde_json::json!({"id": id, "found": false}));
continue;
}
let (_, asked) = found.remove(0);
let asked_id = asked.envelope.id.clone();
let asker = asked.envelope.from.clone();
let names_it =
|reply: &str| reply == asked_id || (reply.len() >= 10 && asked_id.starts_with(reply));
let replies: Vec<serde_json::Value> = Mailbox::open(&root, &asker)
.and_then(|mailbox| mailbox.list())
.unwrap_or_default()
.into_iter()
.filter(|stored| stored.envelope.in_reply_to.as_deref().is_some_and(names_it))
.map(|stored| {
serde_json::json!({
"id": stored.envelope.id,
"from": stored.envelope.from.to_string(),
"from_name": stored.envelope.from_name,
"created_at_ms": stored.envelope.created_at_ms,
"body": stored.envelope.body,
})
})
.collect();
rows.push(serde_json::json!({
"id": id,
"found": true,
"message": asked_id,
"asker": asker.to_string(),
"replies": replies,
}));
}
let missing = rows.iter().any(|row| row["found"] != true);
if json {
println!("{}", serde_json::to_string_pretty(&rows)?);
} else {
for row in &rows {
let id = row["id"].as_str().unwrap_or_default();
if row["found"] != true {
println!("{id}: no mailbox on this machine holds it.\n");
continue;
}
let replies = row["replies"].as_array().cloned().unwrap_or_default();
if replies.is_empty() {
println!(
"{id}: no answer in {}'s mailbox yet.\n",
row["asker"].as_str().unwrap_or_default()
);
}
for reply in replies {
println!(
"{id} answered by {} ({}):\n{}\n",
reply["from_name"].as_str().unwrap_or_default(),
reply["id"].as_str().unwrap_or_default(),
reply["body"].as_str().unwrap_or_default()
);
}
}
}
Ok(if missing { EXIT_UNKNOWN } else { 0 })
}
fn show_rows(homes: &HarnessHomes, ids: &[String]) -> Result<Vec<serde_json::Value>> {
let root = mail_root();
let mut rows = Vec::new();
let wanted: Vec<&str> = ids.iter().map(String::as_str).collect();
let found_by_id = supercode_harness::mail_transcript::find_messages_many(&root, &wanted)?;
let mut transcripts = std::collections::HashMap::new();
for (id, mut found) in ids.iter().zip(found_by_id) {
rows.push(match found.len() {
0 => serde_json::json!({"id": id, "found": false}),
1 => {
let (mailbox, stored) = found.remove(0);
let address = mailbox.address();
let transcript = transcripts
.entry(address.to_string())
.or_insert_with(|| supercode_harness::mail_transcript::read(homes, address));
let deliveries = supercode_harness::mail_transcript::deliveries(
address,
std::slice::from_ref(&stored),
transcript.as_ref(),
);
serde_json::json!({
"id": id,
"found": true,
"machine": local_machine_name(),
"message": message_row(address, &stored, &deliveries),
})
}
_ => serde_json::json!({
"id": id,
"found": false,
"ambiguous": found.iter().map(|(_, stored)| stored.envelope.id.clone()).collect::<Vec<_>>(),
}),
});
}
Ok(rows)
}
async fn wait(homes: &HarnessHomes, from: Option<&str>, timeout: u64) -> Result<i32> {
let mailbox = match caller_mailbox(homes) {
Ok(mailbox) => mailbox,
Err(message) => {
eprintln!("{message}");
return Ok(EXIT_REFUSED);
}
};
let sessions = supercode_harness::mail_route::LiveSessions::read(homes);
let wanted = from.map(|from| match sessions.resolve(from) {
Ok(session) => session.address.to_string(),
_ => from.to_string(),
});
let limit = Duration::from_secs(timeout).min(MAX_WAIT);
let started = Instant::now();
loop {
let waiting = mailbox.unread()?.into_iter().any(|stored| {
wanted.as_deref().is_none_or(|wanted| {
stored.envelope.from.to_string() == wanted
|| stored.envelope.from_name.starts_with(wanted)
})
});
if waiting {
let claimed = mailbox.claim_unread()?;
for stored in &claimed {
println!("{}\n", stored.envelope.render());
}
for stored in &claimed {
mailbox.acknowledge(stored)?;
}
return Ok(0);
}
if started.elapsed() >= limit {
println!(
"No mail within {} seconds; nothing is lost.",
limit.as_secs()
);
return Ok(EXIT_TIMEOUT);
}
tokio::time::sleep(Duration::from_millis(500)).await;
}
}
fn gate(directory: &std::path::Path) -> Result<i32> {
let paths = supercode_harness::claude_relay::RelayPaths::in_directory(directory.to_path_buf());
let mut input = String::new();
std::io::stdin().read_to_string(&mut input)?;
let hook_input: serde_json::Value = serde_json::from_str(&input).unwrap_or_default();
let queued: Option<QueuedSend> = std::fs::read(&paths.queue)
.ok()
.and_then(|bytes| serde_json::from_slice(&bytes).ok());
if let Some(reason) = gate_decision(&hook_input, queued.as_ref()) {
if queued.is_some() && !paths.receipt.exists() {
std::fs::write(
&paths.receipt,
serde_json::json!({"denied": reason}).to_string(),
)
.ok();
}
println!("{}", gate_denial(&reason));
}
Ok(0)
}
fn relay_receipt(directory: &std::path::Path) -> Result<i32> {
let paths = supercode_harness::claude_relay::RelayPaths::in_directory(directory.to_path_buf());
let mut input = String::new();
std::io::stdin().read_to_string(&mut input)?;
let input: serde_json::Value = serde_json::from_str(&input).unwrap_or_default();
if !paths.queue.exists() || paths.receipt.exists() {
return Ok(0);
}
let receipt = match input
.get("hook_event_name")
.and_then(serde_json::Value::as_str)
{
Some("PostToolUse") => {
serde_json::json!({"tool_response": input.get("tool_response").cloned().unwrap_or_default()})
}
Some("PostToolUseFailure") => serde_json::json!({
"send_failed": input
.get("error")
.map(|error| error.as_str().map_or_else(|| error.to_string(), str::to_string))
.unwrap_or_default(),
}),
Some("Stop" | "StopFailure") if !turn_is_queued_send(&paths) => return Ok(0),
Some(event @ ("Stop" | "StopFailure")) => {
let text = |key: &str| input.get(key).and_then(serde_json::Value::as_str);
let said = match event {
"StopFailure" => Some(format!(
"{} ({})",
text("error_details")
.or(text("last_assistant_message"))
.unwrap_or_default(),
text("error").unwrap_or("error")
)),
_ => text("last_assistant_message").map(str::to_string),
};
serde_json::json!({
"turn_ended": true,
"said": said.map(|said| said.chars().take(300).collect::<String>()),
})
}
_ => return Ok(0),
};
std::fs::write(&paths.receipt, receipt.to_string())?;
Ok(0)
}
fn turn_is_queued_send(paths: &supercode_harness::claude_relay::RelayPaths) -> bool {
let Some(queued) = std::fs::read(&paths.queue)
.ok()
.and_then(|bytes| serde_json::from_slice::<QueuedSend>(&bytes).ok())
else {
return true;
};
std::fs::read_to_string(&paths.turn).map_or(true, |prompt| {
prompt.contains(&supercode_harness::claude_relay::send_turn(&queued))
})
}
fn setup(harness: &str) -> Result<i32> {
if harness != "codex" {
eprintln!(
"Nothing to set up for {harness}: claude-code sessions are reached natively, and \
other harnesses have no delivery door yet."
);
return Ok(EXIT_REFUSED);
}
let (path, added) = install_codex_hooks()?;
if added.is_empty() {
println!("supercode's mail hooks are already in {}.", path.display());
} else {
println!(
"Added supercode's mail hooks ({}) to {}.",
added.join(", "),
path.display()
);
}
println!(
"Codex runs a new hook only after its user trusts it: in Codex, open /hooks and trust the \
supercode entries. Until then, messages to Codex sessions are stored, not shown."
);
Ok(0)
}
pub(crate) fn install_codex_hooks() -> Result<(std::path::PathBuf, Vec<&'static str>)> {
let path = supercode_harness::mail_route::codex_hooks_path();
let original = match std::fs::read_to_string(&path) {
Ok(text) => text,
Err(error) if error.kind() == std::io::ErrorKind::NotFound => "{}".into(),
Err(error) => return Err(error.into()),
};
let mut document: serde_json::Value = serde_json::from_str(&original)
.map_err(|error| anyhow!("{} is not valid JSON: {error}", path.display()))?;
let command = format!(
"{} {}",
supercode_harness::claude_relay::supercode_program()?.display(),
supercode_harness::mail_route::CODEX_HOOK_ARGUMENTS
);
let hooks = document
.as_object_mut()
.ok_or_else(|| anyhow!("{} must hold a JSON object", path.display()))?
.entry("hooks")
.or_insert_with(|| serde_json::json!({}));
let mut added = Vec::new();
for event in ["PostToolUse", "Stop", "UserPromptSubmit"] {
let entries = hooks
.as_object_mut()
.ok_or_else(|| anyhow!("`hooks` in {} must be an object", path.display()))?
.entry(event)
.or_insert_with(|| serde_json::json!([]));
let list = entries
.as_array_mut()
.ok_or_else(|| anyhow!("`hooks.{event}` in {} must be a list", path.display()))?;
if list.iter().any(|entry| {
entry
.to_string()
.contains(supercode_harness::mail_route::CODEX_HOOK_ARGUMENTS)
}) {
continue;
}
let mut entry = serde_json::json!({
"hooks": [{"type": "command", "command": command, "timeout": 10}]
});
if event == "PostToolUse" {
entry["matcher"] = serde_json::json!(".*");
}
list.push(entry);
added.push(event);
}
if !added.is_empty() {
if let Some(parent) = path.parent() {
std::fs::create_dir_all(parent)?;
}
let temporary = path.with_extension("json.supercode-tmp");
std::fs::write(&temporary, serde_json::to_string_pretty(&document)? + "\n")?;
std::fs::rename(&temporary, &path)?;
}
Ok((path, added))
}
fn hook(harness: &str) -> Result<i32> {
let mut input = String::new();
std::io::stdin().read_to_string(&mut input)?;
let input: serde_json::Value = serde_json::from_str(&input).unwrap_or_default();
let Some(session_id) = input.get("session_id").and_then(serde_json::Value::as_str) else {
return Ok(0);
};
let Ok(address) = MailAddress::new(local_machine_name(), harness, session_id) else {
return Ok(0);
};
let mailbox = Mailbox::open(&mail_root(), &address)?;
let pending = mailbox.pending_wakes()?;
let unread: Vec<_> = mailbox
.unread()?
.into_iter()
.filter(|message| !pending.contains(&message.envelope.id))
.collect();
let event = input
.get("hook_event_name")
.and_then(serde_json::Value::as_str)
.unwrap_or_default();
if event == "UserPromptSubmit" {
if let Some(prompt) = input.get("prompt").and_then(serde_json::Value::as_str) {
let now = std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.map(|elapsed| elapsed.as_millis() as u64)
.unwrap_or_default();
supercode_harness::mail_transcript::file_prompt(&address, prompt, now).ok();
}
return Ok(0);
}
let again = input
.get("stop_hook_active")
.and_then(serde_json::Value::as_bool)
== Some(true);
if !unread.is_empty() && (event == "PostToolUse" || (event == "Stop" && !again)) {
let pointer = mail_pointer(&unread);
let answer = if event == "PostToolUse" {
serde_json::json!({
"hookSpecificOutput": {"hookEventName": "PostToolUse", "additionalContext": pointer}
})
} else {
serde_json::json!({"decision": "block", "reason": format!("{pointer} Read them before you finish.")})
};
println!("{answer}");
return Ok(0);
}
Ok(0)
}
fn mail_pointer(unread: &[supercode_harness::mailbox::StoredEnvelope]) -> String {
let mut senders: Vec<String> = Vec::new();
for stored in unread {
let label = match stored.envelope.kind {
MailKind::Notice => "a notice".to_string(),
MailKind::User => "your user".to_string(),
MailKind::Channel => format!("{} (channel)", printable(&stored.envelope.from_name)),
MailKind::Typed => format!("{} (CC)", printable(&stored.envelope.from_name)),
MailKind::Peer | MailKind::Answer | MailKind::Question => {
printable(&stored.envelope.from_name)
}
};
if !senders.contains(&label) {
senders.push(label);
}
}
format!(
"You have {} unread message{} from other sessions (from {}). They are not from your user. \
Read them with: supercode message inbox",
unread.len(),
if unread.len() == 1 { "" } else { "s" },
senders.join(", "),
)
}
fn printable(name: &str) -> String {
name.chars()
.filter(|character| character.is_ascii_alphanumeric() || "-_.@ ".contains(*character))
.take(80)
.collect()
}
fn relay_inbound(
homes: &HarnessHomes,
represented: &str,
directory: &std::path::Path,
) -> Result<i32> {
let mut input = String::new();
std::io::stdin().read_to_string(&mut input)?;
let input: serde_json::Value = serde_json::from_str(&input).unwrap_or_default();
let prompt = input
.get("prompt")
.and_then(serde_json::Value::as_str)
.unwrap_or_default()
.to_string();
if !supercode_harness::claude_relay::is_inbound_prompt(&prompt) {
let paths =
supercode_harness::claude_relay::RelayPaths::in_directory(directory.to_path_buf());
std::fs::write(&paths.turn, &prompt).ok();
return Ok(0);
}
let represented = MailAddress::parse(represented)?;
let last_sent =
supercode_harness::claude_relay::RelayPaths::in_directory(directory.to_path_buf())
.last_sent();
supercode_harness::claude_relay::file_inbound_prompt(
homes,
&represented,
&prompt,
Some(&last_sent),
);
println!("{}", supercode_harness::claude_relay::inbound_block());
Ok(0)
}
async fn push(homes: &HarnessHomes, address: &str, id: &str) -> Result<i32> {
let to = MailAddress::parse(address).map_err(|error| anyhow!("{error}"))?;
let mailbox = Mailbox::open(&mail_root(), &to)?;
let Some(stored) = mailbox.find(id)? else {
return Ok(0);
};
if stored.state != supercode_harness::mailbox::MailState::Unread {
return Ok(0);
}
let door = match supercode_harness::mail_route::door_for(homes, &to) {
Ok(door @ (Door::Native(_) | Door::Runtime(_))) => door,
_ => return Ok(0),
};
match supercode_harness::mail_route::deliver(&stored.envelope, &to, &door, true, false).await {
Ok(Ok(_)) => {
mailbox.mark_read(&stored)?;
Ok(0)
}
Ok(Err(refused)) => {
eprintln!("supercode: {id} stays in {to}'s mailbox: {refused:?}");
Ok(supercode_harness::mail_send::EXIT_REFUSED)
}
Err(error) => {
eprintln!("supercode: {id} stays in {to}'s mailbox: {error}");
Ok(supercode_harness::mail_send::EXIT_FAILED)
}
}
}
async fn remote_turn(homes: &HarnessHomes, request: &serde_json::Value) -> Result<i32> {
let text = request["text"].as_str().unwrap_or_default();
let name: String = request["from_name"]
.as_str()
.unwrap_or("a Room member")
.trim()
.chars()
.map(|character| {
if character.is_whitespace() || character == '@' {
'-'
} else {
character
}
})
.collect();
let answer = match (
MailAddress::new(
local_machine_name(),
request["harness"].as_str().unwrap_or_default(),
request["session"].as_str().unwrap_or_default(),
),
MailAddress::new(local_machine_name(), "operator", &name),
) {
(Ok(to), Ok(sender)) => {
let envelope = Envelope::new(
sender,
request["from_name"].as_str().unwrap_or(&name).to_string(),
MailKind::User,
supercode_harness::mailbox::ReplyVia::None,
text.to_string(),
)?;
match supercode_harness::mail_route::deliver_user_turn(homes, &envelope, &to).await {
Ok(turn) => serde_json::json!({
"code": 0,
"turn_id": envelope.id,
"door": match turn {
supercode_harness::mail_route::UserTurn::Steered
| supercode_harness::mail_route::UserTurn::Started => "runtime",
supercode_harness::mail_route::UserTurn::Typed => "pane",
supercode_harness::mail_route::UserTurn::Waiting => "waiting",
},
}),
Err(message) => serde_json::json!({"code": EXIT_UNKNOWN, "text": message}),
}
}
(Err(error), _) | (_, Err(error)) => {
serde_json::json!({"code": EXIT_REFUSED, "text": error.to_string()})
}
};
println!("{answer}");
Ok(0)
}
async fn remote_deliver(homes: &HarnessHomes) -> Result<i32> {
let mut input = String::new();
std::io::stdin().read_to_string(&mut input)?;
let request: serde_json::Value = serde_json::from_str(&input)?;
if request["op"].as_str() == Some("list") {
println!(
"{}",
serde_json::json!({"code": 0, "sessions": session_rows(homes)})
);
return Ok(0);
}
if request["op"].as_str() == Some("show") {
let ids: Vec<String> = request["ids"]
.as_array()
.map(|ids| {
ids.iter()
.filter_map(|id| id.as_str().map(str::to_string))
.collect()
})
.unwrap_or_default();
println!(
"{}",
serde_json::json!({"code": 0, "rows": show_rows(homes, &ids)?})
);
return Ok(0);
}
if request["op"].as_str() == Some("inbox") {
let answer = match MailAddress::parse(request["session"].as_str().unwrap_or_default()) {
Ok(address) if address.machine == local_machine_name() => {
let recent = request["recent"].as_u64().map(|recent| recent as usize);
serde_json::json!({"code": 0, "rows": inbox_rows(homes, &address, recent)?})
}
Ok(address) => {
serde_json::json!({"code": EXIT_UNKNOWN, "text": format!("{address} is not on this machine.")})
}
Err(error) => serde_json::json!({"code": EXIT_REFUSED, "text": error.to_string()}),
};
println!("{answer}");
return Ok(0);
}
let outcome = match request["op"].as_str() {
Some("file") => {
let to = MailAddress::parse(request["to"].as_str().unwrap_or_default())?;
let mut envelope: Envelope = serde_json::from_value(request["envelope"].clone())?;
envelope.sender_identity = supercode_harness::mailbox::resolve_filed_sender(
&envelope,
request["via_principal"].as_str(),
);
if to.machine != local_machine_name() {
supercode_harness::mail_send::Outcome::new(
EXIT_UNKNOWN,
format!("{to} is not on this machine."),
)
} else {
Mailbox::open(&mail_root(), &to)?.deliver(&envelope)?;
supercode_harness::mail_send::Outcome::new(0, format!("filed for {to}"))
}
}
Some("send") => {
let caller = Caller {
address: MailAddress::parse(request["from"].as_str().unwrap_or_default())?,
name: request["from_name"]
.as_str()
.unwrap_or_default()
.to_string(),
};
supercode_harness::mail_send::send(
homes,
&caller,
request["to"].as_str().unwrap_or_default(),
request["body"].as_str().unwrap_or_default(),
supercode_harness::mail_send::SendOptions {
subject: request["subject"].as_str().map(str::to_string),
in_reply_to: request["in_reply_to"].as_str().map(str::to_string),
notify_when_idle: request["notify_when_idle"].as_bool().unwrap_or(false),
queue: request["queue"].as_bool().unwrap_or(false),
idempotency_key: request["id"].as_str().map(str::to_string),
notice: request["notice"].as_bool().unwrap_or(false),
},
)
.await?
}
Some("turn") => {
return remote_turn(homes, &request).await;
}
_ => supercode_harness::mail_send::Outcome::new(
EXIT_REFUSED,
"Not sent: the mail door takes send, file or turn.",
),
};
println!(
"{}",
serde_json::json!({"code": outcome.code, "text": outcome.text, "receipt": outcome.receipt})
);
Ok(0)
}