superbyte-ghsa-maintainer

Manage GHSA security advisories and validate private fork PRs.

Updated Aug 27, 2026
One-click install
npx skills add https://github.com/qkal/superbyte --skill superbyte-ghsa-maintainer
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: superbyte-ghsa-maintainer
Source: https://github.com/qkal/superbyte/tree/main/.agents/skills/superbyte-ghsa-maintainer
Command: npx skills add https://github.com/qkal/superbyte --skill superbyte-ghsa-maintainer

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This skill centralizes the management of SuperByte GHSA security advisories and their private-fork state, enabling safe review, patching, and publishing workflows.

Core Features & Use Cases

  • Inspect current advisory state and linked private fork details.
  • Patch advisory data safely, validate payload shapes, and transition states to published.
  • Verify that the advisory's private fork has no open PRs before publishing, ensuring a clean release process.
  • Use Case: When a new GHSA is detected, fetch it, patch the vulnerability payload, and publish after checks.

Quick Start

Run the GHSA maintainer workflow to fetch the advisory state and publish when ready.

Frequently Asked Questions about superbyte-ghsa-maintainer

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I manage GitHub GHSA security advisories for a repository?

To manage GitHub GHSA security advisories, you can fetch advisory states via the GitHub API, patch vulnerability payloads using jq, and transition publishing states with safety checks.

How does validating a private fork's PRs work before publishing a GHSA advisory?

Validating a private fork's PRs before publishing a GHSA advisory works by verifying that no open pull requests exist in the linked private fork, ensuring a clean release process and safe state transition.

Can I patch GHSA advisory data safely and validate payload shapes?

Yes, you can safely patch GHSA advisory data and validate payload shapes by applying JSON patching with jq and executing safety checks before transitioning the advisory state to published.

What is the best way to transition a GHSA advisory state to published?

The best way to transition a GHSA advisory state to published is to fetch the advisory state, patch the vulnerability payload, verify no open PRs exist in the private fork, and then execute the publishing state transition with safety checks.

Do I need jq to patch GHSA advisories using the GitHub API?

Yes, you need jq to perform JSON patching on GHSA advisories fetched via the GitHub API, allowing you to safely modify the vulnerability payload before validating and publishing.

Why does publishing a GHSA advisory fail when the private fork has open PRs?

Publishing a GHSA advisory fails when the private fork has open PRs because the workflow implements safety checks that verify a clean release process, blocking the state transition until the PRs are resolved.