Skip to main content

rap_github_event_poller/
lib.rs

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// ── Subscription types ──
11
12#[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// ── Per-repo polling state ──
60
61#[derive(Debug)]
62struct RepoState {
63    /// Subscriptions keyed by tool_call_id
64    subscriptions: HashMap<rap_protocol::ToolCallId, Subscription>,
65    /// ETag from last poll (for conditional requests)
66    etag: Option<String>,
67    /// Poll interval from GitHub's X-Poll-Interval header (default 60s)
68    poll_interval: Duration,
69    /// ID of the most recent event we've seen; events at or before this are skipped.
70    last_seen_id: Option<String>,
71    /// False until the first successful poll (we skip delivering historical events).
72    initialized: bool,
73}
74
75// ── Poller ──
76
77pub struct Poller<C: CallbackClient> {
78    /// Map from "owner/repo" -> RepoState
79    repos: Arc<RwLock<HashMap<String, RepoState>>>,
80    /// Notified when subscriptions go from 0 -> 1
81    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    /// Add a subscription. Returns a human-readable confirmation.
125    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    /// Remove a subscription by tool_call_id.
170    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        // Remove repos with no subscriptions
176        repos.retain(|_, state| !state.subscriptions.is_empty());
177    }
178
179    /// Run the polling loop. This never returns.
180    pub async fn run(&self) -> ! {
181        loop {
182            // Wait until there's at least one subscription
183            {
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            // Snapshot the repos we need to poll and their intervals
194            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            // Sleep for the minimum poll interval across all repos
208            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        // Update poll interval from header
240        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        // Update repo state with new etag/interval
256        {
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        // Read current state
291        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        // Record the newest event ID (events are newest-first)
300        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        // On first poll, skip delivering historical events
310        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        // Filter to only new events (stop at last_seen_id)
319        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        // Match events against subscriptions
332        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        // Deliver in chronological order (reverse since API returns newest-first)
341        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// ── GitHub Events API types ──
373
374#[derive(Debug, Deserialize)]
375struct GitHubEvent {
376    pub id: String,
377    pub r#type: String,
378    pub payload: serde_json::Value,
379}
380
381// ── Event data extraction (mirrors the webhook receiver logic) ──
382
383#[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    // SHA extraction chain
410    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    // PR number
422    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    // Issue number
434    if d.pr_number.is_none() {
435        d.issue_number = p.pointer("/issue/number").and_then(|v| v.as_u64());
436    }
437
438    // Branch
439    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}