fix(ci): post report on CI

Author: prajwolrg

.github/workflows/prover.yml

@@ -22,6 +22,7 @@ jobs:
     timeout-minutes: 120
     permissions:
       contents: read
+      pull-requests: write
     steps:
       - name: Checkout repository
         uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v4
@@ -48,7 +49,22 @@ jobs:
       - name: Check SP1 toolchain
         run: cargo prove --version
 
+      - name: Run prover-perf and post PR comment
+        if: github.event_name == 'pull_request' && github.event.pull_request.head.repo.fork == false
+        env:
+          ZKVM_MOCK: "1"
+          ZKVM_PROFILING: "1"
+        run: |
+          cargo run --release -p strata-asm-prover-perf -- \
+            --post-to-gh \
+            --github-token "${{ secrets.GITHUB_TOKEN }}" \
+            --pr-number "${{ github.event.pull_request.number }}" \
+            --commit-hash "${{ github.sha }}" \
+            --github-repo "${{ github.repository }}" \
+            --programs asm-stf
+
       - name: Run prover-perf
+        if: github.event_name != 'pull_request' || github.event.pull_request.head.repo.fork == true
         env:
           ZKVM_MOCK: "1"
           ZKVM_PROFILING: "1"

Cargo.lock

@@ -20,6 +20,12 @@ zkaleido = { workspace = true, features = ["perf"] }
 anyhow.workspace = true
 clap.workspace = true
 num-format = "0.4.4"
+reqwest = { version = "0.12.28", default-features = false, features = [
+  "blocking",
+  "json",
+  "rustls-tls",
+] }
+serde_json.workspace = true
 sp1-sdk = "5.2.1"
 zkaleido-sp1-host = { git = "https://github.com/alpenlabs/zkaleido", tag = "v0.1.0-alpha-rc21", features = [
   "perf",

bin/prover-perf/Cargo.toml

@@ -1,10 +1,36 @@
+use std::env;
+
 use clap::Parser;
 
 use crate::programs::GuestProgram;
 
+fn default_github_repo() -> String {
+    env::var("GITHUB_REPOSITORY").unwrap_or_else(|_| "alpenlabs/asm".to_string())
+}
+
 /// Evaluate SP1 prover performance for ASM programs.
 #[derive(Debug, Clone, Parser)]
 pub(crate) struct EvalArgs {
+    /// Whether to post the results as a GitHub PR comment.
+    #[arg(long, default_value_t = false)]
+    pub post_to_gh: bool,
+
+    /// GitHub token used to authenticate API requests.
+    #[arg(long, default_value_t = String::new())]
+    pub github_token: String,
+
+    /// Pull request number to post comment to.
+    #[arg(long, default_value_t = String::new())]
+    pub pr_number: String,
+
+    /// Commit hash shown in the generated report header.
+    #[arg(long, default_value = "local_commit")]
+    pub commit_hash: String,
+
+    /// GitHub repository in `owner/repo` format.
+    #[arg(long, default_value_t = default_github_repo())]
+    pub github_repo: String,
+
     /// Programs to run. Supports comma-delimited and repeated values, e.g.
     /// `--programs asm-stf` or `--programs asm-stf,asm-stf`.
     #[arg(long)]

bin/prover-perf/src/args.rs

@@ -1,9 +1,16 @@
 use num_format::{Locale, ToFormattedString};
 use zkaleido::PerformanceReport;
 
+use crate::args::EvalArgs;
+
 /// Returns a formatted header for the performance report.
-pub(crate) fn format_header() -> String {
-    "*Local execution*".to_string()
+pub(crate) fn format_header(args: &EvalArgs) -> String {
+    if args.post_to_gh {
+        let short_commit: String = args.commit_hash.chars().take(8).collect();
+        format!("*Commit*: {short_commit}")
+    } else {
+        "*Local execution*".to_string()
+    }
 }
 
 /// Returns formatted results for the [`PerformanceReport`]s as a table.

bin/prover-perf/src/format.rs

@@ -0,0 +1,82 @@
+use anyhow::{anyhow, bail, Result};
+use reqwest::blocking::{Client, RequestBuilder};
+use serde_json::json;
+
+use crate::args::EvalArgs;
+
+/// Posts the report to the configured GitHub PR.
+///
+/// Updates an existing previous comment by `github-actions[bot]` (matching the
+/// prover output marker) if present, otherwise posts a new one.
+pub(crate) fn post_to_github_pr(args: &EvalArgs, message: &str) -> Result<()> {
+    if args.github_token.trim().is_empty() {
+        bail!("--github-token is required when --post-to-gh is set");
+    }
+    if args.pr_number.trim().is_empty() {
+        bail!("--pr-number is required when --post-to-gh is set");
+    }
+
+    let client = Client::new();
+    let comments_url = format!(
+        "https://api.github.com/repos/{}/issues/{}/comments",
+        args.github_repo, args.pr_number
+    );
+
+    let comments_response =
+        set_github_headers(client.get(&comments_url), &args.github_token).send()?;
+    if !comments_response.status().is_success() {
+        let status = comments_response.status();
+        let body = comments_response.text().unwrap_or_default();
+        bail!("failed to fetch PR comments ({status}): {body}");
+    }
+
+    let comments: Vec<serde_json::Value> = comments_response
+        .json()
+        .map_err(|e| anyhow!("failed to decode PR comments response: {e}"))?;
+
+    let bot_comment = comments.iter().find(|comment| {
+        let is_actions_bot = comment["user"]["login"].as_str() == Some("github-actions[bot]");
+        let has_perf_marker = comment["body"]
+            .as_str()
+            .map(|body| body.contains("SP1 Execution Results"))
+            .unwrap_or(false);
+        is_actions_bot && has_perf_marker
+    });
+
+    let request = if let Some(existing_comment) = bot_comment {
+        let comment_url = existing_comment["url"]
+            .as_str()
+            .ok_or_else(|| anyhow!("existing bot comment did not include url field"))?;
+        client.patch(comment_url)
+    } else {
+        client.post(&comments_url)
+    };
+
+    let response = set_github_headers(request, &args.github_token)
+        .json(&json!({ "body": message }))
+        .send()?;
+
+    if !response.status().is_success() {
+        let status = response.status();
+        let body = response.text().unwrap_or_default();
+        bail!("failed to post/update PR comment ({status}): {body}");
+    }
+
+    Ok(())
+}
+
+fn set_github_headers(builder: RequestBuilder, token: &str) -> RequestBuilder {
+    builder
+        .header("Authorization", format!("Bearer {token}"))
+        .header("X-GitHub-Api-Version", "2022-11-28")
+        .header("User-Agent", "strata-asm-prover-perf")
+}
+
+pub(crate) fn format_github_message(results_text: &[String]) -> String {
+    let mut message = String::new();
+    for line in results_text {
+        message.push_str(&line.replace('*', "**"));
+        message.push('\n');
+    }
+    message
+}

bin/prover-perf/src/github.rs

@@ -8,23 +8,30 @@ use sp1_sdk::utils::setup_logger;
 
 mod args;
 mod format;
+mod github;
 mod programs;
 
 use args::{parse_programs, EvalArgs};
 use format::{format_header, format_results};
+use github::{format_github_message, post_to_github_pr};
 
 fn main() -> Result<()> {
     setup_logger();
     let args = EvalArgs::parse();
 
     let programs = parse_programs(&args.programs).map_err(anyhow::Error::msg)?;
 
-    let mut results_text = vec![format_header()];
+    let mut results_text = vec![format_header(&args)];
     let sp1_reports = programs::run_sp1_programs(&programs);
     results_text.push(format_results(&sp1_reports, "SP1".to_string()));
 
     println!("{}", results_text.join("\n"));
 
+    if args.post_to_gh {
+        let message = format_github_message(&results_text);
+        post_to_github_pr(&args, &message)?;
+    }
+
     if !sp1_reports.iter().all(|r| r.success) {
         process::exit(1);
     }