Skip to content

Commit b7731b3

Browse files
committed
fix(acp): wake agents from self-owned workflows
Co-authored-by: LioLionel <[email protected]> Signed-off-by: LioLionel <[email protected]>
1 parent 0720f53 commit b7731b3

4 files changed

Lines changed: 311 additions & 9 deletions

File tree

‎crates/buzz-acp/README.md‎

Lines changed: 5 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -147,6 +147,11 @@ Controls which authors' events the harness forwards to the agent. Events from di
147147
| `anyone` | Forward all events (no author filtering). |
148148
| `nobody` | Drop all inbound events. Agent only acts on heartbeat prompts. |
149149

150+
Relay-signed workflow messages are first verified against the relay's NIP-11
151+
`self` key and attributed to their explicit workflow owner. A workflow owned by
152+
this agent may wake it in every responding mode; `nobody` remains an explicit
153+
proactive-only mode and still rejects workflow wakes.
154+
150155
The gate applies to **all** inbound events — @mentions, DMs, thread replies, and any event delivered by the relay. Owner control commands are checked **before** the gate, so the owner can still manage the harness regardless of mode:
151156

152157
| Command | Effect |

‎crates/buzz-acp/src/lib.rs‎

Lines changed: 252 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -273,6 +273,67 @@ async fn author_allowed(
273273
}
274274
}
275275

276+
/// Return the workflow owner attributed by a relay-signed workflow message.
277+
///
278+
/// The workflow tags alone are not authority: any ordinary event author can
279+
/// forge custom tags. Attribution is accepted only when the event signer
280+
/// matches the relay's NIP-11 `self` key, the event is a kind:9 stream
281+
/// message, and exactly one canonical marker and workflow-owner tag are
282+
/// present. Mention `p` tags are never used for attribution.
283+
fn verified_workflow_owner(event: &nostr::Event, relay_self: Option<&str>) -> Option<String> {
284+
if event.kind.as_u16() as u32 != KIND_STREAM_MESSAGE {
285+
return None;
286+
}
287+
288+
let relay_self = nostr::PublicKey::from_hex(relay_self?).ok()?;
289+
if event.pubkey != relay_self {
290+
return None;
291+
}
292+
293+
let markers: Vec<&[String]> = event
294+
.tags
295+
.iter()
296+
.map(|tag| tag.as_slice())
297+
.filter(|values| values.first().map(String::as_str) == Some("buzz:workflow"))
298+
.collect();
299+
if markers.len() != 1 || markers[0] != ["buzz:workflow", "true"] {
300+
return None;
301+
}
302+
303+
let owners: Vec<&[String]> = event
304+
.tags
305+
.iter()
306+
.map(|tag| tag.as_slice())
307+
.filter(|values| values.first().map(String::as_str) == Some("buzz:workflow-owner"))
308+
.collect();
309+
let [owner_tag] = owners.as_slice() else {
310+
return None;
311+
};
312+
let [_, owner_value] = owner_tag else {
313+
return None;
314+
};
315+
let owner = nostr::PublicKey::from_hex(owner_value).ok()?;
316+
317+
if event.verify().is_err() {
318+
return None;
319+
}
320+
321+
Some(owner.to_hex())
322+
}
323+
324+
/// Return an author-gate decision only for a verified self-owned workflow.
325+
///
326+
/// `None` means the caller must apply the ordinary author policy. A self-owned
327+
/// workflow is the scheduled equivalent of a heartbeat, but `Nobody` remains
328+
/// an explicit proactive-only mode and therefore rejects it.
329+
fn self_owned_workflow_decision(
330+
workflow_owner: Option<&str>,
331+
agent_pubkey: &str,
332+
respond_to: &RespondTo,
333+
) -> Option<bool> {
334+
(workflow_owner == Some(agent_pubkey)).then_some(!matches!(respond_to, RespondTo::Nobody))
335+
}
336+
276337
/// Resolve whether `channel_id` is a DM, for the inbound author gate.
277338
///
278339
/// Resolution order:
@@ -2017,6 +2078,26 @@ async fn tokio_main() -> Result<()> {
20172078

20182079
tracing::info!("connected to relay at {}", config.relay_url);
20192080

2081+
let relay_self = match relay.rest_client().relay_self().await {
2082+
Ok(Some(pubkey)) => {
2083+
tracing::info!(relay_self = %pubkey, "verified relay signing identity via NIP-11");
2084+
Some(pubkey)
2085+
}
2086+
Ok(None) => {
2087+
tracing::warn!(
2088+
"relay NIP-11 document has no stable `self` key; relay-authored workflow wakes will fail closed"
2089+
);
2090+
None
2091+
}
2092+
Err(error) => {
2093+
tracing::warn!(
2094+
%error,
2095+
"failed to verify relay signing identity; relay-authored workflow wakes will fail closed"
2096+
);
2097+
None
2098+
}
2099+
};
2100+
20202101
relay
20212102
.subscribe_membership_notifications()
20222103
.await
@@ -2866,21 +2947,36 @@ async fn tokio_main() -> Result<()> {
28662947
// explicit pubkey list on top, for external people;
28672948
// it never revokes same-owner team bots.
28682949
{
2869-
let author = buzz_event.event.pubkey.to_hex();
28702950
// DM hardening: resolve channel type (fail-closed
28712951
// to DM) so allowlist/anyone modes cannot be
28722952
// exercised by non-owner authors inside DMs.
28732953
let is_dm =
28742954
is_dm_channel(buzz_event.channel_id, &ctx.channel_info).await;
2875-
let allowed = author_allowed(
2955+
let raw_author = buzz_event.event.pubkey.to_hex();
2956+
let workflow_owner = verified_workflow_owner(
2957+
&buzz_event.event,
2958+
relay_self.as_deref(),
2959+
);
2960+
let allowed = match self_owned_workflow_decision(
2961+
workflow_owner.as_deref(),
2962+
&pubkey_hex,
28762963
&config.respond_to,
2877-
&config.respond_to_allowlist,
2878-
&author,
2879-
is_dm,
2880-
&owner_cache,
2881-
&ctx.rest_client,
2882-
)
2883-
.await;
2964+
) {
2965+
Some(decision) => decision,
2966+
None => {
2967+
author_allowed(
2968+
&config.respond_to,
2969+
&config.respond_to_allowlist,
2970+
workflow_owner
2971+
.as_deref()
2972+
.unwrap_or(raw_author.as_str()),
2973+
is_dm,
2974+
&owner_cache,
2975+
&ctx.rest_client,
2976+
)
2977+
.await
2978+
}
2979+
};
28842980
if !allowed {
28852981
tracing::debug!(
28862982
channel_id = %buzz_event.channel_id,
@@ -5334,6 +5430,153 @@ mod owner_cache_tests {
53345430
mod author_gate_tests {
53355431
use super::*;
53365432

5433+
#[test]
5434+
fn test_verified_workflow_owner_accepts_relay_signed_workflow_message() {
5435+
let relay_keys = nostr::Keys::generate();
5436+
let workflow_owner = nostr::Keys::generate().public_key().to_hex();
5437+
let event = nostr::EventBuilder::new(nostr::Kind::Custom(9), "run")
5438+
.tags([
5439+
nostr::Tag::parse(["buzz:workflow", "true"]).unwrap(),
5440+
nostr::Tag::parse(["buzz:workflow-owner", workflow_owner.as_str()]).unwrap(),
5441+
])
5442+
.sign_with_keys(&relay_keys)
5443+
.unwrap();
5444+
5445+
assert_eq!(
5446+
verified_workflow_owner(&event, Some(&relay_keys.public_key().to_hex())),
5447+
Some(workflow_owner)
5448+
);
5449+
}
5450+
5451+
#[test]
5452+
fn test_verified_workflow_owner_rejects_forged_workflow_tags() {
5453+
let relay_keys = nostr::Keys::generate();
5454+
let stranger_keys = nostr::Keys::generate();
5455+
let workflow_owner = nostr::Keys::generate().public_key().to_hex();
5456+
let event = nostr::EventBuilder::new(nostr::Kind::Custom(9), "run")
5457+
.tags([
5458+
nostr::Tag::parse(["buzz:workflow", "true"]).unwrap(),
5459+
nostr::Tag::parse(["buzz:workflow-owner", workflow_owner.as_str()]).unwrap(),
5460+
])
5461+
.sign_with_keys(&stranger_keys)
5462+
.unwrap();
5463+
5464+
assert_eq!(
5465+
verified_workflow_owner(&event, Some(&relay_keys.public_key().to_hex())),
5466+
None
5467+
);
5468+
}
5469+
5470+
#[test]
5471+
fn test_verified_workflow_owner_rejects_tampered_relay_event() {
5472+
let relay_keys = nostr::Keys::generate();
5473+
let workflow_owner = nostr::Keys::generate().public_key().to_hex();
5474+
let mut event = nostr::EventBuilder::new(nostr::Kind::Custom(9), "run")
5475+
.tags([
5476+
nostr::Tag::parse(["buzz:workflow", "true"]).unwrap(),
5477+
nostr::Tag::parse(["buzz:workflow-owner", workflow_owner.as_str()]).unwrap(),
5478+
])
5479+
.sign_with_keys(&relay_keys)
5480+
.unwrap();
5481+
event.content = "tampered".into();
5482+
5483+
assert_eq!(
5484+
verified_workflow_owner(&event, Some(&relay_keys.public_key().to_hex())),
5485+
None
5486+
);
5487+
}
5488+
5489+
#[test]
5490+
fn test_verified_workflow_owner_rejects_ambiguous_tags() {
5491+
let relay_keys = nostr::Keys::generate();
5492+
let workflow_owner = nostr::Keys::generate().public_key().to_hex();
5493+
for duplicate_tag in [
5494+
nostr::Tag::parse(["buzz:workflow", "true"]).unwrap(),
5495+
nostr::Tag::parse(["buzz:workflow-owner", workflow_owner.as_str()]).unwrap(),
5496+
] {
5497+
let event = nostr::EventBuilder::new(nostr::Kind::Custom(9), "run")
5498+
.tags([
5499+
nostr::Tag::parse(["buzz:workflow", "true"]).unwrap(),
5500+
nostr::Tag::parse(["buzz:workflow-owner", workflow_owner.as_str()]).unwrap(),
5501+
duplicate_tag,
5502+
])
5503+
.sign_with_keys(&relay_keys)
5504+
.unwrap();
5505+
5506+
assert_eq!(
5507+
verified_workflow_owner(&event, Some(&relay_keys.public_key().to_hex())),
5508+
None
5509+
);
5510+
}
5511+
}
5512+
5513+
#[test]
5514+
fn test_verified_workflow_owner_rejects_wrong_kind() {
5515+
let relay_keys = nostr::Keys::generate();
5516+
let workflow_owner = nostr::Keys::generate().public_key().to_hex();
5517+
let event = nostr::EventBuilder::new(nostr::Kind::Custom(1), "run")
5518+
.tags([
5519+
nostr::Tag::parse(["buzz:workflow", "true"]).unwrap(),
5520+
nostr::Tag::parse(["buzz:workflow-owner", workflow_owner.as_str()]).unwrap(),
5521+
])
5522+
.sign_with_keys(&relay_keys)
5523+
.unwrap();
5524+
5525+
assert_eq!(
5526+
verified_workflow_owner(&event, Some(&relay_keys.public_key().to_hex())),
5527+
None
5528+
);
5529+
}
5530+
5531+
#[test]
5532+
fn test_owner_only_accepts_self_owned_relay_workflow() {
5533+
let relay_keys = nostr::Keys::generate();
5534+
let agent_keys = nostr::Keys::generate();
5535+
let agent_pubkey = agent_keys.public_key().to_hex();
5536+
let event = nostr::EventBuilder::new(nostr::Kind::Custom(9), "run")
5537+
.tags([
5538+
nostr::Tag::parse(["buzz:workflow", "true"]).unwrap(),
5539+
nostr::Tag::parse(["buzz:workflow-owner", agent_pubkey.as_str()]).unwrap(),
5540+
])
5541+
.sign_with_keys(&relay_keys)
5542+
.unwrap();
5543+
5544+
let workflow_owner =
5545+
verified_workflow_owner(&event, Some(&relay_keys.public_key().to_hex()));
5546+
assert_eq!(
5547+
self_owned_workflow_decision(
5548+
workflow_owner.as_deref(),
5549+
&agent_pubkey,
5550+
&RespondTo::OwnerOnly,
5551+
),
5552+
Some(true)
5553+
);
5554+
}
5555+
5556+
#[test]
5557+
fn test_nobody_rejects_self_owned_relay_workflow() {
5558+
let relay_keys = nostr::Keys::generate();
5559+
let agent_pubkey = nostr::Keys::generate().public_key().to_hex();
5560+
let event = nostr::EventBuilder::new(nostr::Kind::Custom(9), "run")
5561+
.tags([
5562+
nostr::Tag::parse(["buzz:workflow", "true"]).unwrap(),
5563+
nostr::Tag::parse(["buzz:workflow-owner", agent_pubkey.as_str()]).unwrap(),
5564+
])
5565+
.sign_with_keys(&relay_keys)
5566+
.unwrap();
5567+
5568+
let workflow_owner =
5569+
verified_workflow_owner(&event, Some(&relay_keys.public_key().to_hex()));
5570+
assert_eq!(
5571+
self_owned_workflow_decision(
5572+
workflow_owner.as_deref(),
5573+
&agent_pubkey,
5574+
&RespondTo::Nobody,
5575+
),
5576+
Some(false)
5577+
);
5578+
}
5579+
53375580
/// A `RestClient` for tests. The author-gate decisions exercised here all
53385581
/// resolve from the owner pubkey or sibling cache before any HTTP call, so
53395582
/// this client is never actually used to make a request.

‎crates/buzz-acp/src/relay.rs‎

Lines changed: 38 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -277,6 +277,44 @@ fn unix_now_secs() -> u64 {
277277
}
278278

279279
impl RestClient {
280+
/// Fetch the relay's stable signing identity from its NIP-11 document.
281+
///
282+
/// Relay-authored workflow messages are trusted only when their event
283+
/// signer matches this key. Missing, malformed, or unavailable identity
284+
/// data fails closed by returning an error/`None` to the caller.
285+
pub async fn relay_self(&self) -> Result<Option<String>, RelayError> {
286+
let url = format!("{}/info", self.base_url);
287+
let response = tokio::time::timeout(
288+
Duration::from_secs(5),
289+
self.http
290+
.get(&url)
291+
.header(reqwest::header::ACCEPT, "application/nostr+json")
292+
.send(),
293+
)
294+
.await
295+
.map_err(|_| RelayError::Timeout)?
296+
.map_err(|error| RelayError::Http(error.to_string()))?;
297+
298+
if !response.status().is_success() {
299+
return Err(RelayError::Http(format!(
300+
"GET /info returned HTTP {}",
301+
response.status()
302+
)));
303+
}
304+
305+
let document: serde_json::Value = response
306+
.json()
307+
.await
308+
.map_err(|error| RelayError::Http(format!("invalid NIP-11 document: {error}")))?;
309+
let Some(relay_self) = document.get("self").and_then(serde_json::Value::as_str) else {
310+
return Ok(None);
311+
};
312+
let relay_self = nostr::PublicKey::from_hex(relay_self)
313+
.map_err(|error| RelayError::Http(format!("invalid NIP-11 self pubkey: {error}")))?
314+
.to_hex();
315+
Ok(Some(relay_self))
316+
}
317+
280318
/// Sign a NIP-98 HTTP Auth event (kind:27235) for the given method/URL/body.
281319
///
282320
/// Returns the `Authorization: Nostr <base64>` header value (without the

‎crates/buzz-relay/src/workflow_sink.rs‎

Lines changed: 16 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -257,6 +257,8 @@ impl ActionSink for RelayActionSink {
257257
// - `p` tag attributes the message to the workflow owner
258258
// - `h` tag scopes to the channel (NIP-29, canonical UUID)
259259
// - `buzz:workflow` tag prevents recursive workflow triggering
260+
// - `buzz:workflow-owner` lets harnesses apply the owner's
261+
// inbound-author policy after verifying the relay signature
260262
// - one `p` tag per `@Name` that resolves to a channel member,
261263
// so mentioned agents are woken (wake is `p`-tag gated)
262264
let mut tags = vec![
@@ -266,6 +268,8 @@ impl ActionSink for RelayActionSink {
266268
.map_err(|e| ActionSinkError::EventBuild(format!("h tag: {e}")))?,
267269
Tag::parse(["buzz:workflow", "true"])
268270
.map_err(|e| ActionSinkError::EventBuild(format!("workflow tag: {e}")))?,
271+
Tag::parse(["buzz:workflow-owner", &author_pubkey_hex])
272+
.map_err(|e| ActionSinkError::EventBuild(format!("workflow owner tag: {e}")))?,
269273
];
270274

271275
// Resolve thread ancestry when this is a threaded reply, so the
@@ -775,6 +779,18 @@ mod integration_tests {
775779
p_tag_targets.contains(&agent_hex.as_str()),
776780
"mentioned member {agent_hex} must be p-tagged so it wakes; got {p_tag_targets:?}"
777781
);
782+
783+
let owner_tag = stored
784+
.event
785+
.tags
786+
.iter()
787+
.find(|tag| tag.as_slice().first().map(String::as_str) == Some("buzz:workflow-owner"))
788+
.and_then(|tag| tag.as_slice().get(1).map(String::as_str));
789+
assert_eq!(
790+
owner_tag,
791+
Some(author_hex.as_str()),
792+
"workflow owner must be explicit so consumers never infer it from p-tag order"
793+
);
778794
}
779795

780796
#[tokio::test]

0 commit comments

Comments
 (0)