From 903117d9ec94615ea0f67b98319e4f86b0733a5d Mon Sep 17 00:00:00 2001 From: claude-agent Date: Mon, 2 Nov 2026 20:21:54 +0000 Subject: [PATCH 1/6] ci: post new security advisories to the security discord channel Poll the repository security advisories API every 15 minutes and post each new triage or draft advisory once (GHSA ID, title, severity, link) to the private security channel. Skips silently until SECURITY_DISCORD_WEBHOOK and ADVISORY_READ_TOKEN are configured. Co-Authored-By: Claude Opus 5.5 --- .github/scripts/notify_security_advisories.py | 292 ++++++++++++++++ .../test_notify_security_advisories.py | 314 ++++++++++++++++++ .../workflows/security-advisory-notify.yml | 65 ++++ 3 files changed, 671 insertions(+) create mode 100755 .github/scripts/notify_security_advisories.py create mode 100644 .github/scripts/test_notify_security_advisories.py create mode 100644 .github/workflows/security-advisory-notify.yml diff --git a/.github/scripts/notify_security_advisories.py b/.github/scripts/notify_security_advisories.py new file mode 100755 index 000000000..f5038034e --- /dev/null +++ b/.github/scripts/notify_security_advisories.py @@ -0,0 +1,292 @@ +#!/usr/bin/env python3 +"""Post new triage and draft repository security advisories to Discord. + +Run by .github/workflows/security-advisory-notify.yml. Each message carries only +the GHSA ID, title, severity and a link to the advisory. Workflow logs on this +repository are public, so in CI the script never prints anything about an +advisory, and the state file holds keyed hashes of GHSA IDs, never the IDs. + +Environment: + GITHUB_REPOSITORY owner/repo whose advisories are listed + ADVISORY_READ_TOKEN token that can read unpublished advisories + SECURITY_DISCORD_WEBHOOK Discord webhook URL; also the key for state hashes + STATE_FILE JSON file of advisories already posted + GITHUB_OUTPUT set by Actions; receives changed=true|false + +Local check without a webhook or token (refused under GitHub Actions): + python3 notify_security_advisories.py --dry-run \\ + --advisories-file advisories.json --state-file state.json +""" + +from __future__ import annotations + +import argparse +import hashlib +import hmac +import json +import os +import re +import sys +import time +import urllib.error +import urllib.request +from collections.abc import Callable, Iterable + +STATES = ("triage", "draft") +SEVERITIES = {"critical", "high", "medium", "low"} +GHSA_ID = re.compile(r"^GHSA(-[23456789cfghjmpqrvwx]{4}){3}$") +LINK_NEXT = re.compile(r'<([^>]+)>;\s*rel="next"') +EMBED_TITLE_MAX = 256 +DRY_RUN_KEY = "local-dry-run" + + +class NotifyError(Exception): + """An error whose message is safe to print in a public log.""" + + +def state_digest(key: str, ghsa_id: str) -> str: + return hmac.new(key.encode(), ghsa_id.encode(), hashlib.sha256).hexdigest() + + +def load_state(path: str) -> set[str]: + try: + with open(path, encoding="utf-8") as f: + data = json.load(f) + except FileNotFoundError: + return set() + except (OSError, ValueError) as e: + raise NotifyError("state file is unreadable") from e + posted = data.get("posted") if isinstance(data, dict) else None + if not isinstance(posted, list): + raise NotifyError("state file has an unexpected format") + return {d for d in posted if isinstance(d, str)} + + +def save_state(path: str, posted: Iterable[str]) -> None: + os.makedirs(os.path.dirname(os.path.abspath(path)), exist_ok=True) + tmp = f"{path}.tmp" + with open(tmp, "w", encoding="utf-8") as f: + json.dump({"version": 1, "posted": sorted(posted)}, f) + os.replace(tmp, path) + + +def fetch_advisories(api_url: str, repo: str, token: str) -> list[dict]: + advisories: list[dict] = [] + for state in STATES: + url: str | None = ( + f"{api_url}/repos/{repo}/security-advisories" + f"?state={state}&per_page=100&sort=created&direction=asc" + ) + while url: + request = urllib.request.Request( + url, + headers={ + "Accept": "application/vnd.github+json", + "Authorization": f"Bearer {token}", + "X-GitHub-Api-Version": "2022-11-28", + "User-Agent": "security-advisory-notify", + }, + ) + try: + with urllib.request.urlopen(request, timeout=30) as response: + page = json.load(response) + link = response.headers.get("Link", "") + except urllib.error.HTTPError as e: + e.close() + raise NotifyError( + f"listing {state} advisories failed with HTTP {e.code}" + ) from None + except (urllib.error.URLError, TimeoutError, ValueError): + raise NotifyError(f"listing {state} advisories failed") from None + if not isinstance(page, list): + raise NotifyError(f"listing {state} advisories returned non-list") + advisories.extend(a for a in page if isinstance(a, dict)) + match = LINK_NEXT.search(link) + url = match.group(1) if match else None + return advisories + + +def discord_payload(advisory: dict, server_url: str, repo: str) -> dict: + ghsa_id = advisory["ghsa_id"] + summary = " ".join(str(advisory.get("summary") or "").split()) + title = f"{ghsa_id}: {summary}" if summary else ghsa_id + if len(title) > EMBED_TITLE_MAX: + title = title[: EMBED_TITLE_MAX - 1] + "…" + severity = advisory.get("severity") + return { + "content": f"New security advisory {ghsa_id}", + # Titles come from reporters; never let one ping anyone. + "allowed_mentions": {"parse": []}, + "embeds": [ + { + "title": title, + "url": f"{server_url}/{repo}/security/advisories/{ghsa_id}", + "fields": [ + { + "name": "Severity", + "value": severity if severity in SEVERITIES else "unknown", + "inline": True, + } + ], + } + ], + } + + +def post_to_discord(webhook_url: str, payload: dict) -> None: + body = json.dumps(payload).encode() + for attempt in range(3): + request = urllib.request.Request( + webhook_url, + data=body, + method="POST", + headers={ + "Content-Type": "application/json", + "User-Agent": "security-advisory-notify", + }, + ) + try: + with urllib.request.urlopen(request, timeout=30): + return + except urllib.error.HTTPError as e: + with e: + retry_body = e.read() if e.code == 429 else b"" + if e.code == 429 and attempt < 2: + try: + retry_after = float(json.loads(retry_body).get("retry_after", 2)) + except (ValueError, AttributeError): + retry_after = 2.0 + time.sleep(min(retry_after, 30)) + continue + # Don't print the response body or URL: the URL is the secret. + raise NotifyError(f"Discord webhook returned HTTP {e.code}") from None + except (urllib.error.URLError, TimeoutError): + raise NotifyError("Discord webhook request failed") from None + + +def notify( + advisories: list[dict], + posted: set[str], + key: str, + send: Callable[[dict], None], + server_url: str, + repo: str, +) -> tuple[set[str], bool]: + """Send each advisory not yet posted, oldest first. + + Returns the new state (only advisories still in triage or draft, so it + stays small) and whether anything was sent. If a send fails, the state + passed to the exception holds everything sent before it. + """ + current = {} + for advisory in advisories: + ghsa_id = advisory.get("ghsa_id") + if isinstance(ghsa_id, str) and GHSA_ID.match(ghsa_id): + current.setdefault(ghsa_id, advisory) + ordered = sorted( + current.values(), key=lambda a: (str(a.get("created_at") or ""), a["ghsa_id"]) + ) + + new_state = {d for d in (state_digest(key, i) for i in current) if d in posted} + sent = False + for advisory in ordered: + digest = state_digest(key, advisory["ghsa_id"]) + if digest in new_state: + continue + if sent: + time.sleep(1) # stay under Discord's per-webhook rate limit + try: + send(discord_payload(advisory, server_url, repo)) + except NotifyError as e: + e.partial_state = new_state # type: ignore[attr-defined] + raise + new_state.add(digest) + sent = True + return new_state, sent + + +def write_output(changed: bool) -> None: + path = os.environ.get("GITHUB_OUTPUT") + if path: + with open(path, "a", encoding="utf-8") as f: + f.write(f"changed={'true' if changed else 'false'}\n") + + +def main(argv: list[str] | None = None) -> int: + parser = argparse.ArgumentParser(description=__doc__.split("\n")[0]) + parser.add_argument("--state-file", default=os.environ.get("STATE_FILE")) + parser.add_argument( + "--dry-run", + action="store_true", + help="print Discord payloads instead of posting (local runs only)", + ) + parser.add_argument( + "--advisories-file", + help="read advisories from this JSON list instead of the API (local runs only)", + ) + args = parser.parse_args(argv) + + in_actions = os.environ.get("GITHUB_ACTIONS") == "true" + if in_actions and (args.dry_run or args.advisories_file): + print( + "--dry-run and --advisories-file are for local runs only", file=sys.stderr + ) + return 2 + if not args.state_file: + print("set STATE_FILE or --state-file", file=sys.stderr) + return 2 + + repo = os.environ.get("GITHUB_REPOSITORY", "roostorg/coop") + server_url = os.environ.get("GITHUB_SERVER_URL", "https://github.com") + api_url = os.environ.get("GITHUB_API_URL", "https://api.github.com") + webhook = os.environ.get("SECURITY_DISCORD_WEBHOOK", "") + token = os.environ.get("ADVISORY_READ_TOKEN", "") + + if args.dry_run: + key = webhook or DRY_RUN_KEY + + def send(payload: dict) -> None: + print(json.dumps(payload, indent=2, ensure_ascii=False)) + + else: + if not webhook or not token: + # Not configured: skip without output. + write_output(False) + return 0 + key = webhook + + def send(payload: dict) -> None: + post_to_discord(webhook, payload) + + try: + posted = load_state(args.state_file) + if args.advisories_file: + with open(args.advisories_file, encoding="utf-8") as f: + advisories = json.load(f) + else: + advisories = fetch_advisories(api_url, repo, token) + try: + new_state, _ = notify(advisories, posted, key, send, server_url, repo) + except NotifyError as e: + partial = getattr(e, "partial_state", None) + if partial is not None and partial != posted: + save_state(args.state_file, partial) + write_output(True) + raise + changed = new_state != posted + if changed: + save_state(args.state_file, new_state) + write_output(changed) + return 0 + except NotifyError as e: + print(f"::error::{e}", file=sys.stderr) + return 1 + + +if __name__ == "__main__": + try: + sys.exit(main()) + except Exception as e: # noqa: BLE001 + # A traceback could include advisory data or the webhook URL. + print(f"::error::unexpected {type(e).__name__}", file=sys.stderr) + sys.exit(1) diff --git a/.github/scripts/test_notify_security_advisories.py b/.github/scripts/test_notify_security_advisories.py new file mode 100644 index 000000000..1afef18ee --- /dev/null +++ b/.github/scripts/test_notify_security_advisories.py @@ -0,0 +1,314 @@ +"""Tests for notify_security_advisories.py. + +Run: python3 -m unittest discover -s .github/scripts -p 'test_*.py' +""" + +from __future__ import annotations + +import contextlib +import io +import json +import os +import sys +import tempfile +import threading +import unittest +from http.server import BaseHTTPRequestHandler, HTTPServer +from typing import ClassVar +from unittest import mock +from urllib.parse import parse_qs, urlparse + +sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) +import notify_security_advisories as notifier + +SECRET_TEXT = "SECRET-DESCRIPTION-DO-NOT-LEAK" + + +def advisory(ghsa_id, state="triage", created="2026-10-01T00:00:00Z", **extra): + return { + "ghsa_id": ghsa_id, + "state": state, + "summary": f"Summary of {ghsa_id}", + "severity": "high", + "created_at": created, + "description": SECRET_TEXT, + "html_url": f"https://github.com/roostorg/coop/security/advisories/{ghsa_id}", + "submission": {"accepted": False}, + "credits": [{"login": "reporter"}], + "vulnerabilities": [{"package": {"name": SECRET_TEXT}}], + **extra, + } + + +A1 = "GHSA-2222-3333-4444" +A2 = "GHSA-cfgh-jmpq-rvwx" +A3 = "GHSA-5678-9cfg-hjmp" + + +class FakeGitHubAndDiscord(BaseHTTPRequestHandler): + """Serves the advisories API (2 per page) and records Discord posts.""" + + advisories: ClassVar[dict[str, list[dict]]] = {} + posts: ClassVar[list[dict]] = [] + discord_status = 204 + + def log_message(self, *args): + pass + + def do_GET(self): + url = urlparse(self.path) + query = parse_qs(url.query) + if url.path != "/repos/roostorg/coop/security-advisories": + self.send_response(404) + self.end_headers() + return + if self.headers.get("Authorization") != "Bearer test-token": + self.send_response(401) + self.end_headers() + return + items = self.advisories.get(query["state"][0], []) + start = int(query.get("after", ["0"])[0]) + page = items[start : start + 2] + self.send_response(200) + if start + 2 < len(items): + host = f"http://{self.headers['Host']}" + nxt = f"{host}{url.path}?state={query['state'][0]}&after={start + 2}" + self.send_header("Link", f'<{nxt}>; rel="next"') + self.end_headers() + self.wfile.write(json.dumps(page).encode()) + + def do_POST(self): + body = self.rfile.read(int(self.headers["Content-Length"])) + if urlparse(self.path).path != "/webhook": + self.send_response(404) + self.end_headers() + return + status = type(self).discord_status + if status == 204: + type(self).posts.append(json.loads(body)) + self.send_response(status) + self.end_headers() + + +class NotifierTest(unittest.TestCase): + def setUp(self): + FakeGitHubAndDiscord.advisories = {} + FakeGitHubAndDiscord.posts = [] + FakeGitHubAndDiscord.discord_status = 204 + self.server = HTTPServer(("127.0.0.1", 0), FakeGitHubAndDiscord) + threading.Thread(target=self.server.serve_forever, daemon=True).start() + base = f"http://127.0.0.1:{self.server.server_port}" + self.tmp = tempfile.TemporaryDirectory() + self.state_file = os.path.join(self.tmp.name, "state", "state.json") + self.output_file = os.path.join(self.tmp.name, "output") + self.env = { + "GITHUB_ACTIONS": "true", + "GITHUB_REPOSITORY": "roostorg/coop", + "GITHUB_SERVER_URL": "https://github.com", + "GITHUB_API_URL": base, + "GITHUB_OUTPUT": self.output_file, + "SECURITY_DISCORD_WEBHOOK": f"{base}/webhook", + "ADVISORY_READ_TOKEN": "test-token", + "STATE_FILE": self.state_file, + } + sleep = mock.patch.object(notifier.time, "sleep") + sleep.start() + self.addCleanup(sleep.stop) + + def tearDown(self): + self.server.shutdown() + self.server.server_close() + self.tmp.cleanup() + + def run_ci(self, env=None): + """Run main() as the workflow does; return (exit code, stdout+stderr).""" + out = io.StringIO() + with ( + mock.patch.dict(os.environ, env or self.env, clear=True), + contextlib.redirect_stdout(out), + contextlib.redirect_stderr(out), + ): + code = notifier.main([]) + return code, out.getvalue() + + def output(self): + with open(self.output_file) as f: + return f.read() + + def test_posts_triage_and_draft_once_oldest_first_and_prints_nothing(self): + FakeGitHubAndDiscord.advisories = { + "triage": [ + advisory(A2, created="2026-10-03T00:00:00Z"), + advisory(A1, created="2026-10-01T00:00:00Z"), + advisory(A3, created="2026-10-04T00:00:00Z"), + ], + "draft": [advisory("GHSA-wxwx-wxwx-wxwx", "draft", "2026-10-02T00:00:00Z")], + } + code, logs = self.run_ci() + self.assertEqual((code, logs), (0, "")) + self.assertEqual( + [ + p["embeds"][0]["url"].rsplit("/", 1)[1] + for p in FakeGitHubAndDiscord.posts + ], + [A1, "GHSA-wxwx-wxwx-wxwx", A2, A3], + ) + self.assertIn("changed=true", self.output()) + + code, logs = self.run_ci() + self.assertEqual((code, logs), (0, "")) + self.assertEqual(len(FakeGitHubAndDiscord.posts), 4) + self.assertTrue(self.output().endswith("changed=false\n")) + + def test_payload_contains_only_id_title_severity_and_link(self): + FakeGitHubAndDiscord.advisories = {"triage": [advisory(A1)]} + self.run_ci() + (payload,) = FakeGitHubAndDiscord.posts + self.assertEqual( + payload, + { + "content": f"New security advisory {A1}", + "allowed_mentions": {"parse": []}, + "embeds": [ + { + "title": f"{A1}: Summary of {A1}", + "url": f"https://github.com/roostorg/coop/security/advisories/{A1}", + "fields": [ + {"name": "Severity", "value": "high", "inline": True} + ], + } + ], + }, + ) + + def test_state_file_does_not_contain_ghsa_ids(self): + FakeGitHubAndDiscord.advisories = {"triage": [advisory(A1)]} + self.run_ci() + with open(self.state_file) as f: + state = f.read() + self.assertNotIn(A1, state) + self.assertNotIn(A1.lower(), state) + + def test_advisory_moving_from_triage_to_draft_is_not_reposted(self): + FakeGitHubAndDiscord.advisories = {"triage": [advisory(A1)]} + self.run_ci() + FakeGitHubAndDiscord.advisories = {"draft": [advisory(A1, "draft")]} + self.run_ci() + self.assertEqual(len(FakeGitHubAndDiscord.posts), 1) + + def test_state_drops_advisories_no_longer_in_triage_or_draft(self): + FakeGitHubAndDiscord.advisories = {"triage": [advisory(A1), advisory(A2)]} + self.run_ci() + FakeGitHubAndDiscord.advisories = {"triage": [advisory(A2)]} + self.run_ci() + self.assertIn("changed=true", self.output().splitlines()[-1]) + with open(self.state_file) as f: + self.assertEqual(len(json.load(f)["posted"]), 1) + + def test_failed_post_keeps_earlier_posts_and_retries_the_rest(self): + FakeGitHubAndDiscord.advisories = { + "triage": [ + advisory(A1, created="2026-10-01T00:00:00Z"), + advisory(A2, created="2026-10-02T00:00:00Z"), + ] + } + real_post = notifier.post_to_discord + calls = [] + + def flaky(url, payload): + calls.append(payload) + if len(calls) == 2: + raise notifier.NotifyError("Discord webhook returned HTTP 500") + real_post(url, payload) + + with mock.patch.object(notifier, "post_to_discord", flaky): + code, logs = self.run_ci() + self.assertEqual(code, 1) + self.assertEqual(logs, "::error::Discord webhook returned HTTP 500\n") + self.assertIn("changed=true", self.output()) + + code, _ = self.run_ci() + self.assertEqual(code, 0) + self.assertEqual( + [p["content"] for p in FakeGitHubAndDiscord.posts], + [f"New security advisory {A1}", f"New security advisory {A2}"], + ) + + def test_discord_error_does_not_log_webhook_or_advisory(self): + FakeGitHubAndDiscord.advisories = {"triage": [advisory(A1)]} + FakeGitHubAndDiscord.discord_status = 400 + code, logs = self.run_ci() + self.assertEqual(code, 1) + self.assertEqual(logs, "::error::Discord webhook returned HTTP 400\n") + + def test_api_error_fails_without_touching_state(self): + env = {**self.env, "ADVISORY_READ_TOKEN": "wrong"} + code, logs = self.run_ci(env) + self.assertEqual(code, 1) + self.assertEqual( + logs, "::error::listing triage advisories failed with HTTP 401\n" + ) + self.assertFalse(os.path.exists(self.state_file)) + + def test_skips_silently_without_secrets(self): + for missing in ("SECURITY_DISCORD_WEBHOOK", "ADVISORY_READ_TOKEN"): + env = {k: v for k, v in self.env.items() if k != missing} + self.assertEqual(self.run_ci(env), (0, "")) + self.assertEqual(FakeGitHubAndDiscord.posts, []) + + def test_rotating_the_webhook_reposts_open_advisories(self): + FakeGitHubAndDiscord.advisories = {"triage": [advisory(A1)]} + self.run_ci() + self.run_ci( + { + **self.env, + "SECURITY_DISCORD_WEBHOOK": self.env["SECURITY_DISCORD_WEBHOOK"] + + "?v=2", + } + ) + self.assertEqual(len(FakeGitHubAndDiscord.posts), 2) + + def test_ignores_malformed_ids_and_severities_and_truncates_titles(self): + FakeGitHubAndDiscord.advisories = { + "triage": [ + advisory("not-a-ghsa"), + advisory("GHSA-aaaa-bbbb-cccc"), + advisory(A1, severity="@everyone", summary="x\n" * 400), + ] + } + self.run_ci() + (payload,) = FakeGitHubAndDiscord.posts + embed = payload["embeds"][0] + self.assertEqual(len(embed["title"]), notifier.EMBED_TITLE_MAX) + self.assertNotIn("\n", embed["title"]) + self.assertEqual(embed["fields"][0]["value"], "unknown") + + def test_local_only_flags_are_refused_in_actions(self): + with ( + mock.patch.dict(os.environ, self.env, clear=True), + contextlib.redirect_stderr(io.StringIO()), + ): + self.assertEqual(notifier.main(["--dry-run"]), 2) + self.assertEqual(notifier.main(["--advisories-file", "x.json"]), 2) + + def test_local_dry_run_prints_payloads_without_posting(self): + fixture = os.path.join(self.tmp.name, "advisories.json") + with open(fixture, "w") as f: + json.dump([advisory(A1)], f) + env = {"STATE_FILE": self.state_file} + out = io.StringIO() + with ( + mock.patch.dict(os.environ, env, clear=True), + contextlib.redirect_stdout(out), + ): + code = notifier.main(["--dry-run", "--advisories-file", fixture]) + self.assertEqual(code, 0) + self.assertEqual( + json.loads(out.getvalue())["content"], f"New security advisory {A1}" + ) + self.assertNotIn(SECRET_TEXT, out.getvalue()) + self.assertEqual(FakeGitHubAndDiscord.posts, []) + + +if __name__ == "__main__": + unittest.main() diff --git a/.github/workflows/security-advisory-notify.yml b/.github/workflows/security-advisory-notify.yml new file mode 100644 index 000000000..9bbad8bb4 --- /dev/null +++ b/.github/workflows/security-advisory-notify.yml @@ -0,0 +1,65 @@ +# Posts each new repository security advisory in triage or draft state to the +# private security Discord channel: GHSA ID, title, severity and link only. +# GitHub Actions has no advisory event, so this polls the REST API. +# +# Secrets (the job skips silently when either is missing): +# SECURITY_DISCORD_WEBHOOK webhook URL of the private security channel +# ADVISORY_READ_TOKEN fine-grained token, this repository only, +# "Repository security advisories: Read-only" +# +# Logs, step summaries and caches on this repository are readable by anyone, +# so nothing about an advisory is printed and the "already posted" state +# cached between runs holds HMACs of GHSA IDs keyed by the webhook URL. + +name: Security advisory notifications + +on: + schedule: + - cron: '7,22,37,52 * * * *' + workflow_dispatch: + +permissions: {} + +concurrency: + group: security-advisory-notify + cancel-in-progress: false + +jobs: + notify: + name: Post new advisories to Discord + runs-on: ubuntu-latest + timeout-minutes: 10 + env: + CONFIGURED: ${{ secrets.SECURITY_DISCORD_WEBHOOK != '' && secrets.ADVISORY_READ_TOKEN != '' }} + steps: + - name: Checkout notifier script + if: env.CONFIGURED == 'true' + uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1 + with: + persist-credentials: false + sparse-checkout: .github/scripts/notify_security_advisories.py + sparse-checkout-cone-mode: false + + - name: Restore posted-advisory state + if: env.CONFIGURED == 'true' + uses: actions/cache/restore@55cc8345863c7cc4c66a329aec7e433d2d1c52a9 # v6.1.0 + with: + path: ${{ runner.temp }}/security-advisory-notify/state.json + key: security-advisory-notify-${{ github.run_id }}-${{ github.run_attempt }} + restore-keys: security-advisory-notify- + + - name: Post new advisories + id: notify + if: env.CONFIGURED == 'true' + env: + SECURITY_DISCORD_WEBHOOK: ${{ secrets.SECURITY_DISCORD_WEBHOOK }} + ADVISORY_READ_TOKEN: ${{ secrets.ADVISORY_READ_TOKEN }} + STATE_FILE: ${{ runner.temp }}/security-advisory-notify/state.json + run: python3 .github/scripts/notify_security_advisories.py + + - name: Save posted-advisory state + if: always() && env.CONFIGURED == 'true' && steps.notify.outputs.changed == 'true' + uses: actions/cache/save@55cc8345863c7cc4c66a329aec7e433d2d1c52a9 # v6.1.0 + with: + path: ${{ runner.temp }}/security-advisory-notify/state.json + key: security-advisory-notify-${{ github.run_id }}-${{ github.run_attempt }} From 9bf5b924f9ed50193944f05fa39240a4f465467d Mon Sep 17 00:00:00 2001 From: claude-agent Date: Tue, 3 Nov 2026 19:22:35 +0000 Subject: [PATCH 2/6] ci: post security advisories with roostorg/discord-bot List new triage and draft advisories in a script and post them with the shared discord-bot action's repository_advisory event instead of calling the Discord webhook directly. State is saved only after posting succeeds. Co-Authored-By: Claude Opus 5.5 --- .../scripts/list_new_security_advisories.py | 218 ++++++++++++ .github/scripts/notify_security_advisories.py | 292 ---------------- .../test_list_new_security_advisories.py | 236 +++++++++++++ .../test_notify_security_advisories.py | 314 ------------------ .../workflows/security-advisory-notify.yml | 29 +- 5 files changed, 474 insertions(+), 615 deletions(-) create mode 100755 .github/scripts/list_new_security_advisories.py delete mode 100755 .github/scripts/notify_security_advisories.py create mode 100644 .github/scripts/test_list_new_security_advisories.py delete mode 100644 .github/scripts/test_notify_security_advisories.py diff --git a/.github/scripts/list_new_security_advisories.py b/.github/scripts/list_new_security_advisories.py new file mode 100755 index 000000000..dfc15ddab --- /dev/null +++ b/.github/scripts/list_new_security_advisories.py @@ -0,0 +1,218 @@ +#!/usr/bin/env python3 +"""List repository security advisories in triage or draft not yet posted. + +Run by .github/workflows/security-advisory-notify.yml, which posts the result +with roostorg/discord-bot. Writes PAYLOAD_FILE with one repository_advisory +payload per line, holding only the GHSA ID, title, severity and link, and +updates STATE_FILE to include them. The workflow saves the state only after +posting succeeds. + +Workflow logs and caches on this repository are public, so the script never +prints anything about an advisory, and the state holds keyed hashes of GHSA +IDs, never the IDs. + +Environment: + GITHUB_REPOSITORY owner/repo whose advisories are listed + ADVISORY_READ_TOKEN token that can read unpublished advisories + STATE_KEY secret key for the state hashes (the webhook URL) + STATE_FILE JSON file of advisories already posted + PAYLOAD_FILE where to write the payloads to post + GITHUB_OUTPUT set by Actions; receives post= and changed= + +Local check with advisories from a file instead of the API (refused under +GitHub Actions): + STATE_FILE=state.json PAYLOAD_FILE=payload.jsonl \\ + python3 list_new_security_advisories.py --advisories-file advisories.json +""" + +from __future__ import annotations + +import argparse +import hashlib +import hmac +import json +import os +import re +import sys +import urllib.error +import urllib.request +from collections.abc import Iterable + +STATES = ("triage", "draft") +SEVERITIES = {"critical", "high", "medium", "low"} +GHSA_ID = re.compile(r"^GHSA(-[23456789cfghjmpqrvwx]{4}){3}$") +LINK_NEXT = re.compile(r'<([^>]+)>;\s*rel="next"') +LOCAL_KEY = "local" + + +class ListError(Exception): + """An error whose message is safe to print in a public log.""" + + +def state_digest(key: str, ghsa_id: str) -> str: + return hmac.new(key.encode(), ghsa_id.encode(), hashlib.sha256).hexdigest() + + +def load_state(path: str) -> set[str]: + try: + with open(path, encoding="utf-8") as f: + data = json.load(f) + except FileNotFoundError: + return set() + except (OSError, ValueError) as e: + raise ListError("state file is unreadable") from e + posted = data.get("posted") if isinstance(data, dict) else None + if not isinstance(posted, list): + raise ListError("state file has an unexpected format") + return {d for d in posted if isinstance(d, str)} + + +def write_file(path: str, text: str) -> None: + os.makedirs(os.path.dirname(os.path.abspath(path)), exist_ok=True) + tmp = f"{path}.tmp" + with open(tmp, "w", encoding="utf-8") as f: + f.write(text) + os.replace(tmp, path) + + +def save_state(path: str, posted: Iterable[str]) -> None: + write_file(path, json.dumps({"version": 1, "posted": sorted(posted)})) + + +def fetch_advisories(api_url: str, repo: str, token: str) -> list[dict]: + advisories: list[dict] = [] + for state in STATES: + url: str | None = ( + f"{api_url}/repos/{repo}/security-advisories" + f"?state={state}&per_page=100&sort=created&direction=asc" + ) + while url: + request = urllib.request.Request( + url, + headers={ + "Accept": "application/vnd.github+json", + "Authorization": f"Bearer {token}", + "X-GitHub-Api-Version": "2022-11-28", + "User-Agent": "security-advisory-notify", + }, + ) + try: + with urllib.request.urlopen(request, timeout=30) as response: + page = json.load(response) + link = response.headers.get("Link", "") + except urllib.error.HTTPError as e: + e.close() + raise ListError( + f"listing {state} advisories failed with HTTP {e.code}" + ) from None + except (urllib.error.URLError, TimeoutError, ValueError): + raise ListError(f"listing {state} advisories failed") from None + if not isinstance(page, list): + raise ListError(f"listing {state} advisories returned non-list") + advisories.extend(a for a in page if isinstance(a, dict)) + match = LINK_NEXT.search(link) + url = match.group(1) if match else None + return advisories + + +def payload(advisory: dict, server_url: str, repo: str) -> dict: + """The repository_advisory payload for discord-bot, with only what it posts.""" + ghsa_id = advisory["ghsa_id"] + severity = advisory.get("severity") + return { + "repository_advisory": { + "ghsa_id": ghsa_id, + "summary": str(advisory.get("summary") or ""), + "severity": severity if severity in SEVERITIES else None, + "html_url": f"{server_url}/{repo}/security/advisories/{ghsa_id}", + } + } + + +def select_new( + advisories: list[dict], posted: set[str], key: str +) -> tuple[list[dict], set[str]]: + """Return advisories not yet posted, oldest first, and the state after + posting them. The state keeps only advisories still in triage or draft, so + it stays small.""" + current: dict[str, dict] = {} + for advisory in advisories: + ghsa_id = advisory.get("ghsa_id") + if isinstance(ghsa_id, str) and GHSA_ID.match(ghsa_id): + current.setdefault(ghsa_id, advisory) + digests = {ghsa_id: state_digest(key, ghsa_id) for ghsa_id in current} + new = sorted( + (a for i, a in current.items() if digests[i] not in posted), + key=lambda a: (str(a.get("created_at") or ""), a["ghsa_id"]), + ) + return new, set(digests.values()) + + +def write_output(**values: bool) -> None: + path = os.environ.get("GITHUB_OUTPUT") + if path: + with open(path, "a", encoding="utf-8") as f: + f.writelines( + f"{name}={'true' if value else 'false'}\n" + for name, value in values.items() + ) + + +def main(argv: list[str] | None = None) -> int: + parser = argparse.ArgumentParser(description=__doc__.split("\n")[0]) + parser.add_argument( + "--advisories-file", + help="read advisories from this JSON list instead of the API (local runs only)", + ) + args = parser.parse_args(argv) + + if os.environ.get("GITHUB_ACTIONS") == "true" and args.advisories_file: + print("--advisories-file is for local runs only", file=sys.stderr) + return 2 + state_file = os.environ.get("STATE_FILE") + payload_file = os.environ.get("PAYLOAD_FILE") + if not state_file or not payload_file: + print("set STATE_FILE and PAYLOAD_FILE", file=sys.stderr) + return 2 + + repo = os.environ.get("GITHUB_REPOSITORY", "roostorg/coop") + server_url = os.environ.get("GITHUB_SERVER_URL", "https://github.com") + api_url = os.environ.get("GITHUB_API_URL", "https://api.github.com") + key = os.environ.get("STATE_KEY", "") + token = os.environ.get("ADVISORY_READ_TOKEN", "") + if args.advisories_file: + key = key or LOCAL_KEY + elif not key or not token: + print("set STATE_KEY and ADVISORY_READ_TOKEN", file=sys.stderr) + return 2 + + try: + posted = load_state(state_file) + if args.advisories_file: + with open(args.advisories_file, encoding="utf-8") as f: + advisories = json.load(f) + else: + advisories = fetch_advisories(api_url, repo, token) + new, new_state = select_new(advisories, posted, key) + except ListError as e: + print(f"::error::{e}", file=sys.stderr) + return 1 + + write_file( + payload_file, + "".join(json.dumps(payload(a, server_url, repo)) + "\n" for a in new), + ) + changed = new_state != posted + if changed: + save_state(state_file, new_state) + write_output(post=bool(new), changed=changed) + return 0 + + +if __name__ == "__main__": + try: + sys.exit(main()) + except Exception as e: # noqa: BLE001 + # A traceback could include advisory data. + print(f"::error::unexpected {type(e).__name__}", file=sys.stderr) + sys.exit(1) diff --git a/.github/scripts/notify_security_advisories.py b/.github/scripts/notify_security_advisories.py deleted file mode 100755 index f5038034e..000000000 --- a/.github/scripts/notify_security_advisories.py +++ /dev/null @@ -1,292 +0,0 @@ -#!/usr/bin/env python3 -"""Post new triage and draft repository security advisories to Discord. - -Run by .github/workflows/security-advisory-notify.yml. Each message carries only -the GHSA ID, title, severity and a link to the advisory. Workflow logs on this -repository are public, so in CI the script never prints anything about an -advisory, and the state file holds keyed hashes of GHSA IDs, never the IDs. - -Environment: - GITHUB_REPOSITORY owner/repo whose advisories are listed - ADVISORY_READ_TOKEN token that can read unpublished advisories - SECURITY_DISCORD_WEBHOOK Discord webhook URL; also the key for state hashes - STATE_FILE JSON file of advisories already posted - GITHUB_OUTPUT set by Actions; receives changed=true|false - -Local check without a webhook or token (refused under GitHub Actions): - python3 notify_security_advisories.py --dry-run \\ - --advisories-file advisories.json --state-file state.json -""" - -from __future__ import annotations - -import argparse -import hashlib -import hmac -import json -import os -import re -import sys -import time -import urllib.error -import urllib.request -from collections.abc import Callable, Iterable - -STATES = ("triage", "draft") -SEVERITIES = {"critical", "high", "medium", "low"} -GHSA_ID = re.compile(r"^GHSA(-[23456789cfghjmpqrvwx]{4}){3}$") -LINK_NEXT = re.compile(r'<([^>]+)>;\s*rel="next"') -EMBED_TITLE_MAX = 256 -DRY_RUN_KEY = "local-dry-run" - - -class NotifyError(Exception): - """An error whose message is safe to print in a public log.""" - - -def state_digest(key: str, ghsa_id: str) -> str: - return hmac.new(key.encode(), ghsa_id.encode(), hashlib.sha256).hexdigest() - - -def load_state(path: str) -> set[str]: - try: - with open(path, encoding="utf-8") as f: - data = json.load(f) - except FileNotFoundError: - return set() - except (OSError, ValueError) as e: - raise NotifyError("state file is unreadable") from e - posted = data.get("posted") if isinstance(data, dict) else None - if not isinstance(posted, list): - raise NotifyError("state file has an unexpected format") - return {d for d in posted if isinstance(d, str)} - - -def save_state(path: str, posted: Iterable[str]) -> None: - os.makedirs(os.path.dirname(os.path.abspath(path)), exist_ok=True) - tmp = f"{path}.tmp" - with open(tmp, "w", encoding="utf-8") as f: - json.dump({"version": 1, "posted": sorted(posted)}, f) - os.replace(tmp, path) - - -def fetch_advisories(api_url: str, repo: str, token: str) -> list[dict]: - advisories: list[dict] = [] - for state in STATES: - url: str | None = ( - f"{api_url}/repos/{repo}/security-advisories" - f"?state={state}&per_page=100&sort=created&direction=asc" - ) - while url: - request = urllib.request.Request( - url, - headers={ - "Accept": "application/vnd.github+json", - "Authorization": f"Bearer {token}", - "X-GitHub-Api-Version": "2022-11-28", - "User-Agent": "security-advisory-notify", - }, - ) - try: - with urllib.request.urlopen(request, timeout=30) as response: - page = json.load(response) - link = response.headers.get("Link", "") - except urllib.error.HTTPError as e: - e.close() - raise NotifyError( - f"listing {state} advisories failed with HTTP {e.code}" - ) from None - except (urllib.error.URLError, TimeoutError, ValueError): - raise NotifyError(f"listing {state} advisories failed") from None - if not isinstance(page, list): - raise NotifyError(f"listing {state} advisories returned non-list") - advisories.extend(a for a in page if isinstance(a, dict)) - match = LINK_NEXT.search(link) - url = match.group(1) if match else None - return advisories - - -def discord_payload(advisory: dict, server_url: str, repo: str) -> dict: - ghsa_id = advisory["ghsa_id"] - summary = " ".join(str(advisory.get("summary") or "").split()) - title = f"{ghsa_id}: {summary}" if summary else ghsa_id - if len(title) > EMBED_TITLE_MAX: - title = title[: EMBED_TITLE_MAX - 1] + "…" - severity = advisory.get("severity") - return { - "content": f"New security advisory {ghsa_id}", - # Titles come from reporters; never let one ping anyone. - "allowed_mentions": {"parse": []}, - "embeds": [ - { - "title": title, - "url": f"{server_url}/{repo}/security/advisories/{ghsa_id}", - "fields": [ - { - "name": "Severity", - "value": severity if severity in SEVERITIES else "unknown", - "inline": True, - } - ], - } - ], - } - - -def post_to_discord(webhook_url: str, payload: dict) -> None: - body = json.dumps(payload).encode() - for attempt in range(3): - request = urllib.request.Request( - webhook_url, - data=body, - method="POST", - headers={ - "Content-Type": "application/json", - "User-Agent": "security-advisory-notify", - }, - ) - try: - with urllib.request.urlopen(request, timeout=30): - return - except urllib.error.HTTPError as e: - with e: - retry_body = e.read() if e.code == 429 else b"" - if e.code == 429 and attempt < 2: - try: - retry_after = float(json.loads(retry_body).get("retry_after", 2)) - except (ValueError, AttributeError): - retry_after = 2.0 - time.sleep(min(retry_after, 30)) - continue - # Don't print the response body or URL: the URL is the secret. - raise NotifyError(f"Discord webhook returned HTTP {e.code}") from None - except (urllib.error.URLError, TimeoutError): - raise NotifyError("Discord webhook request failed") from None - - -def notify( - advisories: list[dict], - posted: set[str], - key: str, - send: Callable[[dict], None], - server_url: str, - repo: str, -) -> tuple[set[str], bool]: - """Send each advisory not yet posted, oldest first. - - Returns the new state (only advisories still in triage or draft, so it - stays small) and whether anything was sent. If a send fails, the state - passed to the exception holds everything sent before it. - """ - current = {} - for advisory in advisories: - ghsa_id = advisory.get("ghsa_id") - if isinstance(ghsa_id, str) and GHSA_ID.match(ghsa_id): - current.setdefault(ghsa_id, advisory) - ordered = sorted( - current.values(), key=lambda a: (str(a.get("created_at") or ""), a["ghsa_id"]) - ) - - new_state = {d for d in (state_digest(key, i) for i in current) if d in posted} - sent = False - for advisory in ordered: - digest = state_digest(key, advisory["ghsa_id"]) - if digest in new_state: - continue - if sent: - time.sleep(1) # stay under Discord's per-webhook rate limit - try: - send(discord_payload(advisory, server_url, repo)) - except NotifyError as e: - e.partial_state = new_state # type: ignore[attr-defined] - raise - new_state.add(digest) - sent = True - return new_state, sent - - -def write_output(changed: bool) -> None: - path = os.environ.get("GITHUB_OUTPUT") - if path: - with open(path, "a", encoding="utf-8") as f: - f.write(f"changed={'true' if changed else 'false'}\n") - - -def main(argv: list[str] | None = None) -> int: - parser = argparse.ArgumentParser(description=__doc__.split("\n")[0]) - parser.add_argument("--state-file", default=os.environ.get("STATE_FILE")) - parser.add_argument( - "--dry-run", - action="store_true", - help="print Discord payloads instead of posting (local runs only)", - ) - parser.add_argument( - "--advisories-file", - help="read advisories from this JSON list instead of the API (local runs only)", - ) - args = parser.parse_args(argv) - - in_actions = os.environ.get("GITHUB_ACTIONS") == "true" - if in_actions and (args.dry_run or args.advisories_file): - print( - "--dry-run and --advisories-file are for local runs only", file=sys.stderr - ) - return 2 - if not args.state_file: - print("set STATE_FILE or --state-file", file=sys.stderr) - return 2 - - repo = os.environ.get("GITHUB_REPOSITORY", "roostorg/coop") - server_url = os.environ.get("GITHUB_SERVER_URL", "https://github.com") - api_url = os.environ.get("GITHUB_API_URL", "https://api.github.com") - webhook = os.environ.get("SECURITY_DISCORD_WEBHOOK", "") - token = os.environ.get("ADVISORY_READ_TOKEN", "") - - if args.dry_run: - key = webhook or DRY_RUN_KEY - - def send(payload: dict) -> None: - print(json.dumps(payload, indent=2, ensure_ascii=False)) - - else: - if not webhook or not token: - # Not configured: skip without output. - write_output(False) - return 0 - key = webhook - - def send(payload: dict) -> None: - post_to_discord(webhook, payload) - - try: - posted = load_state(args.state_file) - if args.advisories_file: - with open(args.advisories_file, encoding="utf-8") as f: - advisories = json.load(f) - else: - advisories = fetch_advisories(api_url, repo, token) - try: - new_state, _ = notify(advisories, posted, key, send, server_url, repo) - except NotifyError as e: - partial = getattr(e, "partial_state", None) - if partial is not None and partial != posted: - save_state(args.state_file, partial) - write_output(True) - raise - changed = new_state != posted - if changed: - save_state(args.state_file, new_state) - write_output(changed) - return 0 - except NotifyError as e: - print(f"::error::{e}", file=sys.stderr) - return 1 - - -if __name__ == "__main__": - try: - sys.exit(main()) - except Exception as e: # noqa: BLE001 - # A traceback could include advisory data or the webhook URL. - print(f"::error::unexpected {type(e).__name__}", file=sys.stderr) - sys.exit(1) diff --git a/.github/scripts/test_list_new_security_advisories.py b/.github/scripts/test_list_new_security_advisories.py new file mode 100644 index 000000000..eefe0afb2 --- /dev/null +++ b/.github/scripts/test_list_new_security_advisories.py @@ -0,0 +1,236 @@ +"""Tests for list_new_security_advisories.py. + +Run: python3 -m unittest discover -s .github/scripts -p 'test_*.py' +""" + +from __future__ import annotations + +import contextlib +import io +import json +import os +import sys +import tempfile +import threading +import unittest +from http.server import BaseHTTPRequestHandler, HTTPServer +from typing import ClassVar +from unittest import mock +from urllib.parse import parse_qs, urlparse + +sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) +import list_new_security_advisories as lister + +SECRET_TEXT = "SECRET-DESCRIPTION-DO-NOT-LEAK" + + +def advisory(ghsa_id, state="triage", created="2026-10-01T00:00:00Z", **extra): + return { + "ghsa_id": ghsa_id, + "state": state, + "summary": f"Summary of {ghsa_id}", + "severity": "high", + "created_at": created, + "description": SECRET_TEXT, + "html_url": f"https://github.com/roostorg/coop/security/advisories/{ghsa_id}", + "credits": [{"login": "reporter"}], + "vulnerabilities": [{"package": {"name": SECRET_TEXT}}], + **extra, + } + + +A1 = "GHSA-2222-3333-4444" +A2 = "GHSA-cfgh-jmpq-rvwx" +A3 = "GHSA-5678-9cfg-hjmp" + + +class FakeGitHub(BaseHTTPRequestHandler): + """Serves the advisories API, two per page.""" + + advisories: ClassVar[dict[str, list[dict]]] = {} + + def log_message(self, *args): + pass + + def do_GET(self): + url = urlparse(self.path) + query = parse_qs(url.query) + if url.path != "/repos/roostorg/coop/security-advisories": + self.send_response(404) + self.end_headers() + return + if self.headers.get("Authorization") != "Bearer test-token": + self.send_response(401) + self.end_headers() + return + items = self.advisories.get(query["state"][0], []) + start = int(query.get("after", ["0"])[0]) + self.send_response(200) + if start + 2 < len(items): + host = f"http://{self.headers['Host']}" + nxt = f"{host}{url.path}?state={query['state'][0]}&after={start + 2}" + self.send_header("Link", f'<{nxt}>; rel="next"') + self.end_headers() + self.wfile.write(json.dumps(items[start : start + 2]).encode()) + + +class ListerTest(unittest.TestCase): + def setUp(self): + FakeGitHub.advisories = {} + self.server = HTTPServer(("127.0.0.1", 0), FakeGitHub) + threading.Thread(target=self.server.serve_forever, daemon=True).start() + self.tmp = tempfile.TemporaryDirectory() + self.state_file = os.path.join(self.tmp.name, "state", "state.json") + self.payload_file = os.path.join(self.tmp.name, "state", "advisories.jsonl") + self.output_file = os.path.join(self.tmp.name, "output") + self.env = { + "GITHUB_ACTIONS": "true", + "GITHUB_REPOSITORY": "roostorg/coop", + "GITHUB_SERVER_URL": "https://github.com", + "GITHUB_API_URL": f"http://127.0.0.1:{self.server.server_port}", + "GITHUB_OUTPUT": self.output_file, + "ADVISORY_READ_TOKEN": "test-token", + "STATE_KEY": "https://discord.com/api/webhooks/1/secret", + "STATE_FILE": self.state_file, + "PAYLOAD_FILE": self.payload_file, + } + + def tearDown(self): + self.server.shutdown() + self.server.server_close() + self.tmp.cleanup() + + def run_ci(self, env=None, argv=()): + """Run main() as the workflow does; return (exit code, stdout+stderr).""" + out = io.StringIO() + with ( + mock.patch.dict(os.environ, env or self.env, clear=True), + contextlib.redirect_stdout(out), + contextlib.redirect_stderr(out), + ): + code = lister.main(list(argv)) + return code, out.getvalue() + + def outputs(self): + with open(self.output_file) as f: + lines = f.read().splitlines() + return dict(line.split("=", 1) for line in lines[-2:]) + + def payloads(self): + with open(self.payload_file) as f: + return [json.loads(line) for line in f] + + def posted_ids(self): + return [p["repository_advisory"]["ghsa_id"] for p in self.payloads()] + + def test_lists_triage_and_draft_oldest_first_and_prints_nothing(self): + FakeGitHub.advisories = { + "triage": [ + advisory(A2, created="2026-10-03T00:00:00Z"), + advisory(A1, created="2026-10-01T00:00:00Z"), + advisory(A3, created="2026-10-04T00:00:00Z"), + ], + "draft": [advisory("GHSA-wxwx-wxwx-wxwx", "draft", "2026-10-02T00:00:00Z")], + } + self.assertEqual(self.run_ci(), (0, "")) + self.assertEqual(self.posted_ids(), [A1, "GHSA-wxwx-wxwx-wxwx", A2, A3]) + self.assertEqual(self.outputs(), {"post": "true", "changed": "true"}) + + def test_lists_nothing_already_posted(self): + FakeGitHub.advisories = {"triage": [advisory(A1)]} + self.run_ci() + self.assertEqual(self.run_ci(), (0, "")) + self.assertEqual(self.payloads(), []) + self.assertEqual(self.outputs(), {"post": "false", "changed": "false"}) + + def test_payload_contains_only_id_title_severity_and_link(self): + FakeGitHub.advisories = {"triage": [advisory(A1)]} + self.run_ci() + self.assertEqual( + self.payloads(), + [ + { + "repository_advisory": { + "ghsa_id": A1, + "summary": f"Summary of {A1}", + "severity": "high", + "html_url": f"https://github.com/roostorg/coop/security/advisories/{A1}", + } + } + ], + ) + + def test_state_file_does_not_contain_ghsa_ids(self): + FakeGitHub.advisories = {"triage": [advisory(A1)]} + self.run_ci() + with open(self.state_file) as f: + state = f.read() + self.assertNotIn(A1, state) + self.assertNotIn(A1.lower(), state) + + def test_advisory_moving_from_triage_to_draft_is_not_listed_again(self): + FakeGitHub.advisories = {"triage": [advisory(A1)]} + self.run_ci() + FakeGitHub.advisories = {"draft": [advisory(A1, "draft")]} + self.run_ci() + self.assertEqual(self.payloads(), []) + + def test_state_drops_advisories_no_longer_in_triage_or_draft(self): + FakeGitHub.advisories = {"triage": [advisory(A1), advisory(A2)]} + self.run_ci() + FakeGitHub.advisories = {"triage": [advisory(A2)]} + self.run_ci() + self.assertEqual(self.outputs(), {"post": "false", "changed": "true"}) + with open(self.state_file) as f: + self.assertEqual(len(json.load(f)["posted"]), 1) + + def test_api_error_fails_without_touching_state_or_payload(self): + code, logs = self.run_ci({**self.env, "ADVISORY_READ_TOKEN": "wrong"}) + self.assertEqual(code, 1) + self.assertEqual( + logs, "::error::listing triage advisories failed with HTTP 401\n" + ) + self.assertFalse(os.path.exists(self.state_file)) + self.assertFalse(os.path.exists(self.payload_file)) + + def test_changing_the_key_lists_open_advisories_again(self): + FakeGitHub.advisories = {"triage": [advisory(A1)]} + self.run_ci() + self.run_ci({**self.env, "STATE_KEY": "https://discord.com/api/webhooks/2/x"}) + self.assertEqual(self.posted_ids(), [A1]) + + def test_ignores_malformed_ids_and_severities(self): + FakeGitHub.advisories = { + "triage": [ + advisory("not-a-ghsa"), + advisory("GHSA-aaaa-bbbb-cccc"), + advisory(A1, severity="@everyone"), + ] + } + self.run_ci() + self.assertEqual(self.posted_ids(), [A1]) + self.assertIsNone(self.payloads()[0]["repository_advisory"]["severity"]) + + def test_requires_token_and_key(self): + for missing in ("STATE_KEY", "ADVISORY_READ_TOKEN"): + env = {k: v for k, v in self.env.items() if k != missing} + code, _ = self.run_ci(env) + self.assertEqual(code, 2) + + def test_advisories_file_is_refused_in_actions(self): + code, _ = self.run_ci(argv=["--advisories-file", "x.json"]) + self.assertEqual(code, 2) + + def test_local_run_from_advisories_file(self): + fixture = os.path.join(self.tmp.name, "advisories.json") + with open(fixture, "w") as f: + json.dump([advisory(A1)], f) + env = {"STATE_FILE": self.state_file, "PAYLOAD_FILE": self.payload_file} + self.assertEqual(self.run_ci(env, ["--advisories-file", fixture]), (0, "")) + self.assertEqual(self.posted_ids(), [A1]) + with open(self.payload_file) as f: + self.assertNotIn(SECRET_TEXT, f.read()) + + +if __name__ == "__main__": + unittest.main() diff --git a/.github/scripts/test_notify_security_advisories.py b/.github/scripts/test_notify_security_advisories.py deleted file mode 100644 index 1afef18ee..000000000 --- a/.github/scripts/test_notify_security_advisories.py +++ /dev/null @@ -1,314 +0,0 @@ -"""Tests for notify_security_advisories.py. - -Run: python3 -m unittest discover -s .github/scripts -p 'test_*.py' -""" - -from __future__ import annotations - -import contextlib -import io -import json -import os -import sys -import tempfile -import threading -import unittest -from http.server import BaseHTTPRequestHandler, HTTPServer -from typing import ClassVar -from unittest import mock -from urllib.parse import parse_qs, urlparse - -sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) -import notify_security_advisories as notifier - -SECRET_TEXT = "SECRET-DESCRIPTION-DO-NOT-LEAK" - - -def advisory(ghsa_id, state="triage", created="2026-10-01T00:00:00Z", **extra): - return { - "ghsa_id": ghsa_id, - "state": state, - "summary": f"Summary of {ghsa_id}", - "severity": "high", - "created_at": created, - "description": SECRET_TEXT, - "html_url": f"https://github.com/roostorg/coop/security/advisories/{ghsa_id}", - "submission": {"accepted": False}, - "credits": [{"login": "reporter"}], - "vulnerabilities": [{"package": {"name": SECRET_TEXT}}], - **extra, - } - - -A1 = "GHSA-2222-3333-4444" -A2 = "GHSA-cfgh-jmpq-rvwx" -A3 = "GHSA-5678-9cfg-hjmp" - - -class FakeGitHubAndDiscord(BaseHTTPRequestHandler): - """Serves the advisories API (2 per page) and records Discord posts.""" - - advisories: ClassVar[dict[str, list[dict]]] = {} - posts: ClassVar[list[dict]] = [] - discord_status = 204 - - def log_message(self, *args): - pass - - def do_GET(self): - url = urlparse(self.path) - query = parse_qs(url.query) - if url.path != "/repos/roostorg/coop/security-advisories": - self.send_response(404) - self.end_headers() - return - if self.headers.get("Authorization") != "Bearer test-token": - self.send_response(401) - self.end_headers() - return - items = self.advisories.get(query["state"][0], []) - start = int(query.get("after", ["0"])[0]) - page = items[start : start + 2] - self.send_response(200) - if start + 2 < len(items): - host = f"http://{self.headers['Host']}" - nxt = f"{host}{url.path}?state={query['state'][0]}&after={start + 2}" - self.send_header("Link", f'<{nxt}>; rel="next"') - self.end_headers() - self.wfile.write(json.dumps(page).encode()) - - def do_POST(self): - body = self.rfile.read(int(self.headers["Content-Length"])) - if urlparse(self.path).path != "/webhook": - self.send_response(404) - self.end_headers() - return - status = type(self).discord_status - if status == 204: - type(self).posts.append(json.loads(body)) - self.send_response(status) - self.end_headers() - - -class NotifierTest(unittest.TestCase): - def setUp(self): - FakeGitHubAndDiscord.advisories = {} - FakeGitHubAndDiscord.posts = [] - FakeGitHubAndDiscord.discord_status = 204 - self.server = HTTPServer(("127.0.0.1", 0), FakeGitHubAndDiscord) - threading.Thread(target=self.server.serve_forever, daemon=True).start() - base = f"http://127.0.0.1:{self.server.server_port}" - self.tmp = tempfile.TemporaryDirectory() - self.state_file = os.path.join(self.tmp.name, "state", "state.json") - self.output_file = os.path.join(self.tmp.name, "output") - self.env = { - "GITHUB_ACTIONS": "true", - "GITHUB_REPOSITORY": "roostorg/coop", - "GITHUB_SERVER_URL": "https://github.com", - "GITHUB_API_URL": base, - "GITHUB_OUTPUT": self.output_file, - "SECURITY_DISCORD_WEBHOOK": f"{base}/webhook", - "ADVISORY_READ_TOKEN": "test-token", - "STATE_FILE": self.state_file, - } - sleep = mock.patch.object(notifier.time, "sleep") - sleep.start() - self.addCleanup(sleep.stop) - - def tearDown(self): - self.server.shutdown() - self.server.server_close() - self.tmp.cleanup() - - def run_ci(self, env=None): - """Run main() as the workflow does; return (exit code, stdout+stderr).""" - out = io.StringIO() - with ( - mock.patch.dict(os.environ, env or self.env, clear=True), - contextlib.redirect_stdout(out), - contextlib.redirect_stderr(out), - ): - code = notifier.main([]) - return code, out.getvalue() - - def output(self): - with open(self.output_file) as f: - return f.read() - - def test_posts_triage_and_draft_once_oldest_first_and_prints_nothing(self): - FakeGitHubAndDiscord.advisories = { - "triage": [ - advisory(A2, created="2026-10-03T00:00:00Z"), - advisory(A1, created="2026-10-01T00:00:00Z"), - advisory(A3, created="2026-10-04T00:00:00Z"), - ], - "draft": [advisory("GHSA-wxwx-wxwx-wxwx", "draft", "2026-10-02T00:00:00Z")], - } - code, logs = self.run_ci() - self.assertEqual((code, logs), (0, "")) - self.assertEqual( - [ - p["embeds"][0]["url"].rsplit("/", 1)[1] - for p in FakeGitHubAndDiscord.posts - ], - [A1, "GHSA-wxwx-wxwx-wxwx", A2, A3], - ) - self.assertIn("changed=true", self.output()) - - code, logs = self.run_ci() - self.assertEqual((code, logs), (0, "")) - self.assertEqual(len(FakeGitHubAndDiscord.posts), 4) - self.assertTrue(self.output().endswith("changed=false\n")) - - def test_payload_contains_only_id_title_severity_and_link(self): - FakeGitHubAndDiscord.advisories = {"triage": [advisory(A1)]} - self.run_ci() - (payload,) = FakeGitHubAndDiscord.posts - self.assertEqual( - payload, - { - "content": f"New security advisory {A1}", - "allowed_mentions": {"parse": []}, - "embeds": [ - { - "title": f"{A1}: Summary of {A1}", - "url": f"https://github.com/roostorg/coop/security/advisories/{A1}", - "fields": [ - {"name": "Severity", "value": "high", "inline": True} - ], - } - ], - }, - ) - - def test_state_file_does_not_contain_ghsa_ids(self): - FakeGitHubAndDiscord.advisories = {"triage": [advisory(A1)]} - self.run_ci() - with open(self.state_file) as f: - state = f.read() - self.assertNotIn(A1, state) - self.assertNotIn(A1.lower(), state) - - def test_advisory_moving_from_triage_to_draft_is_not_reposted(self): - FakeGitHubAndDiscord.advisories = {"triage": [advisory(A1)]} - self.run_ci() - FakeGitHubAndDiscord.advisories = {"draft": [advisory(A1, "draft")]} - self.run_ci() - self.assertEqual(len(FakeGitHubAndDiscord.posts), 1) - - def test_state_drops_advisories_no_longer_in_triage_or_draft(self): - FakeGitHubAndDiscord.advisories = {"triage": [advisory(A1), advisory(A2)]} - self.run_ci() - FakeGitHubAndDiscord.advisories = {"triage": [advisory(A2)]} - self.run_ci() - self.assertIn("changed=true", self.output().splitlines()[-1]) - with open(self.state_file) as f: - self.assertEqual(len(json.load(f)["posted"]), 1) - - def test_failed_post_keeps_earlier_posts_and_retries_the_rest(self): - FakeGitHubAndDiscord.advisories = { - "triage": [ - advisory(A1, created="2026-10-01T00:00:00Z"), - advisory(A2, created="2026-10-02T00:00:00Z"), - ] - } - real_post = notifier.post_to_discord - calls = [] - - def flaky(url, payload): - calls.append(payload) - if len(calls) == 2: - raise notifier.NotifyError("Discord webhook returned HTTP 500") - real_post(url, payload) - - with mock.patch.object(notifier, "post_to_discord", flaky): - code, logs = self.run_ci() - self.assertEqual(code, 1) - self.assertEqual(logs, "::error::Discord webhook returned HTTP 500\n") - self.assertIn("changed=true", self.output()) - - code, _ = self.run_ci() - self.assertEqual(code, 0) - self.assertEqual( - [p["content"] for p in FakeGitHubAndDiscord.posts], - [f"New security advisory {A1}", f"New security advisory {A2}"], - ) - - def test_discord_error_does_not_log_webhook_or_advisory(self): - FakeGitHubAndDiscord.advisories = {"triage": [advisory(A1)]} - FakeGitHubAndDiscord.discord_status = 400 - code, logs = self.run_ci() - self.assertEqual(code, 1) - self.assertEqual(logs, "::error::Discord webhook returned HTTP 400\n") - - def test_api_error_fails_without_touching_state(self): - env = {**self.env, "ADVISORY_READ_TOKEN": "wrong"} - code, logs = self.run_ci(env) - self.assertEqual(code, 1) - self.assertEqual( - logs, "::error::listing triage advisories failed with HTTP 401\n" - ) - self.assertFalse(os.path.exists(self.state_file)) - - def test_skips_silently_without_secrets(self): - for missing in ("SECURITY_DISCORD_WEBHOOK", "ADVISORY_READ_TOKEN"): - env = {k: v for k, v in self.env.items() if k != missing} - self.assertEqual(self.run_ci(env), (0, "")) - self.assertEqual(FakeGitHubAndDiscord.posts, []) - - def test_rotating_the_webhook_reposts_open_advisories(self): - FakeGitHubAndDiscord.advisories = {"triage": [advisory(A1)]} - self.run_ci() - self.run_ci( - { - **self.env, - "SECURITY_DISCORD_WEBHOOK": self.env["SECURITY_DISCORD_WEBHOOK"] - + "?v=2", - } - ) - self.assertEqual(len(FakeGitHubAndDiscord.posts), 2) - - def test_ignores_malformed_ids_and_severities_and_truncates_titles(self): - FakeGitHubAndDiscord.advisories = { - "triage": [ - advisory("not-a-ghsa"), - advisory("GHSA-aaaa-bbbb-cccc"), - advisory(A1, severity="@everyone", summary="x\n" * 400), - ] - } - self.run_ci() - (payload,) = FakeGitHubAndDiscord.posts - embed = payload["embeds"][0] - self.assertEqual(len(embed["title"]), notifier.EMBED_TITLE_MAX) - self.assertNotIn("\n", embed["title"]) - self.assertEqual(embed["fields"][0]["value"], "unknown") - - def test_local_only_flags_are_refused_in_actions(self): - with ( - mock.patch.dict(os.environ, self.env, clear=True), - contextlib.redirect_stderr(io.StringIO()), - ): - self.assertEqual(notifier.main(["--dry-run"]), 2) - self.assertEqual(notifier.main(["--advisories-file", "x.json"]), 2) - - def test_local_dry_run_prints_payloads_without_posting(self): - fixture = os.path.join(self.tmp.name, "advisories.json") - with open(fixture, "w") as f: - json.dump([advisory(A1)], f) - env = {"STATE_FILE": self.state_file} - out = io.StringIO() - with ( - mock.patch.dict(os.environ, env, clear=True), - contextlib.redirect_stdout(out), - ): - code = notifier.main(["--dry-run", "--advisories-file", fixture]) - self.assertEqual(code, 0) - self.assertEqual( - json.loads(out.getvalue())["content"], f"New security advisory {A1}" - ) - self.assertNotIn(SECRET_TEXT, out.getvalue()) - self.assertEqual(FakeGitHubAndDiscord.posts, []) - - -if __name__ == "__main__": - unittest.main() diff --git a/.github/workflows/security-advisory-notify.yml b/.github/workflows/security-advisory-notify.yml index 9bbad8bb4..d85e754e4 100644 --- a/.github/workflows/security-advisory-notify.yml +++ b/.github/workflows/security-advisory-notify.yml @@ -1,6 +1,7 @@ # Posts each new repository security advisory in triage or draft state to the -# private security Discord channel: GHSA ID, title, severity and link only. -# GitHub Actions has no advisory event, so this polls the REST API. +# private security Discord channel with roostorg/discord-bot: GHSA ID, title, +# severity and link only. GitHub Actions has no advisory event, so this polls +# the REST API. # # Secrets (the job skips silently when either is missing): # SECURITY_DISCORD_WEBHOOK webhook URL of the private security channel @@ -32,12 +33,12 @@ jobs: env: CONFIGURED: ${{ secrets.SECURITY_DISCORD_WEBHOOK != '' && secrets.ADVISORY_READ_TOKEN != '' }} steps: - - name: Checkout notifier script + - name: Checkout advisory script if: env.CONFIGURED == 'true' uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1 with: persist-credentials: false - sparse-checkout: .github/scripts/notify_security_advisories.py + sparse-checkout: .github/scripts/list_new_security_advisories.py sparse-checkout-cone-mode: false - name: Restore posted-advisory state @@ -48,17 +49,27 @@ jobs: key: security-advisory-notify-${{ github.run_id }}-${{ github.run_attempt }} restore-keys: security-advisory-notify- - - name: Post new advisories - id: notify + - name: List new advisories + id: list if: env.CONFIGURED == 'true' env: - SECURITY_DISCORD_WEBHOOK: ${{ secrets.SECURITY_DISCORD_WEBHOOK }} ADVISORY_READ_TOKEN: ${{ secrets.ADVISORY_READ_TOKEN }} + STATE_KEY: ${{ secrets.SECURITY_DISCORD_WEBHOOK }} STATE_FILE: ${{ runner.temp }}/security-advisory-notify/state.json - run: python3 .github/scripts/notify_security_advisories.py + PAYLOAD_FILE: ${{ runner.temp }}/security-advisory-notify/advisories.jsonl + run: python3 .github/scripts/list_new_security_advisories.py + + - name: Post new advisories + if: env.CONFIGURED == 'true' && steps.list.outputs.post == 'true' + uses: roostorg/discord-bot@493e4f5f707a1ab338ca2c33319f54b79ae2c603 # reitblatt/repository-advisories + with: + webhook-url: ${{ secrets.SECURITY_DISCORD_WEBHOOK }} + event: repository_advisory + payload-path: ${{ runner.temp }}/security-advisory-notify/advisories.jsonl + # Only after posting succeeds, so a failed post is retried next run. - name: Save posted-advisory state - if: always() && env.CONFIGURED == 'true' && steps.notify.outputs.changed == 'true' + if: env.CONFIGURED == 'true' && steps.list.outputs.changed == 'true' uses: actions/cache/save@55cc8345863c7cc4c66a329aec7e433d2d1c52a9 # v6.1.0 with: path: ${{ runner.temp }}/security-advisory-notify/state.json From ccad995fb06eea5ecaa298fdda4b039620738002 Mon Sep 17 00:00:00 2001 From: claude-agent Date: Tue, 3 Nov 2026 22:02:45 +0000 Subject: [PATCH 3/6] ci: run advisory notifications only on main Address review: skip manual dispatches from other branches, document the duplicate-post behaviour on a partial batch failure, and use a single import style for unittest in the tests. Co-Authored-By: Claude Opus 5.5 --- .github/scripts/test_list_new_security_advisories.py | 2 +- .github/workflows/security-advisory-notify.yml | 7 ++++++- 2 files changed, 7 insertions(+), 2 deletions(-) diff --git a/.github/scripts/test_list_new_security_advisories.py b/.github/scripts/test_list_new_security_advisories.py index eefe0afb2..11f2cee5e 100644 --- a/.github/scripts/test_list_new_security_advisories.py +++ b/.github/scripts/test_list_new_security_advisories.py @@ -13,9 +13,9 @@ import tempfile import threading import unittest +import unittest.mock as mock from http.server import BaseHTTPRequestHandler, HTTPServer from typing import ClassVar -from unittest import mock from urllib.parse import parse_qs, urlparse sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) diff --git a/.github/workflows/security-advisory-notify.yml b/.github/workflows/security-advisory-notify.yml index d85e754e4..6147c7cfe 100644 --- a/.github/workflows/security-advisory-notify.yml +++ b/.github/workflows/security-advisory-notify.yml @@ -28,6 +28,9 @@ concurrency: jobs: notify: name: Post new advisories to Discord + # A manual dispatch from another branch would run that branch's copy of the + # script with these secrets, so only main runs it. + if: github.ref == 'refs/heads/main' runs-on: ubuntu-latest timeout-minutes: 10 env: @@ -67,7 +70,9 @@ jobs: event: repository_advisory payload-path: ${{ runner.temp }}/security-advisory-notify/advisories.jsonl - # Only after posting succeeds, so a failed post is retried next run. + # Only after posting succeeds, so a failed post is retried next run. If a + # post fails partway through a batch, the advisories posted before it are + # posted again on the next run: a duplicate rather than a missed alert. - name: Save posted-advisory state if: env.CONFIGURED == 'true' && steps.list.outputs.changed == 'true' uses: actions/cache/save@55cc8345863c7cc4c66a329aec7e433d2d1c52a9 # v6.1.0 From ff8889ba8dcd95ba75e3e7c184b98fc482ee60d4 Mon Sep 17 00:00:00 2001 From: claude-agent Date: Tue, 3 Nov 2026 22:29:59 +0000 Subject: [PATCH 4/6] ci: read advisory notification secrets from a main-only environment Co-Authored-By: Claude Opus 5.5 --- .github/workflows/security-advisory-notify.yml | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/.github/workflows/security-advisory-notify.yml b/.github/workflows/security-advisory-notify.yml index 6147c7cfe..af8ba3e09 100644 --- a/.github/workflows/security-advisory-notify.yml +++ b/.github/workflows/security-advisory-notify.yml @@ -3,7 +3,8 @@ # severity and link only. GitHub Actions has no advisory event, so this polls # the REST API. # -# Secrets (the job skips silently when either is missing): +# Secrets of the security-advisory-notify environment, which only main can +# deploy to (the job skips silently when either is missing): # SECURITY_DISCORD_WEBHOOK webhook URL of the private security channel # ADVISORY_READ_TOKEN fine-grained token, this repository only, # "Repository security advisories: Read-only" @@ -28,9 +29,10 @@ concurrency: jobs: notify: name: Post new advisories to Discord - # A manual dispatch from another branch would run that branch's copy of the - # script with these secrets, so only main runs it. + # The environment's branch policy keeps its secrets on main; the if skips + # other branches quietly instead of failing on that policy. if: github.ref == 'refs/heads/main' + environment: security-advisory-notify runs-on: ubuntu-latest timeout-minutes: 10 env: From 618e22b2604a8db72412d8fb0f87e6d83d1da951 Mon Sep 17 00:00:00 2001 From: claude-agent Date: Tue, 3 Nov 2026 22:33:29 +0000 Subject: [PATCH 5/6] ci: post advisory state instead of title Advisory titles are written by reporters and can reveal the vulnerability. Pin roostorg/discord-bot to the matching commit on #19. Co-Authored-By: Claude Opus 5.5 --- .github/scripts/list_new_security_advisories.py | 5 +++-- .github/scripts/test_list_new_security_advisories.py | 6 +++--- .github/workflows/security-advisory-notify.yml | 4 ++-- 3 files changed, 8 insertions(+), 7 deletions(-) diff --git a/.github/scripts/list_new_security_advisories.py b/.github/scripts/list_new_security_advisories.py index dfc15ddab..420982604 100755 --- a/.github/scripts/list_new_security_advisories.py +++ b/.github/scripts/list_new_security_advisories.py @@ -3,7 +3,7 @@ Run by .github/workflows/security-advisory-notify.yml, which posts the result with roostorg/discord-bot. Writes PAYLOAD_FILE with one repository_advisory -payload per line, holding only the GHSA ID, title, severity and link, and +payload per line, holding only the GHSA ID, state, severity and link, and updates STATE_FILE to include them. The workflow saves the state only after posting succeeds. @@ -118,11 +118,12 @@ def fetch_advisories(api_url: str, repo: str, token: str) -> list[dict]: def payload(advisory: dict, server_url: str, repo: str) -> dict: """The repository_advisory payload for discord-bot, with only what it posts.""" ghsa_id = advisory["ghsa_id"] + state = advisory.get("state") severity = advisory.get("severity") return { "repository_advisory": { "ghsa_id": ghsa_id, - "summary": str(advisory.get("summary") or ""), + "state": state if state in STATES else None, "severity": severity if severity in SEVERITIES else None, "html_url": f"{server_url}/{repo}/security/advisories/{ghsa_id}", } diff --git a/.github/scripts/test_list_new_security_advisories.py b/.github/scripts/test_list_new_security_advisories.py index 11f2cee5e..bae3bfcd5 100644 --- a/.github/scripts/test_list_new_security_advisories.py +++ b/.github/scripts/test_list_new_security_advisories.py @@ -28,7 +28,7 @@ def advisory(ghsa_id, state="triage", created="2026-10-01T00:00:00Z", **extra): return { "ghsa_id": ghsa_id, "state": state, - "summary": f"Summary of {ghsa_id}", + "summary": SECRET_TEXT, "severity": "high", "created_at": created, "description": SECRET_TEXT, @@ -143,7 +143,7 @@ def test_lists_nothing_already_posted(self): self.assertEqual(self.payloads(), []) self.assertEqual(self.outputs(), {"post": "false", "changed": "false"}) - def test_payload_contains_only_id_title_severity_and_link(self): + def test_payload_contains_only_id_state_severity_and_link(self): FakeGitHub.advisories = {"triage": [advisory(A1)]} self.run_ci() self.assertEqual( @@ -152,7 +152,7 @@ def test_payload_contains_only_id_title_severity_and_link(self): { "repository_advisory": { "ghsa_id": A1, - "summary": f"Summary of {A1}", + "state": "triage", "severity": "high", "html_url": f"https://github.com/roostorg/coop/security/advisories/{A1}", } diff --git a/.github/workflows/security-advisory-notify.yml b/.github/workflows/security-advisory-notify.yml index af8ba3e09..9174d1bf8 100644 --- a/.github/workflows/security-advisory-notify.yml +++ b/.github/workflows/security-advisory-notify.yml @@ -1,5 +1,5 @@ # Posts each new repository security advisory in triage or draft state to the -# private security Discord channel with roostorg/discord-bot: GHSA ID, title, +# private security Discord channel with roostorg/discord-bot: GHSA ID, state, # severity and link only. GitHub Actions has no advisory event, so this polls # the REST API. # @@ -66,7 +66,7 @@ jobs: - name: Post new advisories if: env.CONFIGURED == 'true' && steps.list.outputs.post == 'true' - uses: roostorg/discord-bot@493e4f5f707a1ab338ca2c33319f54b79ae2c603 # reitblatt/repository-advisories + uses: roostorg/discord-bot@017c8e460a052d8461f2d612129b993dbbbd90fc # reitblatt/repository-advisories with: webhook-url: ${{ secrets.SECURITY_DISCORD_WEBHOOK }} event: repository_advisory From cb825985022e7524d716518286bfd140cbd9167a Mon Sep 17 00:00:00 2001 From: claude-agent Date: Mon, 9 Nov 2026 20:38:21 +0000 Subject: [PATCH 6/6] ci: pin roostorg/discord-bot to main after #19 merged Co-Authored-By: Claude Opus 5.5 --- .github/workflows/security-advisory-notify.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/security-advisory-notify.yml b/.github/workflows/security-advisory-notify.yml index 9174d1bf8..399bbdf5b 100644 --- a/.github/workflows/security-advisory-notify.yml +++ b/.github/workflows/security-advisory-notify.yml @@ -66,7 +66,7 @@ jobs: - name: Post new advisories if: env.CONFIGURED == 'true' && steps.list.outputs.post == 'true' - uses: roostorg/discord-bot@017c8e460a052d8461f2d612129b993dbbbd90fc # reitblatt/repository-advisories + uses: roostorg/discord-bot@308d8cce31f854d50182558bf29851f01e493acf # main with: webhook-url: ${{ secrets.SECURITY_DISCORD_WEBHOOK }} event: repository_advisory