Files
047aadde86 fix(ci): keep alert rule and location out of the public CodeQL triage issue (#4863)
## Description

The weekly CodeQL triage issue (`scripts/codeql_triage.sh`, run by
`.github/workflows/codeql-triage.yml`) is opened in this public repo,
but its body listed every open critical/high alert with its rule id,
file path, line and alert number. Until an alert is fixed, that names
the location of an unfixed vulnerability to anyone.

The issue now carries only the number of open critical and high alerts
and a link to the code scanning page, which only authorized roles can
open. Weekly idempotency is unchanged (one issue per ISO week, reused
even when closed). A re-run in the same week comments with new counts
when they differ from the last recorded counts, or when an open alert's
`updated_at` (creation, reopen, other changes) is later than that
record, so a closed alert replaced by a reopened one is still reported.
The hidden marker holds only the counts; the record time is the public
timestamp of the issue or comment carrying it. Only an issue opened by
`TRIAGE_BOT_LOGIN` (default `github-actions[bot]`) counts as the week's
issue, and only markers that account wrote are read; a failed read stops
the run.

Closes #

## Type of Change

- [x] Bug fix (non-breaking change that fixes an issue)
- [ ] New feature (non-breaking change that adds functionality)
- [ ] Breaking change (fix or feature that would cause existing
functionality to change)
- [ ] Documentation update
- [ ] Performance improvement
- [ ] Code refactoring (no functional changes)

## Changes Made

- `scripts/codeql_triage.sh`: jq emits `<severity> <created_at>` rows
that stay local; the issue body and re-run comments carry counts, a
link, and a `codeql-triage-state:c<N>-h<M>` marker. The per-alert
checklist is gone. Issue and comments are fetched with checked commands
before parsing.
- `.github/workflows/codeql-triage.yml`: header comment describes the
new issue content.
- `tests/test_codeql_triage_script.py` (12 tests): a closed-and-reopened
swap with unchanged counts posts; an issue opened by someone else is not
reused; the issue body and comments contain no rule id, path, line or
alert number, and markers hold counts only; a same-week re-run with the
same alerts posts nothing; a new alert with unchanged counts still
posts; a marker in a non-bot comment is ignored; a failed comments read
exits non-zero without posting.

## Testing

- [x] Unit tests pass (`pytest`)
- [x] Linting passes (`ruff check .`)
- [x] Type checking passes (`mypy headroom`)
- [x] New tests added for new functionality
- [ ] Manual testing performed

### Test Output

```text
$ pytest -q tests/test_codeql_triage_script.py
10 passed

# same tests against the origin/main script
5 failed, 5 passed
```

## Real Behavior Proof

- Environment: macOS, bash, the real authenticated `gh` CLI against
`headroomlabs-ai/headroom`. A wrapper passes every `gh api` call (alert
listing, issue listing, issue and comment reads) to the real `gh` and
prints `gh issue create` / `gh issue comment` instead of posting them,
so the production repo was not written to.
- Exact command / steps: `PATH=<wrapper>:$PATH
REPO=headroomlabs-ai/headroom TRIAGE_ASSIGNEE=<owner> bash
scripts/codeql_triage.sh`
- Observed result: the script found this week's existing issue (#4718,
author `github-actions[bot]`, body in the old format with no state
marker) and would post one comment: `<!-- codeql-triage-state:c0-h0
-->`, `Now open: critical 0, high 0.` and the code scanning link. It
contains no rule, path, line or alert number.
- Not tested: an actual post. The first scheduled run after merge in a
week whose issue predates this change posts one such update comment,
since that issue has no marker yet.

## Runtime Rollout Safety

- Rollout-managed feature(s): none
- Minimum rollout channel: n/a
- Stable/default behavior changed: CI only; no runtime change.
- Kill switch / disable path: n/a
- Unsafe override required: no
- Qualification impact: none
- Rollback path: revert this commit.

## Review Readiness

- [x] I have performed a self-review
- [x] This PR is ready for human review

## Checklist

- [x] My code follows the project's style guidelines
- [x] I have performed a self-review of my code
- [x] I have commented my code, particularly in hard-to-understand areas
- [x] I have made corresponding changes to the documentation
- [x] My changes generate no new warnings
- [x] I have added tests that prove my fix is effective or that my
feature works
- [x] New and existing unit tests pass locally with my changes
- [x] I did **not** edit `CHANGELOG.md` — it is generated by
release-please from my Conventional Commit PR title (a CI guard enforces
this)

## Additional Notes

Existing triage issues already posted keep their old content; closing or
editing them is a separate manual step.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Reported by @JoaoMarcos44. Thank you for your contribution! 🩵

---------

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
Co-authored-by: JerrettDavis <mxjerrett@gmail.com>
2026-11-21 16:37:27 -08:00

135 lines
6.3 KiB
Bash
Executable File

#!/usr/bin/env bash
# Weekly CodeQL triage issue, run by .github/workflows/codeql-triage.yml.
#
# The issue is public, so it carries only counts of open critical/high alerts
# and a link to the code scanning page (visible to authorized roles only):
# never an alert's rule, file, line or number.
#
# Idempotent per ISO week. The week key is the ISO week of "today" (UTC), so a
# re-run of Monday's job and a manual dispatch later the same week both find
# the issue already opened for that week, including a closed one, and reuse it
# instead of opening another. A reused issue is never edited, reopened or
# retitled, so its closure stands. Each issue body and update comment records
# the counts in a hidden marker. A re-run comments with the new counts when
# they differ from the last recorded ones, or when an open alert changed after
# that record (its updated_at moves when it is created, reopened or otherwise
# changed, so one alert closing while another reopens is still reported);
# otherwise it does nothing. The marker holds only the counts, and the time of
# the record is the public timestamp of the issue or comment carrying it, so
# nothing in the issue identifies an alert. Only an issue opened by
# TRIAGE_BOT_LOGIN counts as the week's issue, and only markers it wrote (the
# issue body and its own comments) are read, so nobody else can silence an
# update by opening an issue or commenting. If the bot identity changes, the
# week gets a new issue rather than reusing one opened under the old identity.
#
# Env: REPO (owner/name), TRIAGE_ASSIGNEE (login). TRIAGE_BOT_LOGIN (default
# github-actions[bot], the GITHUB_TOKEN identity) is the author whose comments
# are trusted. TRIAGE_TODAY (YYYY-MM-DD) overrides the date for tests. Needs
# gh, jq and python3.
set -euo pipefail
: "${REPO:?REPO is required}"
: "${TRIAGE_ASSIGNEE:?TRIAGE_ASSIGNEE is required}"
today="${TRIAGE_TODAY:-$(date -u +%Y-%m-%d)}"
bot="${TRIAGE_BOT_LOGIN:-github-actions[bot]}"
# ISO week key (e.g. 2026-W41) and that week's Monday. Python's isocalendar
# handles the year boundary (2027-01-01 is in 2026-W53) on any platform's date.
read -r week_key week_start < <(python3 -c '
import datetime, sys
d = datetime.date.fromisoformat(sys.argv[1])
y, w, wd = d.isocalendar()
print(f"{y}-W{w:02d}", d - datetime.timedelta(days=wd - 1))
' "$today")
marker="<!-- codeql-triage:${week_key} -->"
# jq programs live in quoted heredocs: they are literal jq, not shell, so
# nothing in them is expanded and no single-quoted '$' or backtick is left for
# ShellCheck (SC2016) to misread.
alert_rows_jq=$(cat <<'JQ'
.[] | select(.rule.security_severity_level == "critical" or .rule.security_severity_level == "high")
| "\(.rule.security_severity_level) \(.updated_at // .created_at)"
JQ
)
# Input: the issue object, then the comment pages. Output: "<state> <time>" of
# the last marker in the issue body or a bot comment, or nothing.
last_state_jq=$(cat <<'JQ'
.[0] as $issue
| ([$issue] + (.[1:] | add // []))
| map(select(.user.login == $bot) | {at: .created_at, s: ((.body // "") | capture("<!-- codeql-triage-state:(?<s>c[0-9]+-h[0-9]+) -->") | .s)})
| last // empty
| "\(.s) \(.at)"
JQ
)
week_issue_jq=$(cat <<'JQ'
.[] | select(.pull_request | not) | select(.user.login == $bot)
| select((.body // "") | contains($marker)) | .number
JQ
)
# One "<severity> <updated_at>" row per open critical/high alert. Kept local:
# only the counts are written to the issue.
alerts="$(gh api --paginate -X GET "repos/$REPO/code-scanning/alerts" -f state=open -f per_page=100 \
| jq -r "$alert_rows_jq")"
critical="$(printf '%s' "$alerts" | grep -c '^critical ' || true)"
high="$(printf '%s' "$alerts" | grep -c '^high ' || true)"
count=$((critical + high))
state="c${critical}-h${high}"
state_marker="<!-- codeql-triage-state:${state} -->"
link="https://github.com/$REPO/security/code-scanning?query=is%3Aopen+severity%3Acritical%2Chigh"
# Listing, not search: the search index lags, so an issue created seconds ago
# by the previous run could be missed. state=all so a closed issue counts.
existing="$(gh api --paginate "repos/$REPO/issues?state=all&labels=security&per_page=100" \
| jq -r --arg marker "$marker" --arg bot "$bot" "$week_issue_jq" | head -n 1)"
if [ -n "$existing" ]; then
# Read both before parsing, so a failed request stops the run instead of
# passing for "no marker" and posting a duplicate or skipping an update.
issue_json="$(gh api "repos/$REPO/issues/$existing")"
comments_json="$(gh api --paginate "repos/$REPO/issues/$existing/comments")"
recorded="$(printf '%s\n%s\n' "$issue_json" "$comments_json" \
| jq -rs --arg bot "$bot" "$last_state_jq")"
recorded_state="${recorded%% *}"
recorded_at="${recorded#* }"
# ISO-8601 UTC timestamps compare correctly as strings.
changed_since="$(printf '%s\n' "$alerts" \
| awk -v at="$recorded_at" 'NF == 2 && $2 > at { n++ } END { print n + 0 }')"
if [ -n "$recorded" ] && [ "$recorded_state" = "$state" ] && [ "$changed_since" -eq 0 ]; then
echo "Week $week_key already has issue #$existing and the open critical/high alerts are unchanged. Nothing to do."
exit 0
fi
{
echo "$state_marker"
echo "Re-run on $today: the open critical/high alerts changed since the last update."
echo "Now open: critical $critical, high $high. Review them in code scanning: $link"
} > comment.md
gh issue comment "$existing" --repo "$REPO" --body-file comment.md
echo "Week $week_key: posted updated counts to #$existing."
exit 0
fi
{
echo "$marker"
echo "$state_marker"
echo "Weekly code scanning triage for the week of **$week_start** ($week_key). Owner: @$TRIAGE_ASSIGNEE (tejas@headroomlabs.ai)."
echo
echo "For each open alert: fix it (link the PR in the alert) or dismiss it in code scanning with a reason. Close this issue when none is left open."
echo "Target: critical and high fixed or dismissed within the vulnerability management SLA."
echo
echo "### Open critical/high alerts: $count"
echo
if [ "$count" -eq 0 ]; then
echo "None. Close this issue to record the review."
else
echo "Critical: $critical, high: $high. Details are in code scanning (authorized roles only): $link"
fi
echo
echo "All open alerts: https://github.com/$REPO/security/code-scanning"
} > body.md
gh issue create --repo "$REPO" \
--title "CodeQL triage: week of $week_start ($count critical/high open)" \
--body-file body.md \
--assignee "$TRIAGE_ASSIGNEE" \
--label security