1use std::collections::HashMap;
2use std::sync::Arc;
3use std::time::Duration;
4
5use serde::Deserialize;
6use tokio::sync::{Notify, RwLock};
7
8use rap_protocol::{CallbackClient, RapInvocation, send_subscription_event};
9
10#[derive(Debug, Clone, Deserialize)]
13pub struct SubscribeArgs {
14 pub owner: String,
15 pub repo: String,
16 pub event_type: Option<String>,
17 pub sha: Option<String>,
18 pub pr_number: Option<u64>,
19 pub issue_number: Option<u64>,
20 pub action: Option<String>,
21 pub branch: Option<String>,
22 pub actor: Option<String>,
23}
24
25#[derive(Debug, Clone)]
26pub struct Subscription {
27 pub tool_call_id: rap_protocol::ToolCallId,
28 pub call_id: Option<rap_protocol::ProviderCallId>,
29 pub callback_url: String,
30 pub group_id: rap_protocol::ThreadId,
31 pub filters: Filters,
32}
33
34#[derive(Debug, Clone, Default)]
35pub struct Filters {
36 pub event_type: Option<String>,
37 pub sha: Option<String>,
38 pub pr_number: Option<u64>,
39 pub issue_number: Option<u64>,
40 pub action: Option<String>,
41 pub branch: Option<String>,
42 pub actor: Option<String>,
43}
44
45impl Filters {
46 fn from_args(args: &SubscribeArgs) -> Self {
47 Self {
48 event_type: args.event_type.clone(),
49 sha: args.sha.clone(),
50 pr_number: args.pr_number,
51 issue_number: args.issue_number,
52 action: args.action.clone(),
53 branch: args.branch.clone(),
54 actor: args.actor.clone(),
55 }
56 }
57}
58
59#[derive(Debug)]
62struct RepoState {
63 subscriptions: HashMap<rap_protocol::ToolCallId, Subscription>,
65 etag: Option<String>,
67 poll_interval: Duration,
69 last_seen_id: Option<String>,
71 initialized: bool,
73}
74
75pub struct Poller<C: CallbackClient> {
78 repos: Arc<RwLock<HashMap<String, RepoState>>>,
80 wake: Arc<Notify>,
82 callback_client: Arc<C>,
83 http: reqwest::Client,
84}
85
86impl<C: CallbackClient> Poller<C> {
87 pub fn new(callback_client: C, github_token: Option<String>) -> Self {
88 let mut headers = reqwest::header::HeaderMap::new();
89 headers.insert(
90 "Accept",
91 "application/vnd.github+json"
92 .parse()
93 .expect("bug: invalid Accept header"),
94 );
95 headers.insert(
96 "X-GitHub-Api-Version",
97 "2022-11-28"
98 .parse()
99 .expect("bug: invalid API version header"),
100 );
101 if let Some(ref token) = github_token {
102 headers.insert(
103 "Authorization",
104 format!("Bearer {token}")
105 .parse()
106 .expect("bug: invalid Authorization header"),
107 );
108 }
109
110 let http = reqwest::Client::builder()
111 .user_agent("rap-github-event-poller")
112 .default_headers(headers)
113 .build()
114 .expect("failed to build reqwest client");
115
116 Self {
117 repos: Arc::new(RwLock::new(HashMap::new())),
118 wake: Arc::new(Notify::new()),
119 callback_client: Arc::new(callback_client),
120 http,
121 }
122 }
123
124 pub async fn subscribe(&self, invocation: &RapInvocation) -> String {
126 let args: SubscribeArgs = match serde_json::from_value(invocation.arguments.clone()) {
127 Ok(a) => a,
128 Err(e) => return format!("Error: invalid arguments: {e}"),
129 };
130
131 let key = format!("{}/{}", args.owner, args.repo);
132 let filters = Filters::from_args(&args);
133 let sub = Subscription {
134 tool_call_id: invocation.id.clone(),
135 call_id: invocation.call_id.clone(),
136 callback_url: invocation.callback_url.clone(),
137 group_id: invocation.group_id.clone(),
138 filters: filters.clone(),
139 };
140
141 let was_empty = {
142 let repos = self.repos.read().await;
143 repos.values().all(|r| r.subscriptions.is_empty())
144 };
145
146 {
147 let mut repos = self.repos.write().await;
148 let state = repos.entry(key).or_insert_with(|| RepoState {
149 subscriptions: HashMap::new(),
150 etag: None,
151 poll_interval: Duration::from_secs(60),
152 last_seen_id: None,
153 initialized: false,
154 });
155 state.subscriptions.insert(invocation.id.clone(), sub);
156 }
157
158 if was_empty {
159 self.wake.notify_one();
160 }
161
162 let filter_desc = describe_filters(&filters);
163 format!(
164 "Subscribed to events for {}/{}. {filter_desc}",
165 args.owner, args.repo
166 )
167 }
168
169 pub async fn cancel(&self, tool_call_id: &rap_protocol::ToolCallId<str>) {
171 let mut repos = self.repos.write().await;
172 for state in repos.values_mut() {
173 state.subscriptions.remove(tool_call_id);
174 }
175 repos.retain(|_, state| !state.subscriptions.is_empty());
177 }
178
179 pub async fn run(&self) -> ! {
181 loop {
182 {
184 let repos = self.repos.read().await;
185 if repos.values().all(|r| r.subscriptions.is_empty()) {
186 drop(repos);
187 tracing::info!("no active subscriptions, sleeping until woken");
188 self.wake.notified().await;
189 continue;
190 }
191 }
192
193 let snapshot: Vec<(String, Duration, Option<String>)> = {
195 let repos = self.repos.read().await;
196 repos
197 .iter()
198 .filter(|(_, s)| !s.subscriptions.is_empty())
199 .map(|(k, s)| (k.clone(), s.poll_interval, s.etag.clone()))
200 .collect()
201 };
202
203 for (repo_key, _interval, etag) in &snapshot {
204 self.poll_repo(repo_key, etag.as_deref()).await;
205 }
206
207 let min_interval = {
209 let repos = self.repos.read().await;
210 repos
211 .values()
212 .filter(|s| !s.subscriptions.is_empty())
213 .map(|s| s.poll_interval)
214 .min()
215 .unwrap_or(Duration::from_secs(60))
216 };
217
218 tracing::debug!("sleeping for {}s before next poll", min_interval.as_secs());
219 tokio::time::sleep(min_interval).await;
220 }
221 }
222
223 async fn poll_repo(&self, repo_key: &str, etag: Option<&str>) {
224 let url = format!("https://api.github.com/repos/{repo_key}/events?per_page=30");
225
226 let mut req = self.http.get(&url);
227 if let Some(etag) = etag {
228 req = req.header("If-None-Match", etag);
229 }
230
231 let resp = match req.send().await {
232 Ok(r) => r,
233 Err(e) => {
234 tracing::warn!("failed to poll {repo_key}: {e}");
235 return;
236 }
237 };
238
239 let new_interval = resp
241 .headers()
242 .get("x-poll-interval")
243 .and_then(|v| v.to_str().ok())
244 .and_then(|v| v.parse::<u64>().ok())
245 .map(Duration::from_secs);
246
247 let new_etag = resp
248 .headers()
249 .get("etag")
250 .and_then(|v| v.to_str().ok())
251 .map(|s| s.to_owned());
252
253 let status = resp.status();
254
255 {
257 let mut repos = self.repos.write().await;
258 if let Some(state) = repos.get_mut(repo_key) {
259 if let Some(interval) = new_interval {
260 state.poll_interval = interval;
261 }
262 if let Some(ref etag) = new_etag {
263 state.etag = Some(etag.clone());
264 }
265 }
266 }
267
268 if status == reqwest::StatusCode::NOT_MODIFIED {
269 tracing::debug!("{repo_key}: 304 Not Modified");
270 return;
271 }
272
273 if !status.is_success() {
274 tracing::warn!("{repo_key}: GitHub API returned {status}");
275 return;
276 }
277
278 let events: Vec<GitHubEvent> = match resp.json().await {
279 Ok(e) => e,
280 Err(e) => {
281 tracing::warn!("{repo_key}: failed to parse events: {e}");
282 return;
283 }
284 };
285
286 if events.is_empty() {
287 return;
288 }
289
290 let (was_initialized, last_seen_id) = {
292 let repos = self.repos.read().await;
293 repos
294 .get(repo_key)
295 .map(|s| (s.initialized, s.last_seen_id.clone()))
296 .unwrap_or((false, None))
297 };
298
299 let newest_id = events[0].id.clone();
301 {
302 let mut repos = self.repos.write().await;
303 if let Some(state) = repos.get_mut(repo_key) {
304 state.last_seen_id = Some(newest_id);
305 state.initialized = true;
306 }
307 }
308
309 if !was_initialized {
311 tracing::info!(
312 "{repo_key}: first poll, recorded baseline ({} events), skipping delivery",
313 events.len()
314 );
315 return;
316 }
317
318 let new_events: Vec<&GitHubEvent> = events
320 .iter()
321 .take_while(|e| Some(&e.id) != last_seen_id.as_ref())
322 .collect();
323
324 if new_events.is_empty() {
325 tracing::debug!("{repo_key}: no new events since last poll");
326 return;
327 }
328
329 tracing::debug!("{repo_key}: {} new events", new_events.len());
330
331 let subs: Vec<Subscription> = {
333 let repos = self.repos.read().await;
334 repos
335 .get(repo_key)
336 .map(|s| s.subscriptions.values().cloned().collect())
337 .unwrap_or_default()
338 };
339
340 for event in new_events.into_iter().rev() {
342 let event_data = extract_event_data(event);
343 for sub in &subs {
344 if matches_filters(&sub.filters, &event_data) {
345 let text = serde_json::to_string_pretty(&serde_json::json!({
346 "event_type": event.r#type,
347 "payload": event.payload,
348 }))
349 .unwrap_or_default();
350
351 send_subscription_event(
352 self.callback_client.as_ref(),
353 &sub.callback_url,
354 sub.group_id.clone(),
355 sub.tool_call_id.clone(),
356 &text,
357 false,
358 false,
359 )
360 .await;
361 tracing::info!(
362 "sent event {} to subscription {}",
363 event.r#type,
364 sub.tool_call_id
365 );
366 }
367 }
368 }
369 }
370}
371
372#[derive(Debug, Deserialize)]
375struct GitHubEvent {
376 pub id: String,
377 pub r#type: String,
378 pub payload: serde_json::Value,
379}
380
381#[derive(Debug, Default)]
384struct EventData {
385 event_type: Option<String>,
386 action: Option<String>,
387 actor: Option<String>,
388 sha: Option<String>,
389 pr_number: Option<u64>,
390 issue_number: Option<u64>,
391 branch: Option<String>,
392 head_branch: Option<String>,
393 base_branch: Option<String>,
394}
395
396fn extract_event_data(event: &GitHubEvent) -> EventData {
397 let p = &event.payload;
398 let mut d = EventData {
399 event_type: Some(event.r#type.clone()),
400 action: p.get("action").and_then(|v| v.as_str()).map(String::from),
401 actor: p
402 .pointer("/sender/login")
403 .or_else(|| p.pointer("/actor/login"))
404 .and_then(|v| v.as_str())
405 .map(String::from),
406 ..Default::default()
407 };
408
409 d.sha = p
411 .get("head_sha")
412 .or_else(|| p.get("sha"))
413 .or_else(|| p.get("after"))
414 .or_else(|| p.pointer("/pull_request/head/sha"))
415 .or_else(|| p.pointer("/check_run/head_sha"))
416 .or_else(|| p.pointer("/check_suite/head_sha"))
417 .or_else(|| p.pointer("/workflow_run/head_sha"))
418 .and_then(|v| v.as_str())
419 .map(String::from);
420
421 d.pr_number = p
423 .pointer("/pull_request/number")
424 .or_else(|| {
425 if p.pointer("/issue/pull_request").is_some() {
426 p.pointer("/issue/number")
427 } else {
428 None
429 }
430 })
431 .and_then(|v| v.as_u64());
432
433 if d.pr_number.is_none() {
435 d.issue_number = p.pointer("/issue/number").and_then(|v| v.as_u64());
436 }
437
438 d.branch = p
440 .get("ref")
441 .and_then(|v| v.as_str())
442 .map(|s| s.strip_prefix("refs/heads/").unwrap_or(s).to_owned());
443 d.head_branch = p
444 .pointer("/pull_request/head/ref")
445 .and_then(|v| v.as_str())
446 .map(String::from);
447 d.base_branch = p
448 .pointer("/pull_request/base/ref")
449 .and_then(|v| v.as_str())
450 .map(String::from);
451
452 d
453}
454
455fn matches_filters(filters: &Filters, data: &EventData) -> bool {
456 if let Some(ref et) = filters.event_type
457 && data.event_type.as_deref() != Some(et)
458 {
459 return false;
460 }
461 if let Some(ref sha) = filters.sha
462 && data.sha.as_deref() != Some(sha)
463 {
464 return false;
465 }
466 if let Some(pr) = filters.pr_number
467 && data.pr_number != Some(pr)
468 {
469 return false;
470 }
471 if let Some(issue) = filters.issue_number
472 && data.issue_number != Some(issue)
473 {
474 return false;
475 }
476 if let Some(ref action) = filters.action
477 && data.action.as_deref() != Some(action)
478 {
479 return false;
480 }
481 if let Some(ref actor) = filters.actor
482 && data.actor.as_deref() != Some(actor)
483 {
484 return false;
485 }
486 if let Some(ref branch) = filters.branch
487 && data.branch.as_deref() != Some(branch)
488 && data.head_branch.as_deref() != Some(branch)
489 && data.base_branch.as_deref() != Some(branch)
490 {
491 return false;
492 }
493 true
494}
495
496fn describe_filters(f: &Filters) -> String {
497 let mut parts = Vec::new();
498 if let Some(ref v) = f.event_type {
499 parts.push(format!("event_type={v}"));
500 }
501 if let Some(ref v) = f.sha {
502 parts.push(format!("sha={v}"));
503 }
504 if let Some(v) = f.pr_number {
505 parts.push(format!("pr_number={v}"));
506 }
507 if let Some(v) = f.issue_number {
508 parts.push(format!("issue_number={v}"));
509 }
510 if let Some(ref v) = f.action {
511 parts.push(format!("action={v}"));
512 }
513 if let Some(ref v) = f.branch {
514 parts.push(format!("branch={v}"));
515 }
516 if let Some(ref v) = f.actor {
517 parts.push(format!("actor={v}"));
518 }
519 if parts.is_empty() {
520 "No filters (will match all events).".to_owned()
521 } else {
522 format!("Filters: {}", parts.join(", "))
523 }
524}