# GitHub on boxd

> GitHub is a code hosting platform for version control and collaboration, offering Git-based repository management, issue tracking, and continuous integration features.

- Page: https://boxd.sh/integrations/github/
- CLI: `run github` (890 commands, 65 marked common)
- SDK: `import { github } from "@boxd/run"`; every parameter and response type is at `@boxd/run/github`
- Triggers: 46
- Connect: `run auth github` (Sign in with GitHub), or https://app.boxd.sh/integrations/detail/github
- All integrations: https://boxd.sh/integrations/ (Markdown: https://boxd.sh/integrations/index.md)

## From the shell

```sh
run auth github      # once: prints a link to connect your account
run github           # list its commands
run github list-repositories
```

Parameters are flags (`--flag value`); object and array parameters take a JSON string. Output is YAML, or JSON with `--json`. Calls use your own connection; `--scope <name>` uses a connection shared with your team.

## From a script

```ts
import { github } from "@boxd/run";

const result = await github.listRepositories({});
console.log(result);

github.on("pull-request-created", async (event) => {
  // New Pull Request Created: runs on this machine, once per event
  console.log(event);
});
```

Run it with `run github.run.ts`. A script that calls `.on()` keeps running as a job and handles each event.

## Commands

Required flags are listed; `run github <command> --help` lists the optional ones. "common" marks what `run github` shows without `--all`.

| Command | SDK method | Required flags | Optional | Description |
|---|---|---|---|---|
| `abort-repository-migration` | `github.abortRepositoryMigration()` | `--migrationId` | 1 | Abort a repository migration that is queued or in progress |
| `accept-repository-invitation` | `github.acceptRepositoryInvitation()` | `--invitation-id` | 0 | Accepts a PENDING repository invitation that has been issued to the authenticated user |
| `add-app-access-restrictions` | `github.addAppAccessRestrictions()` | `--apps` `--branch` `--owner` `--repo` | 0 | Adds GitHub Apps to the list of apps allowed to push to a protected branch |
| `add-assignees-to-issue` ·common | `github.addAssigneesToIssue()` | `--issue-number` `--owner` `--repo` | 1 | Adds assignees to a GitHub issue |
| `add-email-address-for-authenticated-user` ·common | `github.addEmailAddressForAuthenticatedUser()` | `--emails` | 0 | Adds one or more email addresses (which will be initially unverified) to the authenticated user's GitHub account; use this to associate new emails, noting an email verified for another account will… |
| `add-field-to-user-project` | `github.addFieldToUserProject()` | `--data-type` `--name` `--project-number` `--username` | 2 | Add a custom field to a user-owned GitHub Projects V2 project |
| `add-item-to-user-project` | `github.addItemToUserProject()` | `--project-number` `--type` `--username` | 4 | Add an issue or pull request to a user-owned GitHub project |
| `add-labels-to-issue` ·common | `github.addLabelsToIssue()` | `--issue-number` `--labels` `--owner` `--repo` | 0 | Adds labels (provided in the request body) to a repository issue; labels that do not already exist are created |
| `add-or-update-team-membership-for-user` ·common | `github.addOrUpdateTeamMembershipForUser()` | `--org` `--team-slug` `--username` | 1 | Adds a GitHub user to a team or updates their role (member or maintainer), inviting them to the organization if not already a member; idempotent, returning current details if no change is made |
| `add-or-update-team-project-permissions` | `github.addOrUpdateTeamProjectPermissions()` | `--org` `--project-id` `--team-slug` | 1 | Adds a classic project to a team or updates the team's permission on it |
| `add-or-update-team-repository-permissions` | `github.addOrUpdateTeamRepositoryPermissions()` | `--org` `--owner` `--repo` `--team-slug` | 1 | Sets or updates a team's permission level for a repository within an organization; the team must be a member of the organization |
| `add-org-runner-labels` | `github.addOrgRunnerLabels()` | `--labels` `--org` `--runner-id` | 0 | Adds new custom labels to an existing self-hosted runner for an organization; existing labels are not removed, and duplicates are not added |
| `add-project-collaborator` | `github.addProjectCollaborator()` | `--project-id` `--username` | 1 | Adds a specified GitHub user as a collaborator to an existing organization project with a given permission level |
| `add-repo-to-org-secret-with-selected-access` | `github.addRepoToOrgSecretWithSelectedAccess()` | `--org` `--repository-id` `--secret-name` | 0 | Adds a repository to an existing organization-level GitHub Actions secret that is configured for 'selected' repository access |
| `add-repo-to-org-secret-with-selected-visibility` | `github.addRepoToOrgSecretWithSelectedVisibility()` | `--org` `--repository-id` `--secret-name` | 0 | Grants an existing repository access to an existing organization-level Dependabot secret when the secret's visibility is set to 'selected'; the repository must belong to the organization, and the… |
| `add-repository-collaborator` ·common | `github.addRepositoryCollaborator()` | `--owner` `--repo` `--username` | 1 | Adds a GitHub user as a repository collaborator, or updates their permission if already a collaborator; `permission` applies to organization-owned repositories (personal ones default to 'push' and… |
| `add-repository-to-app-installation` | `github.addRepositoryToAppInstallation()` | `--installation-id` `--repository-id` | 0 | Adds a repository to a GitHub App installation, granting the app access; requires authenticated user to have admin rights for the repository and access to the installation |
| `add-runner-labels` | `github.addRunnerLabels()` | `--labels` `--owner` `--repo` `--runner-id` | 0 | Adds and appends custom labels to a self-hosted repository runner, which must be registered and active |
| `add-selected-repository-to-organization-secret` | `github.addSelectedRepositoryToOrganizationSecret()` | `--org` `--repository-id` `--secret-name` | 0 | Adds a repository to an organization secret's access list when the secret's visibility is 'selected'; this operation is idempotent |
| `add-selected-repository-to-organization-variable` | `github.addSelectedRepositoryToOrganizationVariable()` | `--name` `--org` `--repository-id` | 0 | Grants a repository access to an organization-level GitHub Actions variable, if that variable's visibility is set to 'selected_repositories' |
| `add-selected-repository-to-user-secret` | `github.addSelectedRepositoryToUserSecret()` | `--repository-id` `--secret-name` | 0 | Grants a specified repository access to an authenticated user's existing Codespaces secret, enabling Codespaces created for that repository to use the secret |
| `add-social-accounts-for-authenticated-user` | `github.addSocialAccountsForAuthenticatedUser()` | `--account-urls` | 0 | Adds one or more social media links (which must be valid, full URLs for platforms supported by GitHub) to the authenticated user's public GitHub profile |
| `add-status-check-contexts` | `github.addStatusCheckContexts()` | `--branch` `--contexts` `--owner` `--repo` | 0 | Adds status check contexts to a protected branch's required status checks |
| `add-sub-issue` | `github.addSubIssue()` | `--issue-id` | 4 | Add a sub-issue to a parent GitHub issue using GraphQL |
| `add-team-access-restrictions` | `github.addTeamAccessRestrictions()` | `--branch` `--owner` `--repo` `--teams` | 0 | Adds teams to the list of teams with push access to a protected branch |
| `add-user-access-restrictions` | `github.addUserAccessRestrictions()` | `--branch` `--owner` `--repo` `--users` | 0 | Adds users to the list of people allowed to push to a protected branch in an organization repository |
| `add-users-to-codespaces-access-for-organization` | `github.addUsersToCodespacesAccessForOrganization()` | `--org` `--selected-usernames` | 0 | Adds organization members to the list of users granted Codespaces access billed to the organization |
| `api-root` | `github.apiRoot()` | — | 0 | Retrieves a map of all top-level GitHub REST API resource URLs and their templates |
| `approve-workflow-run-for-fork-pull-request` ·common | `github.approveWorkflowRunForForkPullRequest()` | `--owner` `--repo` `--run-id` | 0 | Approves a workflow run from a forked repository's pull request; call this when such a run requires manual approval due to workflow configuration |
| `assign-organization-role-to-team` | `github.assignOrganizationRoleToTeam()` | `--org` `--role-id` `--team-slug` | 0 | Assigns an existing organization-level role (identified by `role_id`) to a team (identified by `team_slug`) within a GitHub organization (`org`), provided the organization, team, and role already… |
| `assign-organization-role-to-user` | `github.assignOrganizationRoleToUser()` | `--org` `--role-id` `--username` | 0 | Assigns a specific organization role to a user who is a member or an outside collaborator in a GitHub organization, using a valid role ID |
| `auth-user-docker-conflict-packages-list` | `github.authUserDockerConflictPackagesList()` | — | 0 | List Docker packages with migration conflicts for the authenticated user |
| `block-user` | `github.blockUser()` | `--username` | 0 | Blocks an existing individual GitHub user (not an organization or your own account), preventing them from interacting with your account and repositories |
| `block-user-from-organization` | `github.blockUserFromOrganization()` | `--org` `--username` | 0 | Blocks a GitHub user from an organization, preventing their contributions, collaboration, and forking of the organization's repositories |
| `cancel-pages-deployment` | `github.cancelPagesDeployment()` | `--owner` `--pages-deployment-id` `--repo` | 0 | Cancels an existing, ongoing or queued GitHub Pages deployment for a repository using its `pages_deployment_id` |
| `cancel-sponsorship` | `github.cancelSponsorship()` | — | 5 | Cancel an active GitHub sponsorship using GraphQL |
| `cancel-workflow-run` | `github.cancelWorkflowRun()` | `--owner` `--repo` `--run-id` | 0 | Cancels a workflow run in a GitHub repository if it is in a cancellable state (e.g., 'in_progress' or 'queued') |
| `check-following` | `github.checkFollowing()` | `--username` | 0 | Check if the authenticated user is following a specified person on GitHub |
| `check-if-gist-is-starred` | `github.checkIfGistIsStarred()` | `--gist-id` | 0 | Checks if a gist is starred by the authenticated user |
| `check-if-pull-request-has-been-merged` | `github.checkIfPullRequestHasBeenMerged()` | `--owner` `--pull-number` `--repo` | 0 | Checks if a specified GitHub pull request has been merged, indicated by a 204 HTTP status (merged) or 404 (not merged/found) |
| `check-if-pull-request-merged` ·common | `github.checkIfPullRequestMerged()` | `--owner` `--pull-number` `--repo` | 0 | Checks if a pull request has been merged by querying the GitHub API |
| `check-if-repo-starred-by-auth-user` ·deprecated | `github.checkIfRepoStarredByAuthUser()` | `--owner` `--repo` | 0 | Use `GITHUB_CHECK_IF_A_REPOSITORY_IS_STARRED_BY_THE_USER` instead |
| `check-if-user-can-be-assigned` | `github.checkIfUserCanBeAssigned()` | `--assignee` `--owner` `--repo` | 0 | Verifies if a GitHub user can be assigned to issues in a repository; assignability is confirmed by an HTTP 204 (No Content) response, resulting in an empty 'data' field in the response |
| `check-if-user-can-be-assigned-to-issue` | `github.checkIfUserCanBeAssignedToIssue()` | `--assignee` `--issue-number` `--owner` `--repo` | 0 | Checks if a specified GitHub user can be assigned to a given issue within a repository |
| `check-if-user-follows-another-user` | `github.checkIfUserFollowsAnotherUser()` | `--target-user` `--username` | 0 | Checks if a GitHub user `username` follows `target_user`; returns a 204 HTTP status if true, 404 if not or if users are invalid |
| `check-if-user-is-blocked-by-authenticated-user` | `github.checkIfUserIsBlockedByAuthenticatedUser()` | `--username` | 0 | Checks if the specified GitHub user is blocked by the authenticated user; a 204 No Content response indicates the user is blocked, while a 404 Not Found indicates they are not |
| `check-if-user-is-blocked-by-organization` | `github.checkIfUserIsBlockedByOrganization()` | `--org` `--username` | 0 | Checks if a GitHub user is blocked by an organization |
| `check-if-user-is-repository-collaborator` | `github.checkIfUserIsRepositoryCollaborator()` | `--owner` `--repo` `--username` | 0 | Checks if a user is a collaborator on a specified GitHub repository, returning a 204 status if they are, or a 404 status if they are not or if the repository/user does not exist |
| `check-person-followed-by-auth-user` | `github.checkPersonFollowedByAuthUser()` | `--username` | 0 | Checks if the authenticated GitHub user follows a target GitHub user |
| `check-private-vulnerability-reporting-status` | `github.checkPrivateVulnerabilityReportingStatus()` | `--owner` `--repo` | 0 | Checks if private vulnerability reporting is enabled for the specified repository |
| `check-public-organization-membership-for-user` | `github.checkPublicOrganizationMembershipForUser()` | `--org` `--username` | 0 | Check if a user is a public member of an organization |
| `check-repository-starred` | `github.checkRepositoryStarred()` | `--owner` `--repo` | 0 | Check if a repository is starred by the authenticated user |
| `check-team-permissions-for-project` | `github.checkTeamPermissionsForProject()` | `--org` `--project-id` `--team-slug` | 0 | Checks if a team has 'read', 'write', or 'admin' permissions for an organization's specific classic project, returning the project's details if access is confirmed |
| `check-team-permissions-for-repository` | `github.checkTeamPermissionsForRepository()` | `--org` `--owner` `--repo` `--team-slug` | 0 | Checks a team's permissions for a specific repository within an organization, including permissions inherited from parent teams |
| `check-token` | `github.checkToken()` | `--access-token` `--client-id` | 0 | Checks if a GitHub App or OAuth access_token is valid for the specified client_id and retrieves its details, typically to verify its active status and grants |
| `clear-project-v2-item-field-value` | `github.clearProjectV2ItemFieldValue()` | `--fieldId` `--itemId` `--projectId` | 0 | Clear the value of a field for an item in a GitHub Project V2 |
| `clear-repository-cache-by-key` | `github.clearRepositoryCacheByKey()` | `--key` `--owner` `--repo` | 1 | Deletes GitHub Actions caches from a repository matching a specific `key` and an optional Git `ref`, used to manage storage or clear outdated/corrupted caches; the action succeeds even if no matching… |
| `clear-self-hosted-runner-org-labels` | `github.clearSelfHostedRunnerOrgLabels()` | `--org` `--runner-id` | 0 | Removes all custom labels from a self-hosted runner for an organization; default labels (e.g., 'self-hosted', 'linux', 'x64') will remain |
| `close-issue` ·common | `github.closeIssue()` | `--issue-number` `--owner` `--repo` | 1 | Close a GitHub issue by setting its state to closed |
| `close-pull-request` ·common | `github.closePullRequest()` | `--owner` `--pull-number` `--repo` | 0 | Closes an open pull request without merging it |
| `commit-multiple-files` ·common | `github.commitMultipleFiles()` | `--branch` `--message` `--owner` `--repo` | 7 | Atomically create, update, or delete multiple files in a GitHub repository as a single commit |
| `compare-two-commits` ·common | `github.compareTwoCommits()` | `--basehead` `--owner` `--repo` | 2 | Compares two commit points (commits, branches, tags, or SHAs) within a repository or across forks, using `BASE...HEAD` or `OWNER:REF...OWNER:REF` format for the `basehead` parameter |
| `configure-jit-runner-for-org` | `github.configureJitRunnerForOrg()` | `--labels` `--name` `--org` `--runner-group-id` | 1 | Generates a JIT configuration for a GitHub organization's new self-hosted runner to run a single job then unregister; requires admin:org scope and the runner_group_id must exist in the organization |
| `configure-oidc-subject-claim-template` | `github.configureOidcSubjectClaimTemplate()` | `--include-claim-keys` `--org` | 0 | Sets or updates the OIDC subject claim customization template for an existing GitHub organization by specifying which claims (e.g., 'repo', 'actor') form the OIDC token's subject (`sub`) |
| `convert-org-member-to-outside-collaborator` | `github.convertOrgMemberToOutsideCollaborator()` | `--org` `--username` | 1 | Converts an existing organization member, who is not an owner, to an outside collaborator, restricting their access to explicitly granted repositories |
| `convert-pull-request-to-draft` | `github.convertPullRequestToDraft()` | `--pullRequestId` | 1 | Converts an open pull request to draft status, indicating it is not ready for review |
| `create-app-from-manifest` | `github.createAppFromManifest()` | `--code` | 0 | Use this action to complete the GitHub App Manifest flow (step 3 of 3) by exchanging the temporary authorization `code` for the app's full configuration, including credentials and private key |
| `create-autolink-reference-for-repository` | `github.createAutolinkReferenceForRepository()` | `--key-prefix` `--owner` `--repo` `--url-template` | 1 | Creates a repository autolink to automatically convert text references (e.g., 'TICKET-123') into hyperlinks, using a unique `key_prefix` and a `url_template` that includes `<num>` |
| `create-blob` ·common | `github.createBlob()` | `--content` `--owner` `--repo` | 1 | Creates a Git blob in a repository, requiring content and encoding ('utf-8' or 'base64') |
| `create-branch` ·common | `github.createBranch()` | `--branch-name` `--owner` `--repo` `--sha` | 0 | Creates a new branch in a GitHub repository pointing to a specified commit |
| `create-check-run` | `github.createCheckRun()` | `--head-sha` `--name` `--owner` `--repo` | 12 | Creates a new check run for a specific commit in a repository, used by external services to report status, detailed feedback, annotations, and images directly within the GitHub UI |
| `create-check-suite` | `github.createCheckSuite()` | `--head-sha` `--owner` `--repo` | 0 | Creates a new check suite for a specific commit (`head_sha`) in an original repository (not a fork) |
| `create-codespace-for-authenticated-user` | `github.createCodespaceForAuthenticatedUser()` | — | 3 | Creates a GitHub Codespace for the authenticated user, requiring a JSON request body with either `repository_id` (integer) or a `pull_request` object (containing `pull_request_number` (integer) and… |
| `create-codespace-from-pull-request` | `github.createCodespaceFromPullRequest()` | `--owner` `--pull-number` `--repo` | 10 | Creates a GitHub Codespace for an open pull request in a Codespaces-enabled repository, with options to customize its configuration |
| `create-codespace-in-repository` | `github.createCodespaceInRepository()` | `--owner` `--repo` | 11 | Creates a GitHub Codespace for the authenticated user in a specified repository, which must be accessible and use a valid `devcontainer.json` if `devcontainer_path` is specified |
| `create-commit` ·common | `github.createCommit()` | `--message` `--owner` `--repo` `--tree` | 8 | Creates a new commit in a GitHub repository; the `tree` SHA and any `parents` SHAs must already exist in the repository |
| `create-commit-comment` | `github.createCommitComment()` | `--body` `--commit-sha` `--owner` `--repo` | 3 | Creates a comment on a specific commit, or on a specific line if `path` and `position` are provided |
| `create-commit-signature-protection` | `github.createCommitSignatureProtection()` | `--branch` `--owner` `--repo` | 0 | Enables commit signature protection for a specified branch, requiring all new commits to be signed |
| `create-commit-status` | `github.createCommitStatus()` | `--owner` `--repo` `--sha` `--state` | 3 | Sets a commit's status (e.g., error, failure, pending, success from CI/CD) for a given SHA; max 1000 statuses per SHA/context |
| `create-custom-organization-role` | `github.createCustomOrganizationRole()` | `--name` `--org` `--permissions` | 1 | Creates a custom role with defined permissions within a GitHub organization |
| `create-deploy-key` | `github.createDeployKey()` | `--key` `--owner` `--repo` | 2 | Creates a deploy key for a repository; the repository must exist and be accessible, and the provided key must be a valid public SSH key |
| `create-deployment` | `github.createDeployment()` | `--owner` `--ref` `--repo` | 8 | Creates a GitHub deployment for an existing repository, targeting a specific ref (branch, tag, or SHA) that must also exist within the repository |
| `create-deployment-branch-policy` | `github.createDeploymentBranchPolicy()` | `--environment-name` `--name` `--owner` `--repo` | 1 | Creates a deployment branch or tag policy for an existing environment in a GitHub repository, using a Ruby File.fnmatch pattern (where `*` doesn't match `/`) to specify which branches or tags are… |
| `create-deployment-protection-rule` | `github.createDeploymentProtectionRule()` | `--environment-name` `--owner` `--repo` | 1 | Enables a custom deployment protection rule for an existing environment in a repository by linking a configured GitHub App (via `integration_id`) to control deployments |
| `create-deployment-status` | `github.createDeploymentStatus()` | `--deployment-id` `--owner` `--repo` `--state` | 6 | Creates a status for an existing deployment, updating its operational state, associated URLs, and description |
| `create-discussion` | `github.createDiscussion()` | `--body` `--org` `--team-slug` `--title` | 1 | Creates a new discussion post on a specific team's page within an organization |
| `create-discussion-comment` | `github.createDiscussionComment()` | `--body` `--discussion-number` `--org` `--team-slug` | 0 | Creates a new comment on an existing team discussion within a GitHub organization |
| `create-draft-item-for-user-project` ·common | `github.createDraftItemForUserProject()` | `--project-number` `--title` `--username` | 1 | Creates a draft issue item in a user-owned GitHub ProjectsV2 |
| `create-environment-variable` | `github.createEnvironmentVariable()` | `--environment-name` `--name` `--owner` `--repo` `--value` | 0 | Creates an encrypted environment variable for a pre-existing environment within a GitHub repository; will fail if the variable name already exists |
| `create-fork` | `github.createFork()` | `--owner` `--repo` | 3 | Creates a fork of an accessible repository, optionally into a specific organization, with a new name, or copying only the default branch |
| `create-gist` | `github.createGist()` | `--files` | 2 | Creates a new gist on GitHub with provided files, an optional description, and public/secret visibility |
| `create-gist-comment` | `github.createGistComment()` | `--body` `--gist-id` | 0 | Creates a new comment on a specified GitHub gist |
| `create-inference-chat-completions` | `github.createInferenceChatCompletions()` | `--messages` `--model` | 13 | Create chat completions using GitHub Models inference API |
| `create-inference-embeddings` | `github.createInferenceEmbeddings()` | `--input` `--model` | 3 | Create inference embeddings using GitHub's AI models |
| `create-issue` ·common | `github.createIssue()` | `--owner` `--repo` `--title` | 5 | Creates a new issue in a GitHub repository, requiring the repository to exist and have issues enabled; specific fields like assignees, milestone, or labels may require push access |
| `create-issue-comment` ·common | `github.createIssueComment()` | `--body` `--issue-number` `--owner` `--repo` | 0 | Creates a new comment on an existing GitHub issue or pull request within the specified repository |
| `create-issue-type` | `github.createIssueType()` | `--is-enabled` `--name` `--org` | 2 | Create a new issue type for a GitHub organization |
| `create-jit-runner-config` | `github.createJitRunnerConfig()` | `--labels` `--name` `--owner` `--repo` `--runner-group-id` | 1 | Generates a temporary Just-In-Time (JIT) configuration for a new self-hosted GitHub Actions runner for a repository; any specified non-default `runner_group_id` must be an existing runner group… |
| `create-label` | `github.createLabel()` | `--color` `--name` `--owner` `--repo` | 1 | Creates a new label in a specified GitHub repository, provided the repository exists and the user has write permissions |
| `create-milestone` | `github.createMilestone()` | `--owner` `--repo` `--title` | 3 | Creates a milestone in a GitHub repository for tracking progress on issues or pull requests; requires repository existence and user write permissions |
| `create-or-update-custom-properties-for-org` | `github.createOrUpdateCustomPropertiesForOrg()` | `--org` `--properties` | 0 | Creates new custom property schemas or updates existing ones in bulk for a specified organization; each property definition must include `property_name` and `value_type` |
| `create-or-update-custom-property-org` | `github.createOrUpdateCustomPropertyOrg()` | `--custom-property-name` `--org` `--value-type` | 5 | Creates a new custom property (name must be unique for creation) or updates an existing one for an organization to define metadata for its repositories |
| `create-or-update-environment` | `github.createOrUpdateEnvironment()` | `--environment-name` `--owner` `--repo` | 5 | Creates a new environment or updates an existing one in a GitHub repository, allowing configuration of deployment protection rules such as wait timers and reviewers; ensure `environment_name` is… |
| `create-or-update-environment-secret` | `github.createOrUpdateEnvironmentSecret()` | `--encrypted-value` `--environment-name` `--key-id` `--owner` `--repo` `--secret-name` | 0 | Creates or updates an environment secret with an `encrypted_value` that was encrypted using the public key identified by `key_id` for the specified environment |
| `create-or-update-file-contents` ·common | `github.createOrUpdateFileContents()` | `--content` `--message` `--owner` `--path` `--repo` | 8 | Creates a new file or updates an existing file in a GitHub repository; SHA can be provided to validate file updates, automatically fetched if not provided |
| `create-or-update-organization-secret` | `github.createOrUpdateOrganizationSecret()` | `--encrypted-value` `--key-id` `--org` `--secret-name` `--visibility` | 1 | Creates or updates an organization secret for GitHub Actions, requiring its value to be pre-encrypted via LibSodium using the organization's public key |
| `create-or-update-pages-site` | `github.createOrUpdatePagesSite()` | `--owner` `--repo` | 5 | Enable or update GitHub Pages configuration for a repository |
| `create-or-update-repo-secret-with-encrypted-value` | `github.createOrUpdateRepoSecretWithEncryptedValue()` | `--owner` `--repo` `--secret-name` | 2 | Creates or updates a Dependabot secret in a repository using an `encrypted_value` (pre-encrypted with LibSodium using the repository's Dependabot public key) and its corresponding `key_id` |
| `create-or-update-repository-secret` | `github.createOrUpdateRepositorySecret()` | `--owner` `--repo` `--secret-name` | 2 | Creates or updates a GitHub Actions secret within a specific repository; use `encrypted_value` and `key_id` to set or change its value |
| `create-or-update-secret-for-authenticated-user` | `github.createOrUpdateSecretForAuthenticatedUser()` | `--secret-name` | 4 | Creates or updates a Codespaces secret for the authenticated user; `encrypted_value` must be encrypted with the public key (ID: `key_id`) from GitHub's 'Get public key for the authenticated user'… |
| `create-organization-project` | `github.createOrganizationProject()` | `--name` `--org` | 1 | Creates a new classic project board within a specified GitHub organization |
| `create-organization-repository` ·common | `github.createOrganizationRepository()` | `--name` `--org` | 24 | Creates a new repository within a specified GitHub organization, with options for detailed configuration including visibility, features, merge strategies, initial commit, and templates |
| `create-organization-variable` | `github.createOrganizationVariable()` | `--name` `--org` `--value` `--visibility` | 1 | Creates a new, uniquely named GitHub Actions variable for an organization, with configurable repository access visibility (all, private, or selected) |
| `create-organization-webhook` | `github.createOrganizationWebhook()` | `--config--url` `--org` | 8 | Creates a webhook for a GitHub organization to deliver event notifications to a configured URL |
| `create-pages-deployment` | `github.createPagesDeployment()` | `--oidc-token` `--owner` `--repo` | 4 | Creates a GitHub Pages deployment for a repository using a specified artifact and OIDC token, provided GitHub Pages is enabled and the artifact (containing static assets) is accessible |
| `create-pages-site` | `github.createPagesSite()` | `--owner` `--repo` | 3 | Configures or updates GitHub Pages for a repository, setting build type and source; ensure a Pages workflow exists for 'workflow' `build_type`, or `source_branch` exists for 'legacy' or unspecified… |
| `create-project-card` | `github.createProjectCard()` | `--column-id` | 3 | Creates a project card in a GitHub project column (classic projects only) |
| `create-project-column` | `github.createProjectColumn()` | `--name` `--project-id` | 0 | Creates a new column in a GitHub project (classic) |
| `create-pull-request` ·common | `github.createPullRequest()` | `--base` `--head` `--owner` `--repo` | 6 | Creates a pull request in a GitHub repository, requiring existing `base` and `head` branches; `title` or `issue` must be provided |
| `create-reaction-for-commit-comment` | `github.createReactionForCommitComment()` | `--comment-id` `--content` `--owner` `--repo` | 0 | Creates an emoji reaction for a commit comment; if the user has already reacted with the same content, details of the existing reaction are returned |
| `create-reaction-for-issue` | `github.createReactionForIssue()` | `--content` `--issue-number` `--owner` `--repo` | 0 | Creates a reaction for a specified issue within a GitHub repository |
| `create-reaction-for-issue-comment` | `github.createReactionForIssueComment()` | `--comment-id` `--content` `--owner` `--repo` | 0 | Creates a reaction for a specific comment on an issue within a GitHub repository |
| `create-reaction-for-pull-request-review-comment` | `github.createReactionForPullRequestReviewComment()` | `--comment-id` `--content` `--owner` `--repo` | 0 | Adds a specified reaction to a pull request review comment within a GitHub repository |
| `create-reaction-for-release` | `github.createReactionForRelease()` | `--content` `--owner` `--release-id` `--repo` | 0 | Creates an emoji reaction for a specific, existing release in a GitHub repository |
| `create-reaction-for-team-discussion` | `github.createReactionForTeamDiscussion()` | `--content` `--discussion-number` `--org` `--team-slug` | 0 | Creates a reaction for a team discussion within a GitHub organization |
| `create-reaction-for-team-discussion-comment` | `github.createReactionForTeamDiscussionComment()` | `--comment-number` `--content` `--discussion-number` `--org` `--team-slug` | 0 | Adds a reaction to a team discussion comment, requiring the specified organization, team, discussion, and comment to exist |
| `create-reference` ·common | `github.createReference()` | `--owner` `--ref` `--repo` `--sha` | 0 | Creates a NEW Git reference (branch or tag) in a repository |
| `create-registration-token-for-organization` | `github.createRegistrationTokenForOrganization()` | `--org` | 0 | Generates a temporary (one-hour) registration token to add a new self-hosted runner to an organization for GitHub Actions |
| `create-registration-token-for-repository` | `github.createRegistrationTokenForRepository()` | `--owner` `--repo` | 0 | Generates a time-limited token required to register a new self-hosted runner with a specific repository |
| `create-release` ·common | `github.createRelease()` | `--owner` `--repo` `--tag-name` | 8 | Creates a release in a GitHub repository for a specified tag; the tag must be unique for published releases, and if a `discussion_category_name` is given, it must already exist |
| `create-remove-token-for-organization` | `github.createRemoveTokenForOrganization()` | `--org` | 0 | Generates a token, valid for one hour, to authenticate removing a self-hosted runner from an organization |
| `create-remove-token-for-repository` | `github.createRemoveTokenForRepository()` | `--owner` `--repo` | 0 | Generates a temporary (one-hour validity) token required to unregister and remove a self-hosted runner from a repository |
| `create-reply-for-review-comment` | `github.createReplyForReviewComment()` | `--body` `--comment-id` `--owner` `--pull-number` `--repo` | 0 | Posts a reply to a specific review comment on a GitHub pull request, requiring the repository, pull request, and original comment to exist, and a non-empty reply body |
| `create-repository` ·common | `github.createRepository()` | `--name` | 21 | Creates a new repository for the authenticated user |
| `create-repository-dispatch-event` | `github.createRepositoryDispatchEvent()` | `--event-type` `--owner` `--repo` | 1 | Triggers a GitHub Actions workflow or a webhook on a repository by creating a repository dispatch event, allowing programmatic triggering of workflows based on events outside of GitHub |
| `create-repository-for-authenticated-user` | `github.createRepositoryForAuthenticatedUser()` | `--name` | 22 | Creates a new repository for the authenticated user, optionally within an organization if `team_id` is specified |
| `create-repository-from-unpublished-codespace` | `github.createRepositoryFromUnpublishedCodespace()` | `--codespace-name` | 2 | Publishes the specified codespace to a new repository, using the codespace's current state as the initial commit |
| `create-repository-project` | `github.createRepositoryProject()` | `--name` `--owner` `--repo` | 1 | Creates a new GitHub Projects V2 project board linked to a specified repository |
| `create-repository-ruleset` | `github.createRepositoryRuleset()` | `--enforcement` `--name` `--owner` `--repo` | 5 | Creates a uniquely named ruleset for a repository, defining rules for branches or tags with specified enforcement, conditions, and bypass actors |
| `create-repository-using-template` | `github.createRepositoryUsingTemplate()` | `--name` `--template-owner` `--template-repo` | 4 | Creates a new repository from an existing template repository; the authenticated user must have access to the template and, if creating in an organization, repository creation permissions within it |
| `create-repository-variable` | `github.createRepositoryVariable()` | `--name` `--owner` `--repo` `--value` | 0 | Creates a new, unencrypted variable in a repository for GitHub Actions workflows; fails if a variable with the same name already exists |
| `create-repository-webhook` | `github.createRepositoryWebhook()` | `--owner` `--repo` | 7 | Creates a webhook for a specified repository; requires admin permissions on the repository |
| `create-review-comment-for-pull-request` | `github.createReviewCommentForPullRequest()` | `--body` `--commit-id` `--owner` `--path` `--pull-number` `--repo` | 6 | Creates a review comment on a pull request's diff, targeting a specific line, range of lines, an entire file, or replying to an existing comment |
| `create-review-for-pull-request` | `github.createReviewForPullRequest()` | `--owner` `--pull-number` `--repo` | 4 | Creates a pull request review, allowing approval, change requests, or comments; `body` is required if `event` is `REQUEST_CHANGES` or `COMMENT`, and omitting `event` makes the review `PENDING` |
| `create-scoped-access-token` | `github.createScopedAccessToken()` | `--access-token` `--client-id` | 52 | Exchanges a user-to-server token for a new, fine-grained scoped access token for a GitHub App, requiring `client_id`, `access_token`, either `target` or `target_id`, and at least one permission; for… |
| `create-snapshot-of-dependencies-for-repository` | `github.createSnapshotOfDependenciesForRepository()` | `--owner` `--ref` `--repo` `--scanned` `--sha` `--version` | 8 | Creates a snapshot of a repository's dependencies to populate the GitHub dependency graph and enable security alerts; `sha` must be a 40-character commit ID, `ref` a fully qualified Git reference… |
| `create-sponsors-tier` | `github.createSponsorsTier()` | `--amount` `--description` `--sponsorable-id` | 1 | Create a new payment tier for your GitHub Sponsors profile using GraphQL |
| `create-sponsorship` | `github.createSponsorship()` | `--amount` | 7 | Start a new GitHub sponsorship or reactivate a past sponsorship using GraphQL |
| `create-tag-object` | `github.createTagObject()` | `--message` `--object` `--owner` `--repo` `--tag` `--type` | 3 | Creates an annotated Git tag object in a repository, pointing to an existing Git object (commit, tree, or blob) defined by its SHA and ensuring the `type` field correctly specifies the object's type |
| `create-tag-protection-state-for-repository` ·deprecated | `github.createTagProtectionStateForRepository()` | `--owner` `--pattern` `--repo` | 0 | This API was sunset on August 30, 2024 |
| `create-team` | `github.createTeam()` | `--name` `--org` | 7 | Creates a new team in an organization, optionally with maintainers, repositories, specific privacy, notification settings, or a parent team; if `parent_team_id` is given, `privacy` must be 'closed' |
| `create-temporary-private-fork` | `github.createTemporaryPrivateFork()` | `--ghsa-id` `--owner` `--repo` | 0 | Creates a temporary private fork of the specified repository to address a security vulnerability, linking the fork to a GHSA ID that must be specifically associated with this repository; the fork may… |
| `create-tree` ·common | `github.createTree()` | `--owner` `--repo` `--tree` | 1 | Creates a new Git tree object in a repository, defining file/directory structure by specifying tree entries, optionally building on a `base_tree` SHA; all provided SHAs must be valid |
| `create-update-org-secret-with-lib-sodium` | `github.createUpdateOrgSecretWithLibSodium()` | `--org` `--secret-name` `--visibility` | 3 | Creates or updates a Dependabot organization secret, requiring the secret value to be pre-encrypted with LibSodium using the organization's public key obtained from the 'Get an organization public… |
| `create-user-list` | `github.createUserList()` | `--name` | 2 | Create a new user list on GitHub |
| `create-user-project` | `github.createUserProject()` | `--name` | 1 | Creates a new GitHub Projects V2 project board for the authenticated user to organize and track issues, pull requests, and notes |
| `create-view-for-user-project` | `github.createViewForUserProject()` | `--layout` `--name` `--project-number` `--user-id` | 2 | Create a new view in a user-owned GitHub project (Projects V2) |
| `create-workflow-dispatch-event` | `github.createWorkflowDispatchEvent()` | `--owner` `--ref` `--repo` `--workflow-id` | 1 | Manually triggers a GitHub Actions workflow identified by `workflow_id` at a given `ref`, if the workflow is configured to accept `workflow_dispatch` events |
| `decline-repository-invitation` | `github.declineRepositoryInvitation()` | `--invitation-id` | 0 | Declines a specific, pending repository invitation for the authenticated user, identified by its `invitation_id` |
| `delete-access-restrictions` | `github.deleteAccessRestrictions()` | `--branch` `--owner` `--repo` | 0 | Removes all user, team, and app-based access restrictions from a protected branch |
| `delete-actions-cache-by-id` | `github.deleteActionsCacheById()` | `--cache-id` `--owner` `--repo` | 0 | Deletes a specific GitHub Actions cache from a repository using its unique `cache_id` |
| `delete-admin-branch-protection` | `github.deleteAdminBranchProtection()` | `--branch` `--owner` `--repo` | 0 | Removes admin enforcement from a protected branch (branch name cannot contain wildcard characters) in a repository |
| `delete-app-authorization` | `github.deleteAppAuthorization()` | `--access-token` `--client-id` | 0 | Deletes an OAuth application grant for a user, which revokes ALL OAuth tokens and their associated authorizations for the application |
| `delete-app-token` | `github.deleteAppToken()` | `--access-token` `--client-id` | 0 | Revokes a single OAuth access token for an OAuth App or GitHub App with OAuth authorization |
| `delete-artifact` | `github.deleteArtifact()` | `--artifact-id` `--owner` `--repo` | 0 | Deletes a GitHub artifact by its ID within a repository, typically resulting in an empty response (HTTP 204 No Content) on success |
| `delete-autolink-reference` | `github.deleteAutolinkReference()` | `--autolink-id` `--owner` `--repo` | 0 | Deletes a specific autolink reference (which automatically links external resource IDs like JIRA-123 to URLs) from the specified repository |
| `delete-branch-protection` | `github.deleteBranchProtection()` | `--branch` `--owner` `--repo` | 0 | Removes all protection rules from a specific branch in a GitHub repository; the branch must currently have protection rules enabled |
| `delete-code-scanning-analysis` | `github.deleteCodeScanningAnalysis()` | `--analysis-id` `--owner` `--repo` | 1 | Deletes a specific code scanning analysis by its ID from a repository; `confirm_delete` must be `true` if it's the last analysis of its type for a given tool and reference to prevent data loss |
| `delete-codespace` | `github.deleteCodespace()` | `--codespace-name` | 0 | Deletes a specific codespace owned by the authenticated user; this is a destructive action and the codespace must exist |
| `delete-commit-comment` | `github.deleteCommitComment()` | `--comment-id` `--owner` `--repo` | 0 | Deletes a specific commit comment, identified by its `comment_id`, from the specified repository; the comment must exist |
| `delete-commit-comment-reaction` | `github.deleteCommitCommentReaction()` | `--comment-id` `--owner` `--reaction-id` `--repo` | 0 | Deletes a reaction from a commit comment in a GitHub repository |
| `delete-commit-signature-protection` | `github.deleteCommitSignatureProtection()` | `--branch` `--owner` `--repo` | 0 | Disables GPG commit signature protection for a specific branch in a GitHub repository, meaning commits pushed to this branch no longer require GPG signing |
| `delete-custom-organization-role` | `github.deleteCustomOrganizationRole()` | `--org` `--role-id` | 0 | Deletes a custom organization role (which should not be actively assigned) by its ID; a 204 No Content response indicates success |
| `delete-dependebot-secret-by-name` | `github.deleteDependebotSecretByName()` | `--owner` `--repo` `--secret-name` | 0 | Deletes a specific Dependabot secret, identified by its name, from a given repository if both the repository and secret exist |
| `delete-deploy-key` | `github.deleteDeployKey()` | `--key-id` `--owner` `--repo` | 0 | Deletes a specific deploy key from a repository; to change a key's properties or access scope, the existing key must be deleted and a new one created |
| `delete-deployment` | `github.deleteDeployment()` | `--deployment-id` `--owner` `--repo` | 0 | Permanently deletes a specified *inactive* deployment from a repository |
| `delete-deployment-branch-policy` | `github.deleteDeploymentBranchPolicy()` | `--branch-policy-id` `--environment-name` `--owner` `--repo` | 0 | Deletes a specific deployment branch or tag policy, identified by its ID, from a given environment within a repository |
| `delete-discussion` | `github.deleteDiscussion()` | `--discussion-number` `--org` `--team-slug` | 0 | Deletes a specific team discussion, identified by its number, from an organization's team |
| `delete-discussion-comment` | `github.deleteDiscussionComment()` | `--comment-number` `--discussion-number` `--org` `--team-slug` | 0 | Deletes a specific comment from an existing team discussion within an organization, provided the specified organization, team, discussion, and comment all exist |
| `delete-email-address` | `github.deleteEmailAddress()` | `--emails` | 0 | Sends an empty request body to `DELETE /user/emails` to attempt deletion of user email addresses; the API typically requires specific emails, so outcome may vary |
| `delete-environment` | `github.deleteEnvironment()` | `--environment-name` `--owner` `--repo` | 0 | Deletes an existing deployment environment from an existing repository |
| `delete-environment-secret` | `github.deleteEnvironmentSecret()` | `--environment-name` `--owner` `--repo` `--secret-name` | 0 | Deletes an existing and accessible secret from a specified environment within a GitHub repository, returning an empty dictionary on success or error details otherwise |
| `delete-environment-variable` | `github.deleteEnvironmentVariable()` | `--environment-name` `--name` `--owner` `--repo` | 0 | Deletes a named environment variable from a specified, existing environment within a GitHub repository |
| `delete-file` | `github.deleteFile()` | `--message` `--owner` `--path` `--repo` | 6 | Deletes a file by path from a GitHub repository |
| `delete-gist` | `github.deleteGist()` | `--gist-id` | 0 | Permanently deletes an existing GitHub gist, specified by its `gist_id`; this action is destructive and cannot be undone |
| `delete-gist-comment` | `github.deleteGistComment()` | `--comment-id` `--gist-id` | 0 | Deletes a specific comment from a GitHub Gist using its `gist_id` and `comment_id` |
| `delete-issue-comment` | `github.deleteIssueComment()` | `--comment-id` `--owner` `--repo` | 0 | Permanently deletes a specific comment by its ID from an issue or pull request, if the repository exists and the comment ID is valid |
| `delete-issue-comment-reaction` | `github.deleteIssueCommentReaction()` | `--comment-id` `--owner` `--reaction-id` `--repo` | 0 | Deletes a reaction from an issue comment in a repository; the repository, comment, and reaction must exist |
| `delete-issue-reaction` | `github.deleteIssueReaction()` | `--issue-number` `--owner` `--reaction-id` `--repo` | 0 | Permanently removes a specific reaction from an issue in a GitHub repository |
| `delete-label` | `github.deleteLabel()` | `--name` `--owner` `--repo` | 0 | Permanently removes an existing label from a repository |
| `delete-milestone` | `github.deleteMilestone()` | `--milestone-number` `--owner` `--repo` | 0 | Deletes the specified milestone if it exists; this operation is idempotent, typically returning a 404 if the milestone is not found or already deleted |
| `delete-org-codespace` | `github.deleteOrgCodespace()` | `--codespace-name` `--org` `--username` | 0 | Permanently deletes a specific codespace belonging to a member of the specified organization |
| `delete-org-package` | `github.deleteOrgPackage()` | `--org` `--package-name` `--package-type` | 0 | Deletes a specific package in an organization; cannot delete public packages with over 5,000 downloads |
| `delete-organization` | `github.deleteOrganization()` | `--org` | 0 | Deletes a GitHub organization and its repositories; this is a destructive action and the organization name will be unavailable for reuse for approximately 90 days |
| `delete-organization-secret` | `github.deleteOrganizationSecret()` | `--org` `--secret-name` | 0 | Permanently deletes a secret from a GitHub organization, making it inaccessible to GitHub Actions workflows or other tools |
| `delete-organization-variable` | `github.deleteOrganizationVariable()` | `--name` `--org` | 0 | Deletes a named GitHub Actions variable from a specified organization |
| `delete-organization-webhook` | `github.deleteOrganizationWebhook()` | `--hook-id` `--org` | 0 | Deletes a specific webhook, identified by `hook_id`, from an existing organization |
| `delete-package` | `github.deletePackage()` | `--package-name` `--package-type` | 0 | Permanently deletes a specific package owned by the authenticated user; public packages downloaded over 5,000 times cannot be deleted via this API |
| `delete-package-version` | `github.deletePackageVersion()` | `--package-version-id` | 1 | Delete a package version using GitHub GraphQL API |
| `delete-package-version-for-authenticated-user` | `github.deletePackageVersionForAuthenticatedUser()` | `--package-name` `--package-type` `--package-version-id` | 0 | Deletes an existing package version associated with the authenticated user |
| `delete-package-version-for-organization` | `github.deletePackageVersionForOrganization()` | `--org` `--package-name` `--package-type` `--package-version-id` | 0 | Deletes a specific package version within an organization; requires admin permissions for packages with over 5,000 downloads |
| `delete-package-version-for-user` | `github.deletePackageVersionForUser()` | `--package-name` `--package-type` `--package-version-id` `--username` | 0 | Permanently and irreversibly deletes a specific version of a package owned by the specified user |
| `delete-pages-site` | `github.deletePagesSite()` | `--owner` `--repo` | 0 | Deletes the GitHub Pages site for the specified repository; completes without error if no site is currently enabled |
| `delete-pending-review` | `github.deletePendingReview()` | `--owner` `--pull-number` `--repo` `--review-id` | 0 | Deletes a pending (unsubmitted) review from a pull request; this is only possible if the review has not yet been submitted |
| `delete-project` | `github.deleteProject()` | `--project-id` | 0 | Deletes the specified GitHub project (Projects V2) using the GraphQL API |
| `delete-project-card` | `github.deleteProjectCard()` | `--card-id` | 0 | Deletes a project card from a GitHub 'Project (classic)'; this operation is idempotent |
| `delete-project-column` | `github.deleteProjectColumn()` | `--field-id` | 0 | Deletes a project field (column) from a GitHub Projects V2 project using the GraphQL API |
| `delete-project-item-for-user` | `github.deleteProjectItemForUser()` | `--item-id` `--project-number` `--username` | 0 | Delete a project item for a user in GitHub Projects V2 |
| `delete-pull-request-comment-reaction` | `github.deletePullRequestCommentReaction()` | `--comment-id` `--owner` `--reaction-id` `--repo` | 0 | Deletes a specific reaction from a pull request review comment, provided the comment and reaction exist on that comment within the specified repository |
| `delete-pull-request-review-protection` | `github.deletePullRequestReviewProtection()` | `--branch` `--owner` `--repo` | 0 | Disables the requirement for pull request reviews before merging for a specific, existing branch in an existing repository; this action is idempotent and will succeed even if the protection is not… |
| `delete-reference` | `github.deleteReference()` | `--owner` `--ref` `--repo` | 0 | Deletes a Git reference from a repository; 'ref' must be fully qualified (e.g., 'refs/heads/branch' or 'refs/tags/tag') |
| `delete-release` | `github.deleteRelease()` | `--owner` `--release-id` `--repo` | 0 | Permanently deletes a specific release, its assets, and potentially its associated Git tag from a repository |
| `delete-release-asset` | `github.deleteReleaseAsset()` | `--asset-id` `--owner` `--repo` | 0 | Deletes a specific release asset from a GitHub repository; this action is idempotent |
| `delete-release-reaction` | `github.deleteReleaseReaction()` | `--owner` `--reaction-id` `--release-id` `--repo` | 0 | Deletes a reaction from a GitHub release, provided the repository, release, and reaction exist |
| `delete-repo-codespace-secret-by-name` | `github.deleteRepoCodespaceSecretByName()` | `--owner` `--repo` `--secret-name` | 0 | Deletes a specific Codespace secret from a repository by its name; this action is idempotent and will succeed even if the secret doesn't exist |
| `delete-repository` ·common | `github.deleteRepository()` | `--owner` `--repo` | 0 | Permanently deletes the specified repository; this is a destructive, irreversible action that requires admin privileges for the repository |
| `delete-repository-invitation` | `github.deleteRepositoryInvitation()` | `--invitation-id` `--owner` `--repo` | 0 | Deletes an active repository invitation, permanently revoking a user's access to collaborate on the specified repository |
| `delete-repository-ruleset` | `github.deleteRepositoryRuleset()` | `--owner` `--repo` `--ruleset-id` | 0 | Permanently deletes a repository ruleset |
| `delete-repository-secret` | `github.deleteRepositorySecret()` | `--owner` `--repo` `--secret-name` | 0 | Deletes a named GitHub Actions secret from a specified repository; this operation is destructive and idempotent, and requires the repository to exist |
| `delete-repository-subscription` | `github.deleteRepositorySubscription()` | `--owner` `--repo` | 0 | Deletes the authenticated user's subscription to a specified repository if it exists, effectively 'unwatching' it |
| `delete-repository-variable` | `github.deleteRepositoryVariable()` | `--name` `--owner` `--repo` | 0 | Deletes a named variable (e.g., for GitHub Actions workflows) from a repository; the repository and the variable must already exist |
| `delete-repository-webhook` | `github.deleteRepositoryWebhook()` | `--hook-id` `--owner` `--repo` | 0 | Deletes a specific webhook from a repository |
| `delete-review-comment-for-pull-request` | `github.deleteReviewCommentForPullRequest()` | `--comment-id` `--owner` `--repo` | 0 | Deletes a specific pull request review comment |
| `delete-secret-for-authenticated-user` | `github.deleteSecretForAuthenticatedUser()` | `--secret-name` | 0 | Deletes an existing Codespaces secret for the authenticated user by `secret_name` |
| `delete-self-hosted-runner-from-organization` | `github.deleteSelfHostedRunnerFromOrganization()` | `--org` `--runner-id` | 0 | Forces the removal of a self-hosted runner from a GitHub organization |
| `delete-self-hosted-runner-from-repository` | `github.deleteSelfHostedRunnerFromRepository()` | `--owner` `--repo` `--runner-id` | 0 | Removes a specific self-hosted runner (by `runner_id`) from a repository, if registered there; this is idempotent |
| `delete-social-accounts-for-authenticated-user` | `github.deleteSocialAccountsForAuthenticatedUser()` | `--account-urls` | 0 | Deletes currently linked social media account URLs from the authenticated user's GitHub profile |
| `delete-tag-protection-state-for-repository` ·deprecated | `github.deleteTagProtectionStateForRepository()` | `--owner` `--repo` `--tag-protection-id` | 0 | This API was sunset on August 30, 2024 |
| `delete-team` | `github.deleteTeam()` | `--org` `--team-slug` | 0 | Deletes a team (and any child teams) from an organization |
| `delete-team-discussion-comment-reaction` | `github.deleteTeamDiscussionCommentReaction()` | `--comment-number` `--discussion-number` `--org` `--reaction-id` `--team-slug` | 0 | Deletes a reaction from a team discussion comment, given the organization name, team slug, discussion number, comment number, and reaction ID |
| `delete-team-discussion-reaction` | `github.deleteTeamDiscussionReaction()` | `--discussion-number` `--org` `--reaction-id` `--team-slug` | 0 | Permanently deletes a specific reaction from a team discussion within an organization |
| `delete-thread-subscription` | `github.deleteThreadSubscription()` | `--thread-id` | 0 | Call this to mute a specific notification thread by deleting the user's subscription; notifications may still occur if the user is @mentioned, comments, or due to repository watch settings |
| `delete-user-list` | `github.deleteUserList()` | `--listId` | 1 | Delete a GitHub user list using GraphQL |
| `delete-user-package` | `github.deleteUserPackage()` | `--package-name` `--package-type` `--username` | 0 | Deletes a package owned by the specified user, requiring admin permissions for the authenticated user; deletion of public packages with over 5,000 downloads may require GitHub support |
| `delete-workflow-run` | `github.deleteWorkflowRun()` | `--owner` `--repo` `--run-id` | 0 | Deletes a specific workflow run from a repository |
| `delete-workflow-run-logs` | `github.deleteWorkflowRunLogs()` | `--owner` `--repo` `--run-id` | 0 | Deletes all logs for a specific workflow run in a GitHub repository, provided the repository and run exist |
| `disable-custom-protection-rule-for-environment` | `github.disableCustomProtectionRuleForEnvironment()` | `--environment-name` `--owner` `--protection-rule-id` `--repo` | 0 | Disables a specific, currently active custom deployment protection rule for an existing environment within a GitHub repository |
| `disable-private-vuln-reporting-for-repo` | `github.disablePrivateVulnReportingForRepo()` | `--owner` `--repo` | 0 | Disables private vulnerability reporting for an existing GitHub repository, preventing direct private vulnerability reports to maintainers via GitHub's interface for this repository |
| `disable-repository-actions-in-org` | `github.disableRepositoryActionsInOrg()` | `--org` `--repository-id` | 0 | Removes a repository from the list of selected repositories enabled for GitHub Actions in an organization |
| `disable-workflow` | `github.disableWorkflow()` | `--owner` `--repo` `--workflow-id` | 0 | Disables a specified workflow (by ID or filename) in a given GitHub repository, preventing new automatic triggers; any in-progress runs will continue |
| `dismiss-review-for-pull-request` | `github.dismissReviewForPullRequest()` | `--message` `--owner` `--pull-number` `--repo` `--review-id` | 1 | Dismisses an APPROVED or CHANGES_REQUESTED review on a pull request with a mandatory explanatory message |
| `download-artifact` | `github.downloadArtifact()` | `--artifact-id` `--owner` `--repo` | 1 | Downloads a GitHub Actions workflow artifact as a ZIP file |
| `download-job-logs-for-workflow-run` | `github.downloadJobLogsForWorkflowRun()` | `--job-id` `--owner` `--repo` | 0 | Downloads logs for a specific job in a GitHub Actions workflow run, contingent on the repository's existence and the job ID being valid and having produced logs |
| `download-repository-archive-tar` | `github.downloadRepositoryArchiveTar()` | `--owner` `--ref` `--repo` | 0 | Downloads a repository's source code as a tarball (.tar.gz) archive for a specific Git reference, if the repository is accessible |
| `download-repository-archive-zip` | `github.downloadRepositoryArchiveZip()` | `--owner` `--ref` `--repo` | 0 | Downloads a repository's source code as a ZIP archive for a specific Git reference (branch, tag, or commit SHA) |
| `download-workflow-run-attempt-logs` | `github.downloadWorkflowRunAttemptLogs()` | `--attempt-number` `--owner` `--repo` `--run-id` | 0 | Downloads a ZIP archive of logs for a specific workflow run attempt |
| `download-workflow-run-logs` | `github.downloadWorkflowRunLogs()` | `--owner` `--repo` `--run-id` | 0 | Downloads logs for a specific GitHub Actions workflow run as a ZIP archive containing log files for each job in the workflow |
| `enable-actions-in-selected-repositories` | `github.enableActionsInSelectedRepositories()` | `--org` `--selected-repository-ids` | 0 | Sets the specific repositories that can use GitHub Actions within an organization by replacing the current list; only applies if the organization's Actions policy is 'selected repositories' |
| `enable-private-vuln-reporting-for-repo` | `github.enablePrivateVulnReportingForRepo()` | `--owner` `--repo` | 0 | Enables private vulnerability reporting for a repository, allowing security researchers to privately submit vulnerability reports to maintainers |
| `enable-repo-for-actions` | `github.enableRepoForActions()` | `--org` `--repository-id` | 0 | Adds a repository to the list of selected repositories enabled for GitHub Actions in an organization |
| `enable-workflow` | `github.enableWorkflow()` | `--owner` `--repo` `--workflow-id` | 0 | Reactivates a currently disabled GitHub Actions workflow within a repository using its workflow ID or filename |
| `encrypt-and-update-dev-secret` | `github.encryptAndUpdateDevSecret()` | `--owner` `--repo` `--secret-name` | 3 | Creates or updates a repository's development environment secret using an `encrypted_value` and its corresponding `key_id`; the secret must be pre-encrypted with the repository's Codespaces public key |
| `encrypt-org-dev-env-secret` | `github.encryptOrgDevEnvSecret()` | `--org` `--secret-name` `--visibility` | 4 | Creates or updates an organization's GitHub Codespaces secret using an encrypted value and its corresponding public key ID |
| `export-codespace-for-authenticated-user` | `github.exportCodespaceForAuthenticatedUser()` | `--codespace-name` | 0 | Triggers an export of a user's specified codespace, automatically stopping it if active, and returns its export status and download URL |
| `export-sbom-for-repo` | `github.exportSbomForRepo()` | `--owner` `--repo` | 0 | Exports the software bill of materials (SBOM) in SPDX JSON format for a repository, if its dependency graph is enabled and it has at least one commit |
| `find-pull-requests` ·common | `github.findPullRequests()` | — | 20 | Primary tool to find and search pull requests |
| `find-repositories` ·common | `github.findRepositories()` | `--query` | 14 | AI-optimized repository search with smart filtering by language, stars, topics, and ownership |
| `follow-organization-graphql` | `github.followOrganizationGraphql()` | `--organizationId` | 1 | Follow a GitHub organization using GraphQL |
| `follow-user` | `github.followUser()` | `--username` | 0 | Allows the authenticated user to follow the GitHub user specified by `username`; this action is idempotent and the user cannot follow themselves |
| `follow-user-graphql` | `github.followUserGraphql()` | `--userId` | 1 | Follow a GitHub user using GraphQL |
| `force-cancel-workflow-run` | `github.forceCancelWorkflowRun()` | `--owner` `--repo` `--run-id` | 0 | Forcefully cancels a queued or in-progress GitHub Actions workflow run, bypassing conditions like always() that would otherwise continue execution |
| `fork-gist` | `github.forkGist()` | `--gist-id` | 0 | Forks a specified public gist, creating a copy under the authenticated user's account |
| `generate-release-notes` | `github.generateReleaseNotes()` | `--owner` `--repo` `--tag-name` | 3 | Generates Markdown release notes content (listing changes, pull requests, and contributors) for a GitHub repository release, customizable via tags and a configuration file |
| `get-access-restrictions` | `github.getAccessRestrictions()` | `--branch` `--owner` `--repo` | 0 | Lists users, teams, and GitHub Apps with push access to a branch; this branch must be protected in repository settings for detailed restrictions, otherwise expect a 404 or empty response |
| `get-actions-cache-usage-for-organization` | `github.getActionsCacheUsageForOrganization()` | `--org` | 0 | Retrieves total GitHub Actions cache usage statistics for an organization, including active cache count and size across all repositories |
| `get-actions-cache-usage-for-repository` | `github.getActionsCacheUsageForRepository()` | `--owner` `--repo` | 0 | Retrieves the total count of active GitHub Actions caches and their combined size in bytes for a specified repository |
| `get-actions-permissions-for-organization` | `github.getActionsPermissionsForOrganization()` | `--org` | 0 | Gets the GitHub Actions permissions for a specified organization, detailing repository enablement and allowed actions policies |
| `get-actions-permissions-for-repository` | `github.getActionsPermissionsForRepository()` | `--owner` `--repo` | 0 | Gets the GitHub Actions permissions policy for a repository, including its enabled status and the scope of allowed actions |
| `get-admin-branch-protection` | `github.getAdminBranchProtection()` | `--branch` `--owner` `--repo` | 0 | Checks if repository administrators are subject to the branch protection rules on a specific branch |
| `get-all-api-versions` | `github.getAllApiVersions()` | — | 0 | Retrieves all officially supported, date-based (e.g., "2022-11-28") versions of the GitHub REST API from the /versions endpoint |
| `get-all-contributor-commit-activity` | `github.getAllContributorCommitActivity()` | `--owner` `--repo` | 0 | Retrieves commit activity (total commits, weekly additions/deletions/commits) for all contributors to a repository; may require a retry if GitHub returns 202 while preparing data |
| `get-all-deployment-protection-rules-for-env` | `github.getAllDeploymentProtectionRulesForEnv()` | `--environment-name` `--owner` `--repo` | 0 | Lists all enabled custom deployment protection rules for a specific environment in a repository; the environment must exist and be configured for deployments |
| `get-app` | `github.getApp()` | `--app-slug` | 0 | Retrieves publicly available information for an existing GitHub App, identified by its unique URL-friendly `app_slug` |
| `get-artifact` | `github.getArtifact()` | `--artifact-id` `--owner` `--repo` | 0 | Gets a specific artifact for a repository by `artifact_id` |
| `get-assignment` | `github.getAssignment()` | `--assignment-id` | 0 | Retrieves detailed information for a specific GitHub Classroom assignment if the authenticated user is an administrator of the classroom |
| `get-assignment-grades` | `github.getAssignmentGrades()` | `--assignment-id` | 0 | Retrieves all grades for an existing GitHub Classroom assignment |
| `get-authenticated-user` | `github.getAuthenticatedUser()` | — | 0 | Gets the profile information for the currently authenticated GitHub user, including potentially private details based on user settings |
| `get-autolink-reference-of-repository` | `github.getAutolinkReferenceOfRepository()` | `--autolink-id` `--owner` `--repo` | 0 | Retrieves a specific autolink reference (which automatically hyperlinks text like 'JIRA-123' to an external system) for a repository using its unique ID; requires administrator access to the… |
| `get-billing-premium-request-usage-report-user` | `github.getBillingPremiumRequestUsageReportUser()` | `--username` | 5 | Get billing premium request usage report for a GitHub user |
| `get-billing-usage-report-user` | `github.getBillingUsageReportUser()` | `--username` | 3 | Retrieves the billing usage report for a specified GitHub user |
| `get-billing-usage-summary-for-user` | `github.getBillingUsageSummaryForUser()` | `--username` | 6 | Retrieve billing usage summary for a GitHub user account |
| `get-blob` | `github.getBlob()` | `--file-sha` `--owner` `--repo` | 0 | Retrieves the raw, typically Base64-encoded, content of a file (blob) from a GitHub repository using its SHA hash, if the repository and blob SHA exist |
| `get-branch` | `github.getBranch()` | `--branch` `--owner` `--repo` | 0 | Retrieves detailed information for a specified branch within a GitHub repository |
| `get-branch-protection` | `github.getBranchProtection()` | `--branch` `--owner` `--repo` | 0 | Retrieves branch protection settings for a specific, existing, and accessible branch in a GitHub repository; protection feature availability varies by GitHub product plan |
| `get-catalog-models` | `github.getCatalogModels()` | — | 0 | Retrieve the list of AI models available in the GitHub Models catalog |
| `get-check-run` ·common | `github.getCheckRun()` | `--check-run-id` `--owner` `--repo` | 0 | Retrieves detailed information for a specific check run within a GitHub repository |
| `get-check-suite` | `github.getCheckSuite()` | `--check-suite-id` `--owner` `--repo` | 0 | Retrieves a specific check suite (a collection of check runs) by its ID from a repository accessible to the authenticated user |
| `get-classroom` | `github.getClassroom()` | `--classroom-id` | 0 | Retrieves details for a specific GitHub Classroom |
| `get-code-of-conduct` | `github.getCodeOfConduct()` | `--key` | 0 | Retrieves the full details of a specific GitHub code of conduct using its unique key |
| `get-code-of-conduct-graph-ql` | `github.getCodeOfConductGraphQl()` | `--key` | 0 | Look up a code of conduct by its key using GitHub's GraphQL API |
| `get-code-scanning-alert` | `github.getCodeScanningAlert()` | `--alert-number` `--owner` `--repo` | 0 | Retrieves a specific code scanning alert, which identifies potential code vulnerabilities or errors, by its number from the specified GitHub repository |
| `get-code-scanning-analysis` | `github.getCodeScanningAnalysis()` | `--analysis-id` `--owner` `--repo` | 0 | Retrieves detailed information for a specific code scanning analysis on an accessible repository, identified by its `analysis_id` |
| `get-code-scanning-default-setup` | `github.getCodeScanningDefaultSetup()` | `--owner` `--repo` | 0 | Gets the default setup configuration for code scanning in a repository, including state, languages, query suite, and schedule for a repository if it exists |
| `get-codeql-database` | `github.getCodeqlDatabase()` | `--language` `--owner` `--repo` | 0 | Gets an existing CodeQL database (including a download URL) for a specified language in an accessible repository, if one has been successfully built for that language |
| `get-codespace` | `github.getCodespace()` | `--codespace-name` | 0 | Call to retrieve detailed information for a `codespace_name` belonging to the authenticated user, ensuring the codespace exists and is accessible |
| `get-combined-status-for-specific-reference` | `github.getCombinedStatusForSpecificReference()` | `--owner` `--ref` `--repo` | 2 | Retrieves the aggregated commit status (e.g., success, failure, pending) from all checks for a specific reference (SHA, branch, or tag) in a GitHub repository |
| `get-commit` | `github.getCommit()` | `--owner` `--ref` `--repo` | 2 | Retrieves a specific commit from a repository by its owner, name, and a valid commit reference (SHA, branch, or tag), supporting pagination for large diffs |
| `get-commit-authors` | `github.getCommitAuthors()` | `--owner` `--repo` | 1 | Fetches commit authors identified during a repository import, used to map authors from an external VCS to GitHub accounts |
| `get-commit-comment` | `github.getCommitComment()` | `--comment-id` `--owner` `--repo` | 0 | Retrieves the full details of a specific commit comment in a GitHub repository, using its unique identifier |
| `get-commit-object` | `github.getCommitObject()` | `--commit-sha` `--owner` `--repo` | 0 | Retrieves detailed information (including author, committer, message, tree, parents, verification) for a specific commit in a GitHub repository, identified by its SHA |
| `get-commit-signature-protection` | `github.getCommitSignatureProtection()` | `--branch` `--owner` `--repo` | 0 | Gets the commit signature protection status for a branch in a repository |
| `get-commit-statuses` | `github.getCommitStatuses()` | `--owner` `--ref` `--repo` | 2 | List all statuses for a commit reference (SHA, branch, or tag) in reverse chronological order |
| `get-community-profile-metrics` | `github.getCommunityProfileMetrics()` | `--owner` `--repo` | 0 | Retrieves a repository's community profile metrics, including health percentage and the presence of key community files (e.g., README, LICENSE) |
| `get-contextual-information-for-user` | `github.getContextualInformationForUser()` | `--username` | 2 | Gets contextual hovercard information for a GitHub user; `subject_type` and `subject_id` can be jointly provided for more specific details |
| `get-custom-deployment-protection-rule` | `github.getCustomDeploymentProtectionRule()` | `--environment-name` `--owner` `--protection-rule-id` `--repo` | 0 | Retrieves a specific custom deployment protection rule (used by GitHub Apps for external validation or manual approval of deployments) for a given environment in a repository |
| `get-default-attributes-for-codespace` | `github.getDefaultAttributesForCodespace()` | `--owner` `--repo` | 2 | Get pre-flight data (e.g., default location, devcontainer path) for creating a Codespace in a given repository (must exist and be accessible), optionally for a specific Git ref |
| `get-default-workflow-permissions-for-organization` | `github.getDefaultWorkflowPermissionsForOrganization()` | `--org` | 0 | Gets the default GITHUB_TOKEN workflow permissions and settings for a GitHub organization |
| `get-default-workflow-permissions-for-repository` | `github.getDefaultWorkflowPermissionsForRepository()` | `--owner` `--repo` | 0 | Gets the default workflow permissions (`read` or `write`) for the GITHUB_TOKEN and whether it can approve pull request reviews in an existing and accessible repository |
| `get-dependency-diff` | `github.getDependencyDiff()` | `--basehead` `--owner` `--repo` | 1 | Gets the dependency diff between two Git revisions in a repository, where 'basehead' specifies the revisions and 'name' can optionally scope to a specific manifest file |
| `get-deploy-key` | `github.getDeployKey()` | `--key-id` `--owner` `--repo` | 0 | Gets a specific deploy key, identified by its `key_id`, for the GitHub repository specified by `owner` and `repo` |
| `get-deployment` | `github.getDeployment()` | `--deployment-id` `--owner` `--repo` | 0 | Gets a specific deployment by ID from a repository, provided the repository and deployment ID exist |
| `get-deployment-branch-policy` | `github.getDeploymentBranchPolicy()` | `--branch-policy-id` `--environment-name` `--owner` `--repo` | 0 | Retrieves a specific deployment branch policy for an environment in a repository, identified by its unique ID |
| `get-deployment-status` | `github.getDeploymentStatus()` | `--deployment-id` `--owner` `--repo` `--status-id` | 0 | Retrieves a specific deployment status by its ID for a given deployment within a GitHub repository |
| `get-details-about-codespace-export` | `github.getDetailsAboutCodespaceExport()` | `--codespace-name` `--export-id` | 0 | Retrieves detailed information about a specific export of a codespace |
| `get-discussion` | `github.getDiscussion()` | `--discussion-number` `--org` `--team-slug` | 0 | Fetches a specific discussion by its number from a team within an organization |
| `get-discussion-comment` | `github.getDiscussionComment()` | `--comment-number` `--discussion-number` `--org` `--team-slug` | 0 | Fetches a specific comment from a team discussion within a specific organization |
| `get-emojis` | `github.getEmojis()` | — | 0 | Lists all emojis available for use on GitHub, including custom and Unicode emojis |
| `get-enterprise-member-invitation` | `github.getEnterpriseMemberInvitation()` | `--enterprise-slug` `--user-login` | 0 | Look up a pending enterprise unaffiliated member invitation by invitee and enterprise |
| `get-environment` | `github.getEnvironment()` | `--environment-name` `--owner` `--repo` | 0 | Retrieves the details of a specific deployment environment for a given repository, including its name, configurations, and current status |
| `get-environment-public-key` | `github.getEnvironmentPublicKey()` | `--environment-name` `--owner` `--repo` | 0 | Retrieves the public key for a specified GitHub repository environment, used to encrypt secrets for GitHub Actions |
| `get-environment-secret` | `github.getEnvironmentSecret()` | `--environment-name` `--owner` `--repo` `--secret-name` | 0 | Retrieves metadata (name and timestamps) for a single secret in a GitHub Actions environment |
| `get-environment-variable` | `github.getEnvironmentVariable()` | `--environment-name` `--name` `--owner` `--repo` | 0 | Retrieves a specific environment variable from a GitHub Actions environment by repository owner, repository name, environment name, and variable name |
| `get-feeds` | `github.getFeeds()` | — | 0 | Fetches a list of available GitHub feed URLs for the authenticated user |
| `get-gist` | `github.getGist()` | `--gist-id` | 0 | Fetches a specific GitHub gist by its `gist_id`, returning comprehensive details if the gist exists |
| `get-gist-comment` | `github.getGistComment()` | `--comment-id` `--gist-id` | 0 | Retrieves a specific Gist comment by its ID and the Gist's ID |
| `get-gist-revision` | `github.getGistRevision()` | `--gist-id` `--sha` | 0 | Retrieves a specific revision of a gist |
| `get-gitignore-template` | `github.getGitignoreTemplate()` | `--name` | 0 | Retrieves a specific .gitignore template from GitHub by its name, which must be an existing template in GitHub's collection |
| `get-global-security-advisory` | `github.getGlobalSecurityAdvisory()` | `--ghsa-id` | 0 | Retrieve a global GitHub security advisory by its GHSA identifier |
| `get-graphql-node` | `github.getGraphqlNode()` | `--id` | 1 | Fetch any GitHub object by its global node ID |
| `get-graphql-rate-limit` | `github.getGraphqlRateLimit()` | — | 1 | Retrieve the authenticated client's GitHub GraphQL API rate limit information |
| `get-hourly-commit-count-for-each-day` | `github.getHourlyCommitCountForEachDay()` | `--owner` `--repo` | 0 | Retrieves the 'punch card' data, showing hourly commit counts for each day of the week for an existing and accessible repository |
| `get-information-about-sarif-upload` | `github.getInformationAboutSarifUpload()` | `--owner` `--repo` `--sarif-id` | 0 | Retrieves detailed information, including processing status and results URL, about a specific SARIF (Static Analysis Results Interchange Format) upload for a repository, uniquely identified by its… |
| `get-interaction-restrictions-for-organization` | `github.getInteractionRestrictionsForOrganization()` | `--org` | 0 | Retrieves interaction restrictions for an organization, showing which GitHub user types can interact with its public repositories and when restrictions expire; returns an empty response if no… |
| `get-interaction-restrictions-for-public-repos` | `github.getInteractionRestrictionsForPublicRepos()` | — | 0 | Retrieves currently active interaction restrictions for the authenticated user's public repositories |
| `get-interaction-restrictions-for-repository` | `github.getInteractionRestrictionsForRepository()` | `--owner` `--repo` | 0 | Retrieves active interaction restrictions for a repository, detailing which user groups are limited from activities like commenting or creating pull requests, and when these restrictions expire |
| `get-issue` | `github.getIssue()` | `--issue-number` `--owner` `--repo` | 0 | Retrieves detailed information about a specific issue in a repository using the owner, repository name, and issue number |
| `get-issue-comment` | `github.getIssueComment()` | `--comment-id` `--owner` `--repo` | 0 | Action to get an issue comment |
| `get-issue-comments` ·common | `github.getIssueComments()` | `--issue-number` `--owner` `--repo` | 3 | Retrieves all comments for a specific GitHub issue in chronological order |
| `get-issue-event` | `github.getIssueEvent()` | `--event-id` `--owner` `--repo` | 0 | Fetches details of a specific issue event for a given repository and event ID |
| `get-label` | `github.getLabel()` | `--name` `--owner` `--repo` | 0 | Retrieves a specific label by its name from a specified GitHub repository |
| `get-large-files` | `github.getLargeFiles()` | `--owner` `--repo` | 0 | Lists files larger than 100MB identified during a previous source import for the specified repository |
| `get-last-year-of-commit-activity` | `github.getLastYearOfCommitActivity()` | `--owner` `--repo` | 0 | Fetches weekly commit totals and daily commit counts for the last 52 weeks for a specified GitHub repository |
| `get-latest-pages-build` | `github.getLatestPagesBuild()` | `--owner` `--repo` | 0 | Retrieves information about the most recent GitHub Pages build for a repository, which must exist, be accessible, have GitHub Pages enabled, and have at least one prior build |
| `get-latest-release` | `github.getLatestRelease()` | `--owner` `--repo` | 0 | Fetches the latest official (non-prerelease, non-draft) release for a GitHub repository; requires at least one such published release |
| `get-license` | `github.getLicense()` | `--license` | 0 | Call this action to retrieve comprehensive details for a specific software license recognized by GitHub, using its unique license key |
| `get-license-for-repository` | `github.getLicenseForRepository()` | `--owner` `--repo` | 1 | Retrieves the license file and its details for a repository, optionally from a specific Git reference (branch, tag, or commit SHA) |
| `get-license-graph-ql` | `github.getLicenseGraphQl()` | `--key` | 0 | Look up an open source license by its SPDX ID using GitHub's GraphQL API |
| `get-meta-information` | `github.getMetaInformation()` | — | 0 | Fetches GitHub's publicly available metadata, useful for configuring network security policies or IP allow-listing |
| `get-milestone` | `github.getMilestone()` | `--milestone-number` `--owner` `--repo` | 0 | Retrieves detailed information for a specific milestone within a GitHub repository by its number |
| `get-octocat` | `github.getOctocat()` | — | 1 | Fetches an ASCII art representation of GitHub's Octocat, suitable for text-based displays |
| `get-oidc-subject-claim-template` | `github.getOidcSubjectClaimTemplate()` | `--owner` `--repo` | 0 | Retrieves the OpenID Connect (OIDC) subject claim customization template for a repository, which defines the `sub` claim structure in OIDC tokens for GitHub Actions workflows; returns the default… |
| `get-org-allowed-actions` | `github.getOrgAllowedActions()` | `--org` | 0 | Gets the list of allowed actions and reusable workflows for an organization when the 'allowed_actions' policy is set to 'selected' |
| `get-org-dev-environment-secret-safely` | `github.getOrgDevEnvironmentSecretSafely()` | `--org` `--secret-name` | 0 | Retrieves metadata for a specific secret available to an organization's GitHub Codespaces without exposing its encrypted value |
| `get-org-oidc-subject-claim-template` | `github.getOrgOidcSubjectClaimTemplate()` | `--org` | 0 | Retrieves the OpenID Connect (OIDC) subject claim customization template for a GitHub organization, which defines how the `sub` claim in OIDC tokens for workflows is constructed |
| `get-organization` | `github.getOrganization()` | `--org` | 0 | Get an organization |
| `get-organization-audit-log` | `github.getOrganizationAuditLog()` | `--org` | 6 | Retrieve an organization's audit log events for security and compliance investigations |
| `get-organization-custom-property` | `github.getOrganizationCustomProperty()` | `--custom-property-name` `--org` | 0 | Retrieves the definition (schema) of a specific, existing custom property for an organization |
| `get-organization-project-item` | `github.getOrganizationProjectItem()` | `--item-id` `--org` `--project-number` | 1 | Get an item from an organization-owned GitHub Projects V2 project |
| `get-organization-public-key` | `github.getOrganizationPublicKey()` | `--org` | 0 | Retrieves an organization's public key, which must be used to encrypt secret values before they are configured for Codespaces |
| `get-organization-public-key-for-dependabot` | `github.getOrganizationPublicKeyForDependabot()` | `--org` | 0 | Retrieves the public key for an existing GitHub organization, required for encrypting Dependabot secrets |
| `get-organization-role` | `github.getOrganizationRole()` | `--org` `--role-id` | 0 | Retrieves a specific GitHub organization role by its ID |
| `get-organization-secret` | `github.getOrganizationSecret()` | `--org` `--secret-name` | 0 | Gets an organization secret's metadata (e.g., name, creation/update dates, visibility), but not its encrypted value |
| `get-organization-teams` ·common | `github.getOrganizationTeams()` | `--org` | 3 | Retrieves a list of teams for a specified GitHub organization |
| `get-organization-variable` | `github.getOrganizationVariable()` | `--name` `--org` | 0 | Retrieves details (name, value, visibility, timestamps) of a specific, existing variable for an existing GitHub organization |
| `get-organization-webhook` | `github.getOrganizationWebhook()` | `--hook-id` `--org` | 0 | Retrieves the full configuration, including subscribed events and delivery settings, for an existing organization webhook |
| `get-package-for-authenticated-user` | `github.getPackageForAuthenticatedUser()` | `--package-name` `--package-type` | 0 | Retrieves detailed information for a specific package owned by the authenticated user |
| `get-package-for-organization` | `github.getPackageForOrganization()` | `--org` `--package-name` `--package-type` | 0 | Retrieves a specific package (by type and name) from an organization, if both the package and organization exist |
| `get-package-for-user` | `github.getPackageForUser()` | `--package-name` `--package-type` `--username` | 0 | Retrieves metadata for a specific package owned by a GitHub user, using package type, name, and username as identifiers |
| `get-package-version-for-authenticated-user` | `github.getPackageVersionForAuthenticatedUser()` | `--package-name` `--package-type` `--package-version-id` | 0 | Retrieves detailed information for an existing specific package version associated with the authenticated user, identified by its type, name, and version ID |
| `get-package-version-for-organization` | `github.getPackageVersionForOrganization()` | `--org` `--package-name` `--package-type` `--package-version-id` | 0 | Retrieves detailed information for a specific version of a package within an organization |
| `get-package-version-for-user` | `github.getPackageVersionForUser()` | `--package-name` `--package-type` `--package-version-id` `--username` | 0 | Retrieves a specific public package version associated with a GitHub user |
| `get-page-views` | `github.getPageViews()` | `--owner` `--repo` | 1 | Retrieves page view statistics for a repository over the last 14 days, including total views, unique visitors, and a daily or weekly breakdown |
| `get-pages-build` | `github.getPagesBuild()` | `--build-id` `--owner` `--repo` | 0 | Retrieves detailed information about a specific GitHub Pages build for a repository, which must have GitHub Pages enabled |
| `get-pages-dns-health-check` | `github.getPagesDnsHealthCheck()` | `--owner` `--repo` | 0 | Retrieves the DNS health check status (e.g., CNAME/A records, HTTPS) for a GitHub Pages site; the check may be pending (HTTP 202) on initial calls or after site changes |
| `get-pages-site` | `github.getPagesSite()` | `--owner` `--repo` | 0 | Retrieves information for a GitHub Pages site, which must be enabled for the repository |
| `get-pending-deployments-for-workflow-run` | `github.getPendingDeploymentsForWorkflowRun()` | `--owner` `--repo` `--run-id` | 0 | Retrieves pending deployment environments for a specific workflow run that are awaiting approval due to protection rules |
| `get-project` | `github.getProject()` | `--project-number` | 2 | Retrieves detailed information for a specific GitHub project (V2) using its project number and owner |
| `get-project-card` | `github.getProjectCard()` | `--card-id` | 0 | Retrieves all details of a specific project card, given its unique `card_id` |
| `get-project-column` | `github.getProjectColumn()` | `--column-id` | 0 | Retrieves detailed information for a specific project column from GitHub Projects (classic) |
| `get-project-permission-for-user` | `github.getProjectPermissionForUser()` | `--project-id` `--username` | 0 | Retrieves permission information for a GitHub project (classic) collaborator |
| `get-public-key-for-authenticated-user` | `github.getPublicKeyForAuthenticatedUser()` | — | 0 | Retrieves the authenticated user's public key for encrypting GitHub Codespaces secrets |
| `get-public-key-for-secret-encryption` | `github.getPublicKeyForSecretEncryption()` | `--owner` `--repo` | 0 | Retrieves a repository's public key for encrypting GitHub Codespaces secrets; requires `repo` scope or equivalent read access to codespaces secrets for private repositories |
| `get-pull-request` ·common | `github.getPullRequest()` | `--owner` `--pull-number` `--repo` | 0 | Retrieves a specific pull request from a GitHub repository using its owner, repository name, and pull request number |
| `get-pull-request-review-protection` | `github.getPullRequestReviewProtection()` | `--branch` `--owner` `--repo` | 0 | Retrieves the pull request review protection settings for a specific branch in a GitHub repository, if such protection is configured |
| `get-pull-requests` ·common | `github.getPullRequests()` | `--owner` `--repo` | 7 | Retrieves a list of pull requests from a repository with flexible filtering options |
| `get-rate-limit-status-for-authenticated-user` | `github.getRateLimitStatusForAuthenticatedUser()` | — | 0 | Retrieves the authenticated user's current GitHub API rate limit status, including usage and limits across different resource categories |
| `get-raw-repository-content` | `github.getRawRepositoryContent()` | `--owner` `--path` `--repo` | 1 | Fetch raw file content from a GitHub repository |
| `get-reference` ·common | `github.getReference()` | `--owner` `--ref` `--repo` | 0 | Retrieves a specific Git reference (e.g., a branch, tag, or fully qualified like 'heads/main') from a GitHub repository |
| `get-release` | `github.getRelease()` | `--owner` `--release-id` `--repo` | 0 | Gets a specific release from a GitHub repository, provided the repository is accessible and the release exists |
| `get-release-asset` | `github.getReleaseAsset()` | `--asset-id` `--owner` `--repo` | 0 | Gets metadata for a specific release asset in a GitHub repository, including a `browser_download_url` for downloading the asset |
| `get-release-by-tag-name` | `github.getReleaseByTagName()` | `--owner` `--repo` `--tag` | 0 | Gets a release from a GitHub repository by its tag name; the repository and a release with this tag must already exist |
| `get-repo-allowed-actions` | `github.getRepoAllowedActions()` | `--owner` `--repo` | 0 | Gets the settings for allowed actions and reusable workflows in a repository |
| `get-repo-dev-env-secret` | `github.getRepoDevEnvSecret()` | `--owner` `--repo` `--secret-name` | 0 | Gets metadata (name, creation/update timestamps) for a specific, existing development environment secret (Codespaces secret) in a repository, without exposing its value |
| `get-repos-attestations` | `github.getReposAttestations()` | `--owner` `--repo` `--subject-digest` | 4 | Retrieve attestations by subject digest from a GitHub repository |
| `get-repository` | `github.getRepository()` | `--owner` `--repo` | 0 | Retrieves detailed information about an existing and accessible GitHub repository |
| `get-repository-clones` | `github.getRepositoryClones()` | `--owner` `--repo` | 1 | Retrieves the total number of clones and a breakdown of clone activity (daily or weekly) for a specified repository over the preceding 14 days |
| `get-repository-content` ·common | `github.getRepositoryContent()` | `--owner` `--path` `--repo` | 1 | Retrieves a file's Base64 encoded content or lists a directory's contents from a GitHub repository |
| `get-repository-graph-ql` | `github.getRepositoryGraphQl()` | `--name` `--owner` | 1 | Lookup a repository by owner and name using GitHub's GraphQL API |
| `get-repository-owner` | `github.getRepositoryOwner()` | `--login` | 0 | Lookup a repository owner (User or Organization) by login using GitHub's GraphQL API |
| `get-repository-permissions-for-user` | `github.getRepositoryPermissionsForUser()` | `--owner` `--repo` `--username` | 0 | Retrieves a specific user's permission level ('admin', 'write', 'read', or 'none') for a given repository, where 'maintain' role is reported as 'write' and 'triage' as 'read' |
| `get-repository-public-key` | `github.getRepositoryPublicKey()` | `--owner` `--repo` | 0 | Gets a repository's public key for encrypting secrets to be used in GitHub Actions, if the repository exists and is accessible |
| `get-repository-public-key-for-encryption` | `github.getRepositoryPublicKeyForEncryption()` | `--owner` `--repo` | 0 | Gets a repository's public key, used to encrypt secrets for Dependabot |
| `get-repository-readme` | `github.getRepositoryReadme()` | `--owner` `--repo` | 1 | Fetches the README file (if it exists and is accessible) from a specified GitHub repository, returning its Base64-encoded content and metadata |
| `get-repository-readme-for-directory` | `github.getRepositoryReadmeForDirectory()` | `--dir` `--owner` `--repo` | 1 | Retrieves the README file from a specified directory within a GitHub repository, optionally at a given commit, branch, or tag |
| `get-repository-rule-suite` | `github.getRepositoryRuleSuite()` | `--owner` `--repo` `--rule-suite-id` | 0 | Gets detailed information for a specific repository rule suite by its ID, including its evaluation status and the results of its individual rules |
| `get-repository-ruleset` | `github.getRepositoryRuleset()` | `--owner` `--repo` `--ruleset-id` | 1 | Retrieves a specific repository ruleset by its ID; if `includes_parents` is true, the search for this `ruleset_id` also extends to rulesets from parent organizations |
| `get-repository-secret` | `github.getRepositorySecret()` | `--owner` `--repo` `--secret-name` | 0 | Gets metadata (name, creation/update timestamps) for an existing repository secret, excluding its encrypted value |
| `get-repository-secret-securely` | `github.getRepositorySecretSecurely()` | `--owner` `--repo` `--secret-name` | 0 | Retrieves metadata for an existing Dependabot secret in a repository, without exposing its encrypted value |
| `get-repository-security-advisory` | `github.getRepositorySecurityAdvisory()` | `--ghsa-id` `--owner` `--repo` | 0 | Retrieve a repository security advisory using its GHSA identifier |
| `get-repository-subscription` | `github.getRepositorySubscription()` | `--owner` `--repo` | 0 | Gets the authenticated user's subscription details for a repository, indicating if they receive notifications |
| `get-repository-variable` | `github.getRepositoryVariable()` | `--name` `--owner` `--repo` | 0 | Gets a specific GitHub Actions variable by name from an accessible repository |
| `get-repository-webhook` | `github.getRepositoryWebhook()` | `--hook-id` `--owner` `--repo` | 0 | Returns the configuration of an existing webhook for a given repository |
| `get-repository-webhook-delivery` | `github.getRepositoryWebhookDelivery()` | `--delivery-id` `--hook-id` `--owner` `--repo` | 0 | Retrieves a specific delivery for a repository webhook, identified by its `hook_id` and `delivery_id` |
| `get-review-comment-for-pull-request` | `github.getReviewCommentForPullRequest()` | `--comment-id` `--owner` `--repo` | 0 | Retrieves a specific pull request review comment by its ID, provided the repository exists, is accessible, and the comment ID is valid |
| `get-review-for-pull-request` | `github.getReviewForPullRequest()` | `--owner` `--pull-number` `--repo` `--review-id` | 0 | Retrieves a specific review for a pull request using its owner, repository, pull request number, and review ID |
| `get-review-history-for-workflow-run` | `github.getReviewHistoryForWorkflowRun()` | `--owner` `--repo` `--run-id` | 0 | Retrieves the detailed approval history for a specific workflow run in a GitHub repository, detailing each review's environment, state, reviewer, and comments, to track the approval process for… |
| `get-rules-for-branch` | `github.getRulesForBranch()` | `--branch` `--owner` `--repo` | 2 | Retrieves all active rules for a specific branch in a GitHub repository, excluding rules in 'evaluate' or 'disabled' status |
| `get-secret-for-authenticated-user` | `github.getSecretForAuthenticatedUser()` | `--secret-name` | 0 | Retrieves metadata (name, timestamps, visibility; not the value) for a specific, existing development environment secret associated with the authenticated user's GitHub Codespaces |
| `get-self-hosted-runner-for-organization` | `github.getSelfHostedRunnerForOrganization()` | `--org` `--runner-id` | 0 | Retrieves detailed information about a specific self-hosted runner registered within a GitHub organization |
| `get-self-hosted-runner-for-repository` | `github.getSelfHostedRunnerForRepository()` | `--owner` `--repo` `--runner-id` | 0 | Gets a specific self-hosted runner for a repository by its unique ID |
| `get-single-org-secret-without-decryption` | `github.getSingleOrgSecretWithoutDecryption()` | `--org` `--secret-name` | 0 | Gets a single organization Dependabot secret's metadata (name, timestamps, visibility) without revealing its encrypted value |
| `get-status-checks-protection` | `github.getStatusChecksProtection()` | `--branch` `--owner` `--repo` | 0 | Retrieves the status check protection settings for a specific branch in a GitHub repository, if status check protection is enabled for it |
| `get-status-of-pages-deployment` | `github.getStatusOfPagesDeployment()` | `--owner` `--pages-deployment-id` `--repo` | 0 | Retrieves the status of a specific GitHub Pages deployment for a repository, which must have GitHub Pages enabled |
| `get-tag` | `github.getTag()` | `--owner` `--repo` `--tag-sha` | 0 | Retrieves detailed information for a specific Git tag object from a GitHub repository, using the SHA of the tag object itself |
| `get-team-by-name` | `github.getTeamByName()` | `--org` `--team-slug` | 0 | Retrieves a GitHub team by its slug from a specific organization |
| `get-team-members` ·common | `github.getTeamMembers()` | `--org` `--team-slug` | 3 | Retrieves a list of members for a specific team within an organization |
| `get-team-membership-for-user` | `github.getTeamMembershipForUser()` | `--org` `--team-slug` `--username` | 0 | Retrieves a user's role and membership status within a specific team in an organization |
| `get-teams-with-access-to-protected-branch` | `github.getTeamsWithAccessToProtectedBranch()` | `--branch` `--owner` `--repo` | 0 | Lists teams with explicit push access to a protected branch, provided team restrictions are configured in the branch's protection settings; returns an empty list otherwise |
| `get-thread` | `github.getThread()` | `--thread-id` | 0 | Retrieves a specific GitHub notification thread using its unique `thread_id` |
| `get-thread-subscription-for-authenticated-user` | `github.getThreadSubscriptionForAuthenticatedUser()` | `--thread-id` | 0 | Retrieves the authenticated user's subscription details for a specific notification thread, identified by `thread_id` |
| `get-top-referral-paths` | `github.getTopReferralPaths()` | `--owner` `--repo` | 0 | Fetches the top 10 most viewed content paths for a repository from the last 14 days |
| `get-top-referral-sources` | `github.getTopReferralSources()` | `--owner` `--repo` | 0 | Fetches the top 10 websites that referred traffic to a repository within the last 14 days |
| `get-tree` ·common | `github.getTree()` | `--owner` `--repo` `--tree-sha` | 1 | Browse and list all files/directories in a GitHub repository |
| `get-user` | `github.getUser()` | `--username` | 0 | Retrieves the public profile information for an existing GitHub user, specified by their username |
| `get-user-by-id` | `github.getUserById()` | `--account-id` | 0 | Retrieves a GitHub user's profile information by their unique numeric account ID |
| `get-user-project-item` | `github.getUserProjectItem()` | `--item-id` `--project-number` `--username` | 1 | Get an item from a user-owned project in GitHub Projects V2 |
| `get-users-attestations` | `github.getUsersAttestations()` | `--subject-digest` `--username` | 4 | Get attestations by subject digest for a GitHub user |
| `get-users-projects-v2` | `github.getUsersProjectsV2()` | `--username` | 4 | List GitHub Projects v2 for a specified user |
| `get-users-with-access-to-protected-branch` | `github.getUsersWithAccessToProtectedBranch()` | `--branch` `--owner` `--repo` | 0 | Lists users with explicit push access to a protected branch, provided its protection rule restricts pushes to specific users |
| `get-viewer-graphql` | `github.getViewerGraphql()` | — | 0 | Retrieve the authenticated user's profile information via GitHub GraphQL |
| `get-webhook-configuration-for-organization` | `github.getWebhookConfigurationForOrganization()` | `--hook-id` `--org` | 0 | Retrieves the configuration for a specific webhook associated with a GitHub organization |
| `get-webhook-configuration-for-repository` | `github.getWebhookConfigurationForRepository()` | `--hook-id` `--owner` `--repo` | 0 | Returns the configuration for an existing webhook on the specified repository |
| `get-webhook-delivery-for-organization-webhook` | `github.getWebhookDeliveryForOrganizationWebhook()` | `--delivery-id` `--hook-id` `--org` | 0 | Returns detailed information for a specific delivery attempt of a webhook configured for the specified GitHub organization |
| `get-weekly-commit-activity` | `github.getWeeklyCommitActivity()` | `--owner` `--repo` | 0 | Fetches the weekly commit activity (additions and deletions per week) for a repository over the past year; best for repositories with under 10,000 commits |
| `get-weekly-commit-count` | `github.getWeeklyCommitCount()` | `--owner` `--repo` | 0 | Retrieves the weekly commit count for a repository, detailing commits by the owner and all contributors over the last 52 weeks; GitHub may return a 202 status or an empty response if statistics are… |
| `get-workflow` | `github.getWorkflow()` | `--owner` `--repo` | 2 | Retrieves detailed information for a specific GitHub Actions workflow in a repository, identified by either its numeric ID or its filename |
| `get-workflow-external-access` | `github.getWorkflowExternalAccess()` | `--owner` `--repo` | 0 | Gets the access level settings for a private repository, determining how workflows outside this repository can use its actions and reusable workflows |
| `get-workflow-run` | `github.getWorkflowRun()` | `--owner` `--repo` `--run-id` | 1 | Gets a specific workflow run by its ID from a GitHub repository |
| `get-workflow-run-attempt` | `github.getWorkflowRunAttempt()` | `--attempt-number` `--owner` `--repo` `--run-id` | 1 | Retrieves detailed information for a specific attempt of a workflow run in a GitHub repository, including its status, conclusion, and timings |
| `get-workflow-run-job` | `github.getWorkflowRunJob()` | `--job-id` `--owner` `--repo` | 0 | Retrieves detailed information for a specific job within a GitHub Actions workflow run, given its `job_id` which must be valid for the specified repository's workflow |
| `get-workflow-run-usage` | `github.getWorkflowRunUsage()` | `--owner` `--repo` `--run-id` | 0 | Gets the billable time, in milliseconds, for a specific workflow run, detailing time spent on various operating systems |
| `get-workflow-usage` | `github.getWorkflowUsage()` | `--owner` `--repo` `--workflow-id` | 0 | Gets the billable time (in milliseconds, broken down by runner OS) for a specific workflow within a repository for the current billing cycle |
| `get-zen-of-github` | `github.getZenOfGithub()` | — | 0 | Retrieves a random quote from GitHub's 'Zen of GitHub' collection, reflecting GitHub's design philosophies and offering humorous insights, useful for displaying GitHub wisdom or a lighthearted message |
| `is-repository-starred-by-user` | `github.isRepositoryStarredByUser()` | `--owner` `--repo` | 0 | Use to determine if the authenticated user has starred a specific GitHub repository, which is confirmed by an HTTP 204 status (resulting in an empty dictionary in the response data); the action fails… |
| `list-accepted-assignments-for-assignment` | `github.listAcceptedAssignmentsForAssignment()` | `--assignment-id` | 2 | Lists accepted assignments (student repositories created after acceptance) for an existing GitHub Classroom assignment, identified by its unique `assignment_id` |
| `list-accessible-repositories` | `github.listAccessibleRepositories()` | `--installation-id` | 2 | Lists repositories that the authenticated user can access through a specific GitHub App installation |
| `list-actions-caches-for-repository` | `github.listActionsCachesForRepository()` | `--owner` `--repo` | 6 | Lists GitHub Actions caches for a repository, with options to filter by Git reference or cache key, and to sort and paginate results |
| `list-app-installations` | `github.listAppInstallations()` | — | 2 | Lists GitHub App installations accessible to the authenticated user via their access token, including installation details, permissions, and repository access |
| `list-apps-with-access-to-protected-branch` | `github.listAppsWithAccessToProtectedBranch()` | `--branch` `--owner` `--repo` | 0 | Lists GitHub Apps with push access to a repository's protected branch |
| `list-artifacts-for-repository` | `github.listArtifactsForRepository()` | `--owner` `--repo` | 3 | Lists GitHub Actions workflow artifacts for a specified repository, which must exist |
| `list-assignees` | `github.listAssignees()` | `--owner` `--repo` | 2 | Lists users who can be assigned to issues in a repository, typically those with push access |
| `list-assignments-for-classroom` | `github.listAssignmentsForClassroom()` | `--classroom-id` | 2 | Lists all assignments for a given GitHub Classroom `classroom_id`; the classroom must exist and be accessible |
| `list-attestation-repositories` | `github.listAttestationRepositories()` | `--org` | 3 | List attestation repositories for an organization |
| `list-available-machine-types-for-repository` | `github.listAvailableMachineTypesForRepository()` | `--owner` `--repo` | 3 | Lists machine types available for GitHub Codespaces in a repository, optionally using a Git ref to check compatibility based on prebuild availability and devcontainer configurations |
| `list-branches` ·common | `github.listBranches()` | `--owner` `--repo` | 3 | List branches in a GitHub repository |
| `list-branches-for-head-commit` | `github.listBranchesForHeadCommit()` | `--commit-sha` `--owner` `--repo` | 0 | Lists branches in an accessible repository where the provided commit SHA is the head, useful for identifying development lines based on that commit |
| `list-check-run-annotations` | `github.listCheckRunAnnotations()` | `--check-run-id` `--owner` `--repo` | 2 | Lists annotations for a specific check run in a GitHub repository, detailing issues like errors or warnings on particular code lines |
| `list-check-runs-for-ref` ·common | `github.listCheckRunsForRef()` | `--owner` `--ref` `--repo` | 6 | List GitHub check runs for a commit SHA, branch, or tag to assess CI status and conclusions |
| `list-check-runs-in-check-suite` | `github.listCheckRunsInCheckSuite()` | `--check-suite-id` `--owner` `--repo` | 5 | Lists check runs for a specific check suite in a GitHub repository, optionally filtering by check name or status |
| `list-check-suites-for-git-reference` | `github.listCheckSuitesForGitReference()` | `--owner` `--ref` `--repo` | 4 | Lists check suites for a Git reference (commit SHA, branch, or tag) in a repository, optionally filtering by GitHub App ID or check run name |
| `list-child-teams` | `github.listChildTeams()` | `--org` `--team-slug` | 2 | Lists the immediate child teams of a parent team within an organization |
| `list-classrooms` | `github.listClassrooms()` | — | 2 | Lists GitHub Classrooms to which the authenticated user has administrative access |
| `list-code-scanning-alerts-for-organization` | `github.listCodeScanningAlertsForOrganization()` | `--org` | 10 | Lists code scanning alerts for a GitHub organization; use EITHER `tool_name` OR `tool_guid` if filtering by tool, not both |
| `list-code-scanning-alerts-for-repository` | `github.listCodeScanningAlertsForRepository()` | `--owner` `--repo` | 9 | Lists code scanning alerts for a repository, optionally filtering by tool (which must have produced scan results for the repository), Git reference, state, or severity |
| `list-code-scanning-analyses-for-repository` | `github.listCodeScanningAnalysesForRepository()` | `--owner` `--repo` | 8 | Lists code scanning analyses for an existing repository, optionally filtering by tool (name or GUID), Git reference, or SARIF ID |
| `list-codeowners-errors` | `github.listCodeownersErrors()` | `--owner` `--repo` | 1 | Lists syntax errors in a repository's CODEOWNERS file, which must be located at the root, `.github/`, or `docs/` directory for the specified ref |
| `list-codeql-databases-for-repository` | `github.listCodeqlDatabasesForRepository()` | `--owner` `--repo` | 0 | Lists all CodeQL databases for a repository where CodeQL analysis has been previously run and completed |
| `list-codes-of-conduct` | `github.listCodesOfConduct()` | — | 0 | Retrieves all available codes of conduct from GitHub, often used to select one for a repository |
| `list-codes-of-conduct-graphql` | `github.listCodesOfConductGraphql()` | — | 0 | Fetch all available codes of conduct using GitHub's GraphQL API |
| `list-codespaces-for-authenticated-user` | `github.listCodespacesForAuthenticatedUser()` | — | 3 | Lists GitHub Codespaces for the authenticated user, optionally filtering by repository ID and supporting pagination |
| `list-codespaces-for-organization` | `github.listCodespacesForOrganization()` | `--org` | 2 | Lists active/pending GitHub Codespaces for an existing organization; admins list all, members list their own |
| `list-codespaces-for-user-in-organization` | `github.listCodespacesForUserInOrganization()` | `--org` `--username` | 2 | Lists all GitHub Codespaces owned by a specified member of a given organization |
| `list-comment-changes` | `github.listCommentChanges()` | `--org` | 2 | List issue and PR comment changes across an organization's repositories efficiently |
| `list-comments-for-pull-request-review` | `github.listCommentsForPullRequestReview()` | `--owner` `--pull-number` `--repo` `--review-id` | 2 | Lists all comments for a specific review on a GitHub pull request |
| `list-commit-comments` | `github.listCommitComments()` | `--commit-sha` `--owner` `--repo` | 2 | Retrieves all comments for a specific commit in a GitHub repository, supporting pagination |
| `list-commit-comments-for-repository` | `github.listCommitCommentsForRepository()` | `--owner` `--repo` | 2 | Lists all commit comments for a specified repository, which must exist and be accessible |
| `list-commits` | `github.listCommits()` | `--owner` `--repo` | 8 | Lists commits for a GitHub repository |
| `list-commits-on-pull-request` | `github.listCommitsOnPullRequest()` | `--owner` `--pull-number` `--repo` | 2 | Lists commits for a pull request; requires the repository and pull request to exist and be accessible, and supports pagination |
| `list-commonly-used-licenses` | `github.listCommonlyUsedLicenses()` | — | 3 | Retrieves a list of commonly used software licenses from GitHub, optionally filtering for 'featured' licenses whose specific selection criteria by GitHub may vary |
| `list-custom-properties-for-organization` | `github.listCustomPropertiesForOrganization()` | `--org` | 0 | Gets the schema definitions for all custom properties configured for an organization, not the specific values assigned to repositories |
| `list-custom-property-values-for-org-repos` | `github.listCustomPropertyValuesForOrgRepos()` | `--org` | 3 | Lists repositories in an organization with their custom property values |
| `list-custom-property-values-for-repository` | `github.listCustomPropertyValuesForRepository()` | `--owner` `--repo` | 0 | Gets all custom property values for a repository |
| `list-deliveries-for-organization-webhook` | `github.listDeliveriesForOrganizationWebhook()` | `--hook-id` `--org` | 3 | Retrieves a list of webhook deliveries for a specific webhook in an organization, allowing inspection of delivery history and details |
| `list-deliveries-for-repository-webhook` | `github.listDeliveriesForRepositoryWebhook()` | `--hook-id` `--owner` `--repo` | 3 | Retrieves delivery attempts for a specific repository webhook to inspect its history; ensure the webhook ID exists |
| `list-deploy-keys` | `github.listDeployKeys()` | `--owner` `--repo` | 2 | Lists deploy SSH keys for a specified repository; the repository must exist |
| `list-deployment-branch-policies` | `github.listDeploymentBranchPolicies()` | `--environment-name` `--owner` `--repo` | 2 | Lists all deployment branch policies for a specified environment in a GitHub repository |
| `list-deployment-statuses` | `github.listDeploymentStatuses()` | `--deployment-id` `--owner` `--repo` | 2 | Lists all statuses for a given deployment in a repository |
| `list-deployments` ·common | `github.listDeployments()` | `--owner` `--repo` | 6 | Lists deployments for a specified repository; repository must exist |
| `list-discussion-comments` | `github.listDiscussionComments()` | `--discussion-number` `--org` `--team-slug` | 3 | Lists all comments for a specific team discussion within an organization |
| `list-discussions` | `github.listDiscussions()` | `--org` `--team-slug` | 4 | Lists discussions for a specific team within an organization, with options for sorting, pagination, and filtering by pinned status |
| `list-email-addresses-for-authenticated-user` | `github.listEmailAddressesForAuthenticatedUser()` | — | 2 | Lists all email addresses for the authenticated user, including their primary status, verification status, and visibility |
| `list-environment-custom-deployment-rules` | `github.listEnvironmentCustomDeploymentRules()` | `--environment-name` `--owner` `--repo` | 2 | Lists all custom deployment protection rule integrations for a repository environment; the `environment_name` must be URL-encoded |
| `list-environment-secrets` | `github.listEnvironmentSecrets()` | `--environment-name` `--owner` `--repo` | 2 | Lists the names and metadata (not values) of secrets for a specified, existing environment within an existing GitHub repository |
| `list-environment-variables` | `github.listEnvironmentVariables()` | `--environment-name` `--owner` `--repo` | 2 | Lists all environment variables, which are plaintext key-value pairs for GitHub Actions workflows, for a specified environment within a GitHub repository |
| `list-environments` | `github.listEnvironments()` | `--owner` `--repo` | 2 | Retrieves all deployment environments for a specified repository, which are used to configure protection rules and secrets for different software lifecycle stages |
| `list-events-for-authenticated-user` | `github.listEventsForAuthenticatedUser()` | `--username` | 2 | Lists public events for the specified GitHub user, or private events if authenticated as that user, in reverse chronological order |
| `list-events-for-user` ·common | `github.listEventsForUser()` | `--username` | 2 | Lists events performed by a GitHub user in reverse chronological order |
| `list-events-received-by-authenticated-user` | `github.listEventsReceivedByAuthenticatedUser()` | `--username` | 2 | Lists events a specific GitHub user received from followed users and watched repositories; returns private events if authenticated for `username`, otherwise public |
| `list-followers-of-authenticated-user` | `github.listFollowersOfAuthenticatedUser()` | — | 2 | Lists users following the authenticated GitHub user, returning an empty list if the user has no followers |
| `list-followers-of-user` ·common | `github.listFollowersOfUser()` | `--username` | 2 | Lists followers for a specified, existing GitHub user |
| `list-following-for-user` | `github.listFollowingForUser()` | `--username` | 2 | Lists the people that a GitHub user follows |
| `list-forks` | `github.listForks()` | `--owner` `--repo` | 3 | Lists forks for a specified repository, which must exist, with options for sorting and pagination |
| `list-gist-comments` | `github.listGistComments()` | `--gist-id` | 2 | Lists comments for a specified GitHub Gist |
| `list-gist-commits` | `github.listGistCommits()` | `--gist-id` | 2 | Lists all commits for a specified gist |
| `list-gist-forks` | `github.listGistForks()` | `--gist-id` | 2 | Lists all forks for a given GitHub gist ID |
| `list-gists-for-authenticated-user` | `github.listGistsForAuthenticatedUser()` | — | 3 | Lists gists for the authenticated user, with optional filtering by update time and pagination |
| `list-gists-for-user` | `github.listGistsForUser()` | `--username` | 3 | _lists public gists for a specified GitHub user._ |
| `list-gitignore-templates` | `github.listGitignoreTemplates()` | — | 0 | Retrieves all available .gitignore template names from GitHub (e.g., 'Python', 'Node', 'Java'), used for generating .gitignore files |
| `list-global-security-advisories` | `github.listGlobalSecurityAdvisories()` | — | 18 | Lists GitHub's global security advisories, filterable by various attributes including ID, type, ecosystem, severity, and dates |
| `list-gpg-keys-for-user` | `github.listGpgKeysForUser()` | `--username` | 2 | List GPG keys for a GitHub user |
| `list-installation-requests-for-authenticated-app` | `github.listInstallationRequestsForAuthenticatedApp()` | — | 2 | Lists pending installation requests made by users or organizations for the authenticated GitHub App |
| `list-instances-of-code-scanning-alert` | `github.listInstancesOfCodeScanningAlert()` | `--alert-number` `--owner` `--repo` | 3 | Lists all instances of a specific code scanning alert, optionally filtered by Git ref; requires code scanning to be enabled on the repository |
| `list-issue-comments` | `github.listIssueComments()` | `--issue-number` `--owner` `--repo` | 3 | Lists comments for a specified issue in a GitHub repository |
| `list-issue-comments-for-repository` | `github.listIssueCommentsForRepository()` | `--owner` `--repo` | 5 | Lists issue comments, including those on pull requests, for an accessible repository |
| `list-issue-dependencies-blocked-by` | `github.listIssueDependenciesBlockedBy()` | `--issue-number` `--owner` `--repo` | 2 | List dependencies an issue is blocked by |
| `list-issue-dependencies-blocking` | `github.listIssueDependenciesBlocking()` | `--issue-number` `--owner` `--repo` | 2 | List dependencies an issue is blocking |
| `list-issue-events` | `github.listIssueEvents()` | `--issue-number` `--owner` `--repo` | 2 | Retrieves a list of all events for a specific issue within a GitHub repository |
| `list-issue-events-for-repository` | `github.listIssueEventsForRepository()` | `--owner` `--repo` | 2 | Lists all issue events (e.g., closed, reopened, assigned) for a specified repository |
| `list-issue-types` | `github.listIssueTypes()` | `--org` | 0 | List all issue types configured for a GitHub organization |
| `list-issues-assigned-to-authenticated-user` | `github.listIssuesAssignedToAuthenticatedUser()` | — | 8 | Lists GitHub issues for the authenticated user across visible repositories, with filtering by user relationship, state, labels, an ISO 8601 `since` timestamp (YYYY-MM-DDTHH:MM:SSZ), and sorting… |
| `list-jobs-for-workflow-run` | `github.listJobsForWorkflowRun()` | `--owner` `--repo` `--run-id` | 3 | Lists jobs for a specific workflow run in a GitHub repository |
| `list-jobs-for-workflow-run-attempt` | `github.listJobsForWorkflowRunAttempt()` | `--attempt-number` `--owner` `--repo` `--run-id` | 2 | Lists jobs, including details like ID, status, and steps, for a specific attempt of a GitHub Actions workflow run |
| `list-labels-for-issue` | `github.listLabelsForIssue()` | `--issue-number` `--owner` `--repo` | 2 | Lists all labels for a specified issue in a GitHub repository |
| `list-labels-for-issues-in-milestone` | `github.listLabelsForIssuesInMilestone()` | `--milestone-number` `--owner` `--repo` | 2 | Lists all labels for issues within a specific milestone in a repository |
| `list-labels-for-repository` | `github.listLabelsForRepository()` | `--owner` `--repo` | 2 | Retrieves all labels for a specified, existing GitHub repository |
| `list-labels-for-self-hosted-runner-for-repository` | `github.listLabelsForSelfHostedRunnerForRepository()` | `--owner` `--repo` `--runner-id` | 0 | Lists all labels assigned to a specific self-hosted runner registered with the given repository |
| `list-labels-for-self-hosted-runner-org` | `github.listLabelsForSelfHostedRunnerOrg()` | `--org` `--runner-id` | 0 | Lists all labels assigned to a specific self-hosted runner within a GitHub organization, which are used to route workflows |
| `list-licenses-graph-ql` | `github.listLicensesGraphQl()` | — | 0 | Fetch all known open source licenses using GitHub's GraphQL API |
| `list-machine-types-for-codespace` | `github.listMachineTypesForCodespace()` | `--codespace-name` | 0 | Lists available machine types for a specific, accessible codespace, enabling it to be transitioned to a new hardware configuration |
| `list-matching-references` | `github.listMatchingReferences()` | `--owner` `--ref` `--repo` | 2 | Lists all Git references (branches or tags) in a repository that start with the provided partial reference path (e.g., `heads/my-feature` or `tags/v1.2`) |
| `list-milestones` | `github.listMilestones()` | `--owner` `--repo` | 5 | Lists milestones, which track progress for groups of issues and pull requests, for an existing repository, allowing filtering by state and sorting |
| `list-notifications` ·common | `github.listNotifications()` | — | 6 | List notification threads for the authenticated user with efficient polling support |
| `list-notifications-for-authenticated-user` ·deprecated | `github.listNotificationsForAuthenticatedUser()` | — | 6 | Use list-notifications instead |
| `list-org-fine-grained-permissions` | `github.listOrgFineGrainedPermissions()` | `--org` | 0 | Lists all fine-grained permissions available in a GitHub organization for use in custom organization roles |
| `list-org-issues-for-authenticated-user` | `github.listOrgIssuesForAuthenticatedUser()` | `--org` | 8 | Lists issues for the authenticated user within a specified GitHub organization, with options to filter by involvement type, state, labels, and to sort results |
| `list-org-package-versions` | `github.listOrgPackageVersions()` | `--org` `--package-name` `--package-type` | 3 | Lists all versions for a specified package, if it exists and is owned by the given GitHub organization |
| `list-org-project-view-items` | `github.listOrgProjectViewItems()` | `--org` `--project-number` `--view-number` | 4 | List items for an organization project view |
| `list-org-repos-with-actions-enabled` | `github.listOrgReposWithActionsEnabled()` | `--org` | 2 | Lists the selected repositories that are enabled for GitHub Actions in an organization |
| `list-org-resource-access-tokens` | `github.listOrgResourceAccessTokens()` | `--org` | 10 | Lists approved fine-grained personal access tokens (PATs) with access to resources in a GitHub organization, optionally filtering by owner, repository, permissions, or last usage time |
| `list-org-resources-with-personal-tokens` | `github.listOrgResourcesWithPersonalTokens()` | `--org` | 10 | Lists requests from organization members to access organization resources with fine-grained personal access tokens (pending, approved, or denied) |
| `list-org-secrets-without-values` | `github.listOrgSecretsWithoutValues()` | `--org` | 2 | Lists all Dependabot secrets (metadata like names, creation/update timestamps, but not their encrypted values) for a specified organization, which must exist |
| `list-organization-codespaces-secrets` | `github.listOrganizationCodespacesSecrets()` | `--org` | 2 | Lists all Codespaces secrets available for a specified organization, which must exist |
| `list-organization-events-for-authenticated-user` | `github.listOrganizationEventsForAuthenticatedUser()` | `--org` `--username` | 2 | Lists public events in a specified GitHub organization for the authenticated user's organization dashboard |
| `list-organization-members` ·common | `github.listOrganizationMembers()` | `--org` | 4 | List all members of a GitHub organization |
| `list-organization-memberships-for-authenticated-u` | `github.listOrganizationMembershipsForAuthenticatedU()` | — | 3 | List organization memberships for authenticated user |
| `list-organization-projects` | `github.listOrganizationProjects()` | `--org` | 4 | Lists projects (V2) for a specified GitHub organization, with optional search query and cursor-based pagination |
| `list-organization-repositories` | `github.listOrganizationRepositories()` | `--org` | 5 | Retrieves a list of repositories for a specified GitHub organization, allowing filtering by type and sorting |
| `list-organization-roles-for-organization` | `github.listOrganizationRolesForOrganization()` | `--org` | 0 | Lists all custom organization roles for an existing GitHub organization |
| `list-organization-secrets` | `github.listOrganizationSecrets()` | `--org` | 2 | Lists GitHub Actions secrets available for a specified organization |
| `list-organization-variables` | `github.listOrganizationVariables()` | `--org` | 2 | Lists all GitHub Actions variables for a specified organization |
| `list-organization-webhooks` | `github.listOrganizationWebhooks()` | `--org` | 2 | Lists all webhooks for a specified GitHub organization; the organization must exist |
| `list-organizations` | `github.listOrganizations()` | — | 2 | Lists GitHub organizations for the authenticated user, sorted by ID in ascending order |
| `list-organizations-for-authenticated-user` ·common | `github.listOrganizationsForAuthenticatedUser()` | — | 2 | Lists organizations the authenticated GitHub user is a member of, returning details for each organization |
| `list-organizations-for-user` ·common | `github.listOrganizationsForUser()` | `--username` | 2 | List public organization memberships for a GitHub user |
| `list-outside-collaborators-for-organization` | `github.listOutsideCollaboratorsForOrganization()` | `--org` | 3 | Lists outside collaborators for a GitHub organization, with options to filter (e.g., by 2FA status) and paginate results |
| `list-owned-package-versions` | `github.listOwnedPackageVersions()` | `--package-name` `--package-type` | 3 | Lists all versions for an existing package owned by the authenticated user, identified by its type and name |
| `list-package-versions-for-package-owned-by-user` | `github.listPackageVersionsForPackageOwnedByUser()` | `--package-name` `--package-type` `--username` | 2 | Lists all versions of a public package owned by a specific GitHub user, identified by package type, package name, and username |
| `list-packages-for-authenticated-user` | `github.listPackagesForAuthenticatedUser()` | `--package-type` | 3 | Lists packages of a specific type and visibility within the authenticated user's namespace on GitHub |
| `list-packages-for-organization` | `github.listPackagesForOrganization()` | `--org` `--package-type` | 3 | Lists GitHub Packages for an organization, noting specific interpretations for package_type and visibility parameters |
| `list-packages-for-user` | `github.listPackagesForUser()` | `--package-type` `--username` | 3 | Lists packages for a specified GitHub user, filterable by package type and visibility |
| `list-pages-builds` | `github.listPagesBuilds()` | `--owner` `--repo` | 2 | Lists GitHub Pages builds for a repository; GitHub Pages must be enabled on the repository for builds to be listed |
| `list-pending-team-invitations` | `github.listPendingTeamInvitations()` | `--org` `--team-slug` | 2 | Lists all pending membership invitations for a specified team within an organization |
| `list-people-authenticated-user-follows` | `github.listPeopleAuthenticatedUserFollows()` | — | 2 | Lists people the authenticated user follows |
| `list-people-user-follows` | `github.listPeopleUserFollows()` | `--username` | 2 | Lists GitHub users that a valid GitHub `username` is following, supporting pagination |
| `list-project-cards` | `github.listProjectCards()` | `--column-id` | 3 | Lists all project cards for a given column_id in GitHub Projects (classic) |
| `list-project-collaborators` | `github.listProjectCollaborators()` | `--project-id` | 3 | Lists collaborators for a GitHub Project (classic) by project ID |
| `list-project-columns` | `github.listProjectColumns()` | `--project-id` | 2 | Lists all of a GitHub project's columns (e.g., 'To Do', 'In Progress'); project_id must identify a valid, accessible project |
| `list-project-fields-for-user` | `github.listProjectFieldsForUser()` | `--project-number` `--username` | 3 | List all fields in a GitHub Projects V2 project for a specific user |
| `list-project-items-for-user` | `github.listProjectItemsForUser()` | `--project-number` `--username` | 5 | List items for a user-owned GitHub project |
| `list-project-view-items-for-user` | `github.listProjectViewItemsForUser()` | `--project-number` `--username` `--view-number` | 4 | List items for a user's GitHub Projects (v2) view |
| `list-public-emails-for-auth-user` | `github.listPublicEmailsForAuthUser()` | — | 2 | Lists the public email addresses for the authenticated user |
| `list-public-events` | `github.listPublicEvents()` | — | 2 | Lists public GitHub events, which may be delayed by up to 5 minutes, with support for pagination |
| `list-public-events-for-network-of-repositories` | `github.listPublicEventsForNetworkOfRepositories()` | `--owner` `--repo` | 2 | Retrieves public events (up to 90 days old, newest first) for a GitHub repository network, including the repository and its forks |
| `list-public-events-for-user` | `github.listPublicEventsForUser()` | `--username` | 2 | Retrieves a list of public events for a specified GitHub user, in reverse chronological order |
| `list-public-events-received-by-user` | `github.listPublicEventsReceivedByUser()` | `--username` | 2 | Lists public events for a specified GitHub user (e.g., activities in repositories they watch or are involved in); the target user's profile must be public, and if blocked by the authenticated user, a… |
| `list-public-gists` | `github.listPublicGists()` | — | 3 | Lists public gists from GitHub, optionally filtering by a 'since' timestamp and supporting pagination; results are generally newest first |
| `list-public-keys-for-user` | `github.listPublicKeysForUser()` | `--username` | 2 | Lists the verified public SSH keys for a specified GitHub user |
| `list-public-organization-events` | `github.listPublicOrganizationEvents()` | `--org` | 2 | Lists public events for a specified GitHub organization, which must exist |
| `list-public-organization-members` | `github.listPublicOrganizationMembers()` | `--org` | 2 | Lists users who have publicly declared their membership in a specified, existing GitHub organization |
| `list-public-repositories` | `github.listPublicRepositories()` | — | 1 | Lists all public repositories on GitHub; use the `since` parameter with a repository ID from a previous result for pagination |
| `list-pull-requests` ·common | `github.listPullRequests()` | `--owner` `--repo` | 7 | Lists pull requests for a GitHub repository |
| `list-pull-requests-associated-with-commit` | `github.listPullRequestsAssociatedWithCommit()` | `--commit-sha` `--owner` `--repo` | 2 | Lists pull requests for a commit; returns merged PRs that introduced the commit if on the default branch, or open PRs including the commit if on other branches |
| `list-pull-requests-files` ·common | `github.listPullRequestsFiles()` | `--owner` `--pull-number` `--repo` | 2 | Lists all files (including additions, modifications, and removals) associated with a specific pull request in a GitHub repository |
| `list-reactions-for-commit-comment` | `github.listReactionsForCommitComment()` | `--comment-id` `--owner` `--repo` | 3 | Lists reactions for a specific commit comment; this is a read-only operation |
| `list-reactions-for-issue` | `github.listReactionsForIssue()` | `--issue-number` `--owner` `--repo` | 3 | Lists reactions for a specific, existing issue within an accessible GitHub repository, optionally filtering by content type |
| `list-reactions-for-issue-comment` | `github.listReactionsForIssueComment()` | `--comment-id` `--owner` `--repo` | 3 | Lists reactions for a specific issue comment in a GitHub repository, optionally filtering by content type |
| `list-reactions-for-pull-request-review-comment` | `github.listReactionsForPullRequestReviewComment()` | `--comment-id` `--owner` `--repo` | 3 | Lists reactions for a pull request review comment in a repository, optionally filtering by reaction type |
| `list-reactions-for-release` | `github.listReactionsForRelease()` | `--owner` `--release-id` `--repo` | 3 | Lists all reactions, or optionally filters reactions by a specific content type, for a given GitHub release |
| `list-reactions-for-team-discussion` | `github.listReactionsForTeamDiscussion()` | `--discussion-number` `--org` `--team-slug` | 3 | Lists reactions for an existing team discussion within an organization |
| `list-reactions-for-team-discussion-comment` | `github.listReactionsForTeamDiscussionComment()` | `--comment-number` `--discussion-number` `--org` `--team-slug` | 3 | Lists reactions for a specific comment in a team discussion within an organization, optionally filtering by content type |
| `list-release-assets` | `github.listReleaseAssets()` | `--owner` `--release-id` `--repo` | 2 | Lists assets (e.g., compiled binaries, source code archives) for a specific GitHub release, identified by `release_id` which must be valid for an existing release in the repository |
| `list-releases` ·common | `github.listReleases()` | `--owner` `--repo` | 2 | Retrieves a list of all releases (published, draft, and prerelease) for a specified repository |
| `list-repo-access-by-token` | `github.listRepoAccessByToken()` | `--org` `--pat-request-id` | 2 | Lists repositories in an organization that a fine-grained personal access token has requested access to |
| `list-repo-codespaces` | `github.listRepoCodespaces()` | `--owner` `--repo` | 2 | Lists Codespaces the authenticated user can access within a specified, existing repository |
| `list-repo-dev-container-configs-for-user` | `github.listRepoDevContainerConfigsForUser()` | `--owner` `--repo` | 2 | Lists the `devcontainer.json` configurations available in a specified repository for use with GitHub Codespaces |
| `list-repo-invitations-for-auth-user` | `github.listRepoInvitationsForAuthUser()` | — | 2 | Lists all pending repository invitations for the authenticated user |
| `list-repo-notifications-for-auth-user` | `github.listRepoNotificationsForAuthUser()` | `--owner` `--repo` | 6 | Retrieves notifications for the authenticated user from a specified repository, to which the user must have access |
| `list-repo-secrets-without-values` | `github.listRepoSecretsWithoutValues()` | `--owner` `--repo` | 2 | Lists all Codespaces secrets available in a specific repository, without their encrypted values |
| `list-repositories` ·common | `github.listRepositories()` | — | 9 | Lists repositories accessible to the authenticated user based on visibility, affiliation, and type filters |
| `list-repositories-accessible-to-app-installation` | `github.listRepositoriesAccessibleToAppInstallation()` | — | 2 | Lists repositories a GitHub App installation can access |
| `list-repositories-for-authenticated-user` ·common | `github.listRepositoriesForAuthenticatedUser()` | — | 7 | Lists repositories for the authenticated user; using 'type' with 'visibility' or 'affiliation' API parameters (not in this model) can cause a 422 error |
| `list-repositories-for-user` | `github.listRepositoriesForUser()` | `--username` | 5 | Lists public repositories for a specified GitHub user, who must have an existing account |
| `list-repositories-starred-by-authenticated-user` ·common | `github.listRepositoriesStarredByAuthenticatedUser()` | — | 4 | Lists repositories the authenticated user has starred, optionally sorted and paginated, including star creation timestamps via 'application/vnd.github.star+json' media type |
| `list-repositories-starred-by-user` | `github.listRepositoriesStarredByUser()` | `--username` | 4 | Lists repositories a valid and existing GitHub user has starred |
| `list-repositories-watched-by-authenticated-user` | `github.listRepositoriesWatchedByAuthenticatedUser()` | — | 2 | Lists repositories the authenticated user is watching (subscribed to for notifications) |
| `list-repositories-watched-by-user` | `github.listRepositoriesWatchedByUser()` | `--username` | 2 | Lists repositories a given GitHub user is watching; the username must be a valid and existing GitHub user handle |
| `list-repositories-with-actions-cache-usage` | `github.listRepositoriesWithActionsCacheUsage()` | `--org` | 2 | Retrieves a paginated list of GitHub Actions cache usage statistics for repositories within an existing GitHub organization |
| `list-repository-activities` | `github.listRepositoryActivities()` | `--owner` `--repo` | 8 | Lists activities for a GitHub repository, ensuring the repository exists and is accessible |
| `list-repository-autolinks` | `github.listRepositoryAutolinks()` | `--owner` `--repo` | 0 | Retrieves all autolinks (e.g., for JIRA issues) configured for a repository; requires admin permissions on the repository |
| `list-repository-collaborators` | `github.listRepositoryCollaborators()` | `--owner` `--repo` | 4 | Lists collaborators for a specified repository, provided it exists and is accessible to the authenticated user |
| `list-repository-contributors` ·common | `github.listRepositoryContributors()` | `--owner` `--repo` | 3 | Lists contributors to a specified repository, sorted by number of contributions in descending order; the repository must exist and be accessible |
| `list-repository-events` | `github.listRepositoryEvents()` | `--owner` `--repo` | 2 | Lists chronological events (e.g., code pushes, issue activities, PR actions, forks) for a specified, existing GitHub repository |
| `list-repository-invitations` | `github.listRepositoryInvitations()` | `--owner` `--repo` | 2 | Retrieves all pending (unaccepted or undeclined) collaboration invitations for a specified GitHub repository |
| `list-repository-issues` ·common | `github.listRepositoryIssues()` | `--owner` `--repo` | 12 | Lists issues (including pull requests) from a GitHub repository |
| `list-repository-languages` | `github.listRepositoryLanguages()` | `--owner` `--repo` | 0 | Lists the programming languages used in a GitHub repository, returning a byte count for each language |
| `list-repository-organization-secrets` | `github.listRepositoryOrganizationSecrets()` | `--owner` `--repo` | 2 | Lists names of organization-level secrets shared with the specified repository; actual secret values are not returned and visibility depends on token access |
| `list-repository-organization-variables` | `github.listRepositoryOrganizationVariables()` | `--owner` `--repo` | 2 | Lists organization-level variables that are shared with a specific repository |
| `list-repository-projects` | `github.listRepositoryProjects()` | `--owner` `--repo` | 3 | Lists Projects (classic) associated with a specific repository |
| `list-repository-rule-suites` | `github.listRepositoryRuleSuites()` | `--owner` `--repo` | 6 | Lists rule suite evaluations for a repository, allowing filtering by ref (non-wildcard), time period, actor, and result |
| `list-repository-rulesets` | `github.listRepositoryRulesets()` | `--owner` `--repo` | 3 | Retrieves all rulesets for a GitHub repository, which define conditions and actions for repository interactions (e.g., branch protections) |
| `list-repository-secrets` | `github.listRepositorySecrets()` | `--owner` `--repo` | 2 | Lists metadata for all secrets in a GitHub repository, excluding their encrypted values |
| `list-repository-secrets-without-decrypting` | `github.listRepositorySecretsWithoutDecrypting()` | `--owner` `--repo` | 2 | Lists metadata (e.g., name, creation/update dates) for all Dependabot secrets in a repository; secret values are not included |
| `list-repository-security-advisories` | `github.listRepositorySecurityAdvisories()` | `--owner` `--repo` | 6 | List security advisories for a repository |
| `list-repository-tags` | `github.listRepositoryTags()` | `--owner` `--repo` | 2 | Lists tags for a specified GitHub repository |
| `list-repository-teams` | `github.listRepositoryTeams()` | `--owner` `--repo` | 2 | Lists all teams with explicit permission to access the specified repository; the repository must exist |
| `list-repository-topics` | `github.listRepositoryTopics()` | `--owner` `--repo` | 2 | Retrieves all topics for a specified, existing, and accessible repository |
| `list-repository-variables` | `github.listRepositoryVariables()` | `--owner` `--repo` | 2 | Lists plain text key-value variables for GitHub Actions workflows within a specific, accessible repository |
| `list-repository-webhooks` | `github.listRepositoryWebhooks()` | `--owner` `--repo` | 2 | Retrieves a list of webhooks for a repository, which must exist and be accessible |
| `list-repository-workflows` ·common | `github.listRepositoryWorkflows()` | `--owner` `--repo` | 2 | Lists all GitHub Actions workflows for a specified repository, which must exist and be accessible |
| `list-requested-reviewers-for-pull-request` | `github.listRequestedReviewersForPullRequest()` | `--owner` `--pull-number` `--repo` | 0 | Gets all users and teams requested to review a specific pull request in a repository |
| `list-review-comments-in-repository` | `github.listReviewCommentsInRepository()` | `--owner` `--repo` | 5 | Lists all review comments on all pull requests within a specified repository |
| `list-review-comments-on-pull-request` | `github.listReviewCommentsOnPullRequest()` | `--owner` `--pull-number` `--repo` | 5 | Lists all review comments on a specific pull request within a GitHub repository |
| `list-reviews-for-pull-request` | `github.listReviewsForPullRequest()` | `--owner` `--pull-number` `--repo` | 2 | Lists submitted reviews chronologically for a specific pull request within a GitHub repository |
| `list-runner-applications-for-organization` | `github.listRunnerApplicationsForOrganization()` | `--org` | 0 | Lists downloadable GitHub Actions runner application binaries for setting up self-hosted runners in a GitHub organization |
| `list-runner-applications-for-repository` | `github.listRunnerApplicationsForRepository()` | `--owner` `--repo` | 0 | Lists available self-hosted runner application binaries for a specific repository, including their OS, architecture, and download URL |
| `list-secret-scanning-alerts-for-repository` ·common | `github.listSecretScanningAlertsForRepository()` | `--owner` `--repo` | 14 | List secret scanning alerts for a GitHub repository using first-party detections |
| `list-secrets-for-authenticated-user` | `github.listSecretsForAuthenticatedUser()` | — | 2 | Lists all Codespaces secrets accessible to the authenticated user for use within GitHub Codespaces |
| `list-security-advisories-graphql` | `github.listSecurityAdvisoriesGraphql()` | — | 11 | List GitHub Security Advisories using the GraphQL API |
| `list-security-vulnerabilities` | `github.listSecurityVulnerabilities()` | — | 10 | Query software vulnerabilities documented by GitHub Security Advisories using GraphQL |
| `list-selected-repos-org-variable` | `github.listSelectedReposOrgVariable()` | `--name` `--org` | 2 | Lists repositories in an organization that can access a specific organization variable; supports pagination and returns an empty list if no repositories have been granted access |
| `list-selected-repositories-for-organization-secret` | `github.listSelectedRepositoriesForOrganizationSecret()` | `--org` `--secret-name` | 2 | Lists repositories that have been granted access to a Codespaces organization secret |
| `list-selected-repositories-for-secret-access` | `github.listSelectedRepositoriesForSecretAccess()` | `--org` `--secret-name` | 2 | Lists repositories within a specified organization that have been granted access to a particular Dependabot secret |
| `list-selected-repositories-for-user-secret` | `github.listSelectedRepositoriesForUserSecret()` | `--secret-name` | 2 | Lists repositories that have access to the specified user Codespaces secret |
| `list-self-hosted-runners-for-organization` | `github.listSelfHostedRunnersForOrganization()` | `--org` | 3 | Lists self-hosted runners for a GitHub organization, optionally filtering by name and paginating results, providing details for each runner such as OS, status, and labels |
| `list-self-hosted-runners-for-repository` | `github.listSelfHostedRunnersForRepository()` | `--owner` `--repo` | 3 | Lists all self-hosted runners configured for a repository |
| `list-social-accounts-for-authenticated-user` | `github.listSocialAccountsForAuthenticatedUser()` | — | 2 | Lists all social media accounts linked to the authenticated user's GitHub profile |
| `list-social-accounts-for-user` | `github.listSocialAccountsForUser()` | `--username` | 2 | Lists social media accounts publicly linked to an existing GitHub user's profile |
| `list-sponsorables` | `github.listSponsorables()` | — | 9 | List users and organizations who can be sponsored via GitHub Sponsors |
| `list-ssh-signing-keys-for-user` | `github.listSshSigningKeysForUser()` | `--username` | 2 | Lists the public SSH signing keys for a specified GitHub user |
| `list-stargazers` ·common | `github.listStargazers()` | `--owner` `--repo` | 2 | Lists users who have starred the specified GitHub repository, which must exist |
| `list-starred-gists` | `github.listStarredGists()` | — | 3 | Retrieves a list of gists starred by the authenticated user |
| `list-starred-repositories-for-user` ·common | `github.listStarredRepositoriesForUser()` | `--username` | 4 | Lists public repositories that a user has starred |
| `list-status-check-contexts` | `github.listStatusCheckContexts()` | `--branch` `--owner` `--repo` | 0 | Fetches all required status check contexts for a protected branch; returns an empty list if the branch isn't protected or has no required checks |
| `list-sub-issues` | `github.listSubIssues()` | `--issue-number` `--owner` `--repo` | 2 | List sub-issues for a specific GitHub issue |
| `list-subscriptions-for-authenticated-user` | `github.listSubscriptionsForAuthenticatedUser()` | — | 2 | List GitHub Marketplace subscriptions for the authenticated user |
| `list-subscriptions-for-authenticated-user-stubbed` | `github.listSubscriptionsForAuthenticatedUserStubbed()` | — | 2 | Lists the authenticated user's stubbed (test/example data, not live) GitHub Marketplace subscriptions, useful for development or testing |
| `list-tag-protection-states-for-repository` ·deprecated | `github.listTagProtectionStatesForRepository()` | `--owner` `--repo` | 0 | Lists tag protection rules for a repository |
| `list-team-members` | `github.listTeamMembers()` | `--org` `--team-slug` | 3 | Lists members of a specific team within an organization, including members of child teams |
| `list-team-projects` | `github.listTeamProjects()` | `--org` `--team-slug` | 2 | Lists GitHub projects accessible to a specific team within an organization |
| `list-team-repositories` | `github.listTeamRepositories()` | `--org` `--team-slug` | 2 | Lists repositories accessible to a specific team within a GitHub organization |
| `list-teams` | `github.listTeams()` | `--org` | 2 | Lists teams for a specified GitHub organization |
| `list-teams-for-authenticated-user` | `github.listTeamsForAuthenticatedUser()` | — | 2 | Lists all teams across all organizations to which the authenticated user belongs, supporting pagination |
| `list-teams-that-are-assigned-to-organization-role` | `github.listTeamsThatAreAssignedToOrganizationRole()` | `--org` `--role-id` | 2 | Lists teams assigned to a specific role within a GitHub organization |
| `list-timeline-events-for-issue` | `github.listTimelineEventsForIssue()` | `--issue-number` `--owner` `--repo` | 2 | Lists chronological events (e.g., comments, commits, label changes) for a specific issue in a GitHub repository |
| `list-token-access-repositories` | `github.listTokenAccessRepositories()` | `--org` `--pat-id` | 2 | Lists repositories in an organization that a fine-grained personal access token has access to |
| `list-user-projects` | `github.listUserProjects()` | `--username` | 3 | Retrieves a list of projects for a specified GitHub user, optionally filtering by state and supporting pagination; the username must be a valid GitHub handle |
| `list-users` | `github.listUsers()` | — | 2 | Retrieves all GitHub users (individuals and organizations) in chronological order of their sign-up date |
| `list-users-blocked-by-authenticated-user` | `github.listUsersBlockedByAuthenticatedUser()` | — | 2 | Lists users blocked by the authenticated user, returning an empty list if no users are blocked |
| `list-users-blocked-by-organization` | `github.listUsersBlockedByOrganization()` | `--org` | 2 | Lists users blocked by a specified GitHub organization |
| `list-users-that-are-assigned-to-organization-role` | `github.listUsersThatAreAssignedToOrganizationRole()` | `--org` `--role-id` | 2 | Lists users assigned to a specific role within a GitHub organization |
| `list-watchers` | `github.listWatchers()` | `--owner` `--repo` | 2 | Retrieves a list of users watching a specific repository; the repository must be accessible to the authenticated user |
| `list-workflow-run-artifacts` | `github.listWorkflowRunArtifacts()` | `--owner` `--repo` `--run-id` | 3 | Lists artifacts (e.g., build outputs, test results) for a specific workflow run in a GitHub repository |
| `list-workflow-runs-for-repository` | `github.listWorkflowRunsForRepository()` | `--owner` `--repo` | 10 | Lists workflow runs for a repository, allowing filtering by actor, branch, event, status, creation date, check suite ID, or head SHA; the repository must exist and be accessible |
| `list-workflow-runs-for-workflow` | `github.listWorkflowRunsForWorkflow()` | `--owner` `--repo` `--workflow-id` | 10 | Lists runs for a specified, existing workflow (identified by ID or filename like `main.yml`) in a GitHub repository, with filtering options |
| `lock-issue` | `github.lockIssue()` | `--issue-number` `--owner` `--repo` | 1 | Locks an existing GitHub issue's conversation, preventing further comments; an optional reason can be specified |
| `lookup-enterprise-administrator-invitation` | `github.lookupEnterpriseAdministratorInvitation()` | `--enterprise-slug` `--role` `--user-login` | 0 | Look up a pending enterprise administrator invitation by invitee, enterprise, and role |
| `lookup-nodes-by-ids` | `github.lookupNodesByIds()` | `--ids` | 0 | Lookup GitHub nodes by their global node IDs |
| `lookup-organization-graph-ql` | `github.lookupOrganizationGraphQl()` | `--login` | 0 | Lookup a GitHub organization by login using GraphQL |
| `lookup-resource` | `github.lookupResource()` | `--url` | 0 | Lookup a GitHub resource by its URL |
| `lookup-topic-by-name` | `github.lookupTopicByName()` | `--name` | 2 | Look up a GitHub topic by name using GraphQL |
| `manage-access-control-for-organization-codespaces` | `github.manageAccessControlForOrganizationCodespaces()` | `--org` `--visibility` | 1 | Sets the Codespaces access control policy for a GitHub organization, determining which members can use them |
| `manage-custom-properties-for-org-repos` | `github.manageCustomPropertiesForOrgRepos()` | `--org` `--properties` `--repository-names` | 0 | Creates or updates values for an organization's predefined custom properties across multiple repositories (up to 30) |
| `manage-secrets-in-selected-repositories` | `github.manageSecretsInSelectedRepositories()` | `--org` `--secret-name` | 2 | Lists repositories within an organization that have been explicitly granted access to a specific GitHub Actions organization secret |
| `map-commit-author` | `github.mapCommitAuthor()` | `--author-id` `--owner` `--repo` | 2 | Updates Git author information (name and/or email) for an `author_id` obtained during a repository import, to correctly attribute commits |
| `mark-notifications-as-read` | `github.markNotificationsAsRead()` | — | 2 | Marks notifications as read or unread, optionally for those updated at or before a `last_read_at` timestamp |
| `mark-pull-request-ready-for-review` ·common | `github.markPullRequestReadyForReview()` | `--pull-request-id` | 1 | Marks a draft pull request as ready for review using GitHub GraphQL API, transitioning it from draft to reviewable state |
| `mark-repository-notifications-as-read` | `github.markRepositoryNotificationsAsRead()` | `--owner` `--repo` | 1 | Marks notifications in a repository as read; if 'last_read_at' is specified, notifications updated after this timestamp are not marked as read |
| `mark-thread-as-done` | `github.markThreadAsDone()` | `--thread-id` | 0 | Marks the GitHub notification thread (identified by `thread_id`) as done or read for the authenticated user, effectively archiving it |
| `mark-thread-as-read` | `github.markThreadAsRead()` | `--thread-id` | 0 | Marks an existing GitHub notification thread, identified by its `thread_id`, as read |
| `merge-branch` | `github.mergeBranch()` | `--base` `--head` `--owner` `--repo` | 1 | Merges a head branch or commit SHA into a base branch in a repository; fails if there are merge conflicts requiring manual resolution |
| `merge-pull-request` | `github.mergePullRequest()` | `--owner` `--pull-number` `--repo` | 4 | Merges an open and mergeable pull request in a repository |
| `move-project-card` | `github.moveProjectCard()` | `--card-id` `--position` | 1 | Moves a project card to a specified position within a column (GitHub Classic Projects) |
| `move-project-column` | `github.moveProjectColumn()` | `--column-id` `--position` | 0 | Moves a column within a GitHub project (classic) to a new position |
| `ping-organization-webhook` | `github.pingOrganizationWebhook()` | `--hook-id` `--org` | 0 | Sends a 'ping' event to a specified, existing organization webhook to test its configuration and ensure it correctly receives events |
| `ping-repository-webhook` | `github.pingRepositoryWebhook()` | `--hook-id` `--owner` `--repo` | 0 | Pings an existing webhook on a repository to test its configuration and reachability by GitHub |
| `privately-report-security-vulnerability` | `github.privatelyReportSecurityVulnerability()` | `--description` `--owner` `--repo` `--summary` | 5 | Privately reports a security vulnerability to a repository's maintainers |
| `publish-sponsors-tier-graph-ql` | `github.publishSponsorsTierGraphQl()` | `--tierId` | 1 | Publish a draft GitHub Sponsors tier using GraphQL |
| `re-run-failed-jobs-from-workflow-run` | `github.reRunFailedJobsFromWorkflowRun()` | `--owner` `--repo` `--run-id` | 1 | Re-runs all failed jobs and their dependent jobs from a specified workflow run if the run contains previously failed jobs |
| `re-run-job-from-workflow-run` | `github.reRunJobFromWorkflowRun()` | `--job-id` `--owner` `--repo` | 1 | Re-runs a specific job and any dependent jobs from a GitHub Actions workflow run in the specified repository, optionally enabling debug logging |
| `re-run-workflow` | `github.reRunWorkflow()` | `--owner` `--repo` `--run-id` | 1 | Re-runs a specific GitHub Actions workflow run identified by its owner, repository, and run ID, optionally enabling debug logging |
| `redeliver-delivery-for-organization-webhook` | `github.redeliverDeliveryForOrganizationWebhook()` | `--delivery-id` `--hook-id` `--org` | 0 | Redelivers a specific webhook delivery for a webhook within an organization, to resend an event that previously failed or was not processed |
| `redeliver-delivery-for-repository-webhook` | `github.redeliverDeliveryForRepositoryWebhook()` | `--delivery-id` `--hook-id` `--owner` `--repo` | 0 | Redelivers a specific, previously made webhook delivery (`delivery_id`) for a repository's webhook (`hook_id`) |
| `remove-all-labels-from-issue` | `github.removeAllLabelsFromIssue()` | `--issue-number` `--owner` `--repo` | 0 | Removes all labels from a specified issue in a GitHub repository; this operation is idempotent |
| `remove-all-organization-roles-for-team` | `github.removeAllOrganizationRolesForTeam()` | `--org` `--team-slug` | 0 | Revokes all organization roles for a team in an organization; this is destructive and succeeds even if the team initially has no roles |
| `remove-all-organization-roles-for-user` | `github.removeAllOrganizationRolesForUser()` | `--org` `--username` | 0 | Revokes all assigned organization-level roles from a specified user (who must be a member of the organization) within a GitHub organization, without removing the user from the organization or… |
| `remove-app-access-restrictions` | `github.removeAppAccessRestrictions()` | `--branch` `--owner` `--repo` | 0 | Removes all GitHub App access restrictions from a protected branch in a repository; the branch must have protection rules configured, and this action does not alter user or team restrictions |
| `remove-assignees-from-issue` | `github.removeAssigneesFromIssue()` | `--issue-number` `--owner` `--repo` | 1 | Removes specified assignees from a GitHub issue; requires push access, and invalid removal attempts are silently ignored |
| `remove-custom-label-from-repo-runner` | `github.removeCustomLabelFromRepoRunner()` | `--name` `--owner` `--repo` `--runner-id` | 0 | Removes a custom label from a repository's self-hosted runner; this operation is idempotent |
| `remove-custom-label-from-self-hosted-runner` | `github.removeCustomLabelFromSelfHostedRunner()` | `--name` `--org` `--runner-id` | 0 | Removes a currently assigned custom label (`name`) from a self-hosted runner (`runner_id`) in an organization (`org`) |
| `remove-custom-labels-from-self-hosted-repo-runner` | `github.removeCustomLabelsFromSelfHostedRepoRunner()` | `--owner` `--repo` `--runner-id` | 0 | Removes all custom labels from a self-hosted runner registered at the repository level, leaving only its default labels and any labels inherited from its runner group or organization |
| `remove-custom-property-for-organization` | `github.removeCustomPropertyForOrganization()` | `--custom-property-name` `--org` | 0 | Deletes a custom property, specified by `custom_property_name`, from an existing organization (`org`) for which the property is currently defined, preventing its future assignment to repositories |
| `remove-interaction-restrictions-for-organization` | `github.removeInteractionRestrictionsForOrganization()` | `--org` | 0 | Removes all interaction restrictions from public repositories in the specified GitHub organization, allowing all users to resume interactions |
| `remove-interaction-restrictions-for-repository` | `github.removeInteractionRestrictionsForRepository()` | `--owner` `--repo` | 0 | Removes all interaction restrictions for a repository, enabling all users to comment, open issues, and create pull requests by lifting any existing temporary interaction limits |
| `remove-label-from-issue` | `github.removeLabelFromIssue()` | `--issue-number` `--name` `--owner` `--repo` | 0 | Removes a label currently applied to a specific issue in a repository |
| `remove-org-dev-env-secret-by-name` | `github.removeOrgDevEnvSecretByName()` | `--org` `--secret-name` | 0 | Deletes a GitHub Codespaces secret from an organization by its name; this operation is idempotent |
| `remove-org-secret-by-name` | `github.removeOrgSecretByName()` | `--org` `--secret-name` | 0 | Permanently removes a specific Dependabot secret, by its `secret_name`, from the GitHub `org`, making it unavailable to Dependabot for that organization |
| `remove-organization-member` | `github.removeOrganizationMember()` | `--org` `--username` | 0 | Removes a member from a GitHub organization |
| `remove-organization-role-from-team` | `github.removeOrganizationRoleFromTeam()` | `--org` `--role-id` `--team-slug` | 0 | Revokes an organization role that a team currently possesses within an organization |
| `remove-organization-role-from-user` | `github.removeOrganizationRoleFromUser()` | `--org` `--role-id` `--username` | 0 | Removes a custom organization role from a user within a GitHub organization, provided the organization exists, the user is a member, and the role_id corresponds to a valid custom role in that… |
| `remove-outside-collaborator-from-organization` | `github.removeOutsideCollaboratorFromOrganization()` | `--org` `--username` | 0 | Removes a user, who must be an outside collaborator, from the specified GitHub organization, revoking their access to all its repositories |
| `remove-project-from-team` | `github.removeProjectFromTeam()` | `--org` `--project-id` `--team-slug` | 0 | Removes a project from a team within an organization; this action requires the project to be currently associated with the team |
| `remove-public-org-membership` | `github.removePublicOrgMembership()` | `--org` `--username` | 0 | Removes the authenticated user's public organization membership, making it private |
| `remove-public-repo-interaction-restrictions` | `github.removePublicRepoInteractionRestrictions()` | — | 0 | Removes all interaction restrictions (limitations on comments, issues, or pull requests) from all public repositories owned by the authenticated user |
| `remove-repo-from-org-dev-env-secret` | `github.removeRepoFromOrgDevEnvSecret()` | `--org` `--repository-id` `--secret-name` | 0 | Removes a repository's access to an organization-level Codespaces secret, if it was previously granted |
| `remove-repo-from-org-secret-with-selected-visibility` | `github.removeRepoFromOrgSecretWithSelectedVisibility()` | `--org` `--repository-id` `--secret-name` | 0 | Revokes a specific repository's access to an organization-level Dependabot secret, applicable only when the secret has 'selected' visibility and the specified repository currently has access |
| `remove-repository-collaborator` | `github.removeRepositoryCollaborator()` | `--owner` `--repo` `--username` | 0 | Removes a collaborator from a specified GitHub repository, provided the repository exists and the user is an existing collaborator |
| `remove-repository-from-app-installation` | `github.removeRepositoryFromAppInstallation()` | `--installation-id` `--repository-id` | 0 | Removes a repository from a GitHub App installation for the authenticated user, given a valid `installation_id` and the `repository_id` of a repository currently linked to that installation; this… |
| `remove-repository-from-team` | `github.removeRepositoryFromTeam()` | `--org` `--owner` `--repo` `--team-slug` | 0 | Disassociates a repository from a team; team members may lose access permissions, but the repository and team are not deleted |
| `remove-requested-reviewers-from-pull-request` | `github.removeRequestedReviewersFromPullRequest()` | `--owner` `--pull-number` `--repo` `--reviewers` | 1 | Removes currently assigned user logins and/or team slugs from a GitHub pull request's list of requested reviewers |
| `remove-review-request` | `github.removeReviewRequest()` | `--owner` `--pull-number` `--repo` `--reviewers` | 1 | Removes requested reviewers from a pull request |
| `remove-selected-repo-from-org-secret` | `github.removeSelectedRepoFromOrgSecret()` | `--org` `--repository-id` `--secret-name` | 0 | Removes a specific repository's access to an organization-level secret; the repository must have been previously granted access to this secret |
| `remove-selected-repo-from-org-variable` | `github.removeSelectedRepoFromOrgVariable()` | `--name` `--org` `--repository-id` | 0 | Removes a repository's access to an organization variable that has 'selected' visibility |
| `remove-selected-repository-from-user-secret` | `github.removeSelectedRepositoryFromUserSecret()` | `--repository-id` `--secret-name` | 0 | Removes a selected repository's access to a user's Codespaces secret; the secret must exist and the repository must have previously been granted access |
| `remove-status-check-contexts` | `github.removeStatusCheckContexts()` | `--branch` `--contexts` `--owner` `--repo` | 0 | Removes specified status check contexts from a protected branch's required status checks |
| `remove-status-check-protection` | `github.removeStatusCheckProtection()` | `--branch` `--owner` `--repo` | 0 | Removes status check protection from a branch, disabling required status checks for merging pull requests; will only have an effect if status check protection is currently configured on the branch |
| `remove-team-access-restrictions` | `github.removeTeamAccessRestrictions()` | `--branch` `--owner` `--repo` `--teams` | 0 | Removes specified teams from push access to a protected branch |
| `remove-team-membership` | `github.removeTeamMembership()` | `--org` `--team-slug` `--username` | 0 | Remove team membership for a user in an organization |
| `remove-team-membership-for-user` | `github.removeTeamMembershipForUser()` | `--org` `--team-slug` `--username` | 0 | Removes a user from a specific team within an organization |
| `remove-user-access-restrictions` | `github.removeUserAccessRestrictions()` | `--branch` `--owner` `--repo` `--users` | 0 | Removes specified users from the list of people allowed to push to a protected branch |
| `remove-user-as-collaborator` | `github.removeUserAsCollaborator()` | `--project-id` `--username` | 0 | Removes a user as a collaborator from an organization project (classic) |
| `remove-users-codespaces-access-org` | `github.removeUsersCodespacesAccessOrg()` | `--org` `--selected-usernames` | 0 | Removes selected users from GitHub Codespaces billing access for an existing organization |
| `rename-branch` | `github.renameBranch()` | `--branch` `--new-name` `--owner` `--repo` | 0 | Renames an existing branch in a GitHub repository; the new name must be unique and adhere to GitHub's naming conventions, and the current branch name cannot contain wildcard characters |
| `render-markdown-document` | `github.renderMarkdownDocument()` | `--text` | 2 | Renders Markdown to HTML; for 'gfm' mode, provide 'context' (owner/repo) to correctly link issues, pull requests, and user mentions |
| `render-markdown-raw` | `github.renderMarkdownRaw()` | `--markdown-content` | 0 | Render raw Markdown text to HTML using GitHub's markdown API |
| `reopen-issue` ·common | `github.reopenIssue()` | `--issue-number` `--owner` `--repo` | 0 | Reopens a closed GitHub issue by changing its state to 'open' with state_reason 'reopened' |
| `reopen-pull-request` ·common | `github.reopenPullRequest()` | `--owner` `--pull-number` `--repo` | 0 | Reopens a previously closed pull request by setting its state to 'open' |
| `replace-all-repository-topics` | `github.replaceAllRepositoryTopics()` | `--names` `--owner` `--repo` | 0 | Replaces all topics of a repository |
| `replace-org-secret-visibility-to-selected` | `github.replaceOrgSecretVisibilityToSelected()` | `--org` `--secret-name` `--selected-repository-ids` | 0 | Replaces the list of repositories that can access a Dependabot organization secret when the secret's visibility is already set to 'selected' |
| `replace-repo-access-on-org-dev-env-secret-set` | `github.replaceRepoAccessOnOrgDevEnvSecretSet()` | `--org` `--secret-name` `--selected-repository-ids` | 0 | Replaces the list of repositories that can access an organization-level Codespaces secret |
| `request-pages-build` | `github.requestPagesBuild()` | `--owner` `--repo` | 0 | Manually triggers a GitHub Pages build for a repository if GitHub Pages is enabled, useful for deployments not automatically built or for retrying failed builds |
| `request-reviewers` ·common | `github.requestReviewers()` | `--owner` `--pull-number` `--repo` | 2 | Requests reviewers for a specific pull request identified by owner, repository, and pull request number |
| `request-reviewers-for-pull-request` | `github.requestReviewersForPullRequest()` | `--owner` `--pull-number` `--repo` | 2 | Adds reviewers to a specific pull request identified by owner, repo, and pull_number |
| `rerequest-check-run` | `github.rerequestCheckRun()` | `--check-run-id` `--owner` `--repo` | 0 | Triggers a re-run of a specific check run in a GitHub repository, resetting its status to 'queued', clearing its conclusion, and triggering the `check_run` webhook with `rerequested` action |
| `rerequest-check-suite` | `github.rerequestCheckSuite()` | `--check-suite-id` `--owner` `--repo` | 0 | Triggers a new run of an existing check suite within a repository, resetting its status to 'queued', clearing its conclusion, and triggering the `check_suite` webhook with `rerequested` action |
| `reset-token` | `github.resetToken()` | `--access-token` `--client-id` | 0 | Invalidates the provided OAuth `access_token` and generates a new one for the GitHub OAuth App identified by `client_id` |
| `restore-package-for-authenticated-user` | `github.restorePackageForAuthenticatedUser()` | `--package-name` `--package-type` | 1 | Restores a package deleted by the authenticated user within the last 30 days, if its namespace and version are still available |
| `restore-package-for-organization` | `github.restorePackageForOrganization()` | `--org` `--package-name` `--package-type` | 1 | Restores a package in an organization, provided it was deleted within the last 30 days |
| `restore-package-for-user` | `github.restorePackageForUser()` | `--package-name` `--package-type` `--username` | 1 | Restores a user-owned package previously deleted from GitHub Packages, if restorable under GitHub's data retention policy (typically within 30 days of deletion) |
| `restore-package-version-for-authenticated-user` | `github.restorePackageVersionForAuthenticatedUser()` | `--package-name` `--package-type` `--package-version-id` | 0 | Restores a package version that was deleted by the authenticated user within the last 30 days |
| `restore-package-version-for-organization` | `github.restorePackageVersionForOrganization()` | `--org` `--package-name` `--package-type` `--package-version-id` | 0 | Restores a package version for an organization, provided it was deleted within the last 30 days |
| `restore-package-version-for-user` | `github.restorePackageVersionForUser()` | `--package-name` `--package-type` `--package-version-id` `--username` | 0 | Restores a specific, user-owned package version if it was deleted within the last 30 days and its original namespace and version name are still available |
| `retire-sponsors-tier` | `github.retireSponsorsTier()` | `--tier-id` | 1 | Retire a published payment tier from your GitHub Sponsors profile using GraphQL |
| `review-access-with-personal-token` | `github.reviewAccessWithPersonalToken()` | `--action` `--org` `--pat-request-id` | 1 | Approves or denies a pending fine-grained personal access token request for organization resources; must be performed by a GitHub App |
| `review-deployment-protection-rules` | `github.reviewDeploymentProtectionRules()` | `--environment-name` `--owner` `--repo` `--run-id` `--state` | 1 | Approves or rejects pending custom deployment protection rules for a workflow run |
| `review-pending-deployments-for-workflow-run` | `github.reviewPendingDeploymentsForWorkflowRun()` | `--comment` `--environment-ids` `--owner` `--repo` `--run-id` `--state` | 0 | Approves or rejects pending deployments for a specific workflow run that are in a 'waiting' state within specified, configured environments |
| `review-resource-requests-with-fine-grained-tokens` | `github.reviewResourceRequestsWithFineGrainedTokens()` | `--action` `--org` `--pat-request-ids` | 1 | Approves or denies multiple fine-grained personal access token requests for an organization in bulk |
| `revoke-installation-access-token` | `github.revokeInstallationAccessToken()` | — | 0 | Revokes the GitHub App's current installation access token, immediately invalidating it for API authentication |
| `run-graph-ql-query` | `github.runGraphQlQuery()` | `--query` | 1 | Run an arbitrary GitHub GraphQL v4 query or mutation |
| `run-graph-ql-relay-query` | `github.runGraphQlRelayQuery()` | `--query` | 1 | Run a GitHub GraphQL relay query |
| `search-code` | `github.searchCode()` | `--q` | 4 | Searches code file contents and paths on the default branch of GitHub repositories using a query string; searches only files under 384KB, returns max 1000 results by best match, and is optimized for… |
| `search-code-all-pages` | `github.searchCodeAllPages()` | `--q` | 6 | Search code across multiple pages using GitHub's code search API |
| `search-commits` | `github.searchCommits()` | `--q` | 4 | Finds commits on GitHub using a query string (q) supporting keywords and qualifiers, with options for sorting and pagination |
| `search-commits-by-author` | `github.searchCommitsByAuthor()` | `--q` | 5 | Searches commits across GitHub using the Search API (e.g., by author/email/org/date range) without per-repo scanning |
| `search-graphql` | `github.searchGraphql()` | `--query` `--type` | 2 | Perform GitHub GraphQL searches across issues, pull requests, repositories, users, and discussions |
| `search-issues` ·common | `github.searchIssues()` | `--q` | 4 | Searches GitHub issues and pull requests using a flexible query with qualifiers, sorting, and pagination |
| `search-issues-and-pull-requests` | `github.searchIssuesAndPullRequests()` | `--q` | 5 | Searches GitHub for issues and pull requests |
| `search-labels` | `github.searchLabels()` | `--q` `--repository-id` | 4 | Searches for labels within a GitHub repository by keywords in their names or descriptions |
| `search-repositories` | `github.searchRepositories()` | `--q` | 4 | Searches GitHub repositories using a flexible query (keywords, qualifiers) with sorting, ordering, and pagination |
| `search-topics` | `github.searchTopics()` | `--q` | 2 | Finds topics on GitHub using keywords and qualifiers with GitHub's search syntax, supporting pagination |
| `search-users` | `github.searchUsers()` | `--q` | 4 | Searches for users on GitHub by criteria like username, email, location, followers, or repository associations, using a flexible query string `q` |
| `set-actions-permissions-for-organization` | `github.setActionsPermissionsForOrganization()` | `--enabled-repositories` `--org` | 2 | Sets the GitHub Actions permissions policy for an organization, specifying which repositories can run Actions and which actions/workflows are allowed; if 'selected' is chosen for either, manage the… |
| `set-actions-permissions-for-repository` | `github.setActionsPermissionsForRepository()` | `--enabled` `--owner` `--repo` | 1 | Sets GitHub Actions permissions for a repository, enabling/disabling Actions and defining the policy for allowed actions and reusable workflows |
| `set-admin-branch-protection` | `github.setAdminBranchProtection()` | `--branch` `--owner` `--repo` | 0 | Enables administrator enforcement on a branch, making existing protection rules also apply to administrators; branch protection rules must already be configured |
| `set-app-access-restrictions` | `github.setAppAccessRestrictions()` | `--apps` `--branch` `--owner` `--repo` | 0 | Replaces the list of GitHub Apps permitted to push to a protected branch |
| `set-default-workflow-permissions-for-organization` | `github.setDefaultWorkflowPermissionsForOrganization()` | `--org` | 2 | Updates an organization's default GITHUB_TOKEN permissions for workflows and whether GitHub Actions can approve pull requests; note that allowing Actions to approve pull requests… |
| `set-default-workflow-permissions-for-repository` | `github.setDefaultWorkflowPermissionsForRepository()` | `--owner` `--repo` | 2 | Sets the default permissions for the GITHUB_TOKEN within a repository and configures whether GitHub Actions can approve pull requests |
| `set-email-visibility` | `github.setEmailVisibility()` | `--visibility` | 0 | Sets the visibility ('public' or 'private') of the authenticated user's primary email address on GitHub, if one is configured |
| `set-interaction-restrictions-for-organization` | `github.setInteractionRestrictionsForOrganization()` | `--limit` `--org` | 1 | Limits interactions (comments, new issues, PRs) in an organization's public repositories by user type and duration, typically to mitigate high traffic or unwanted activity |
| `set-interaction-restrictions-for-repository` | `github.setInteractionRestrictionsForRepository()` | `--limit` `--owner` `--repo` | 1 | Temporarily limits which GitHub users (e.g., existing_users, contributors_only) can interact (comment, open issues, create pull requests) in a repository for a specified duration |
| `set-interaction-restrictions-for-your-public-repos` | `github.setInteractionRestrictionsForYourPublicRepos()` | `--limit` | 1 | Sets or updates temporary interaction restrictions for all public repositories owned by the authenticated user, overriding any repository-specific limits |
| `set-labels-for-issue` | `github.setLabelsForIssue()` | `--issue-number` `--labels` `--owner` `--repo` | 0 | Replaces all existing labels on a GitHub issue with a new set of labels |
| `set-oidc-subject-claim-template` | `github.setOidcSubjectClaimTemplate()` | `--owner` `--repo` `--use-default` | 1 | Sets the OpenID Connect (OIDC) subject claim template for a GitHub repository, allowing use of the default template or a custom one defined by `include_claim_keys` if `use_default` is `false` |
| `set-org-allowed-actions` | `github.setOrgAllowedActions()` | `--org` | 3 | Sets the GitHub Actions permissions for an existing organization, specifying allowed GitHub-owned actions, verified creator actions, and action/workflow patterns from public repositories |
| `set-org-runner-labels` | `github.setOrgRunnerLabels()` | `--labels` `--org` `--runner-id` | 0 | Sets the custom labels for a self-hosted runner in an organization; this operation does not affect default system-assigned labels (e.g., 'self-hosted', 'linux', 'x64') |
| `set-repo-allowed-actions` | `github.setRepoAllowedActions()` | `--owner` `--repo` | 3 | Sets allowed GitHub Actions and reusable workflows for a repository, managing permissions for GitHub-owned, verified creator, or specific pattern-matched actions/workflows (note: `patterns_allowed`… |
| `set-repo-runner-labels` | `github.setRepoRunnerLabels()` | `--labels` `--owner` `--repo` `--runner-id` | 0 | Replaces all custom labels for a specific self-hosted runner in a repository; an empty list for `labels` removes all existing custom labels |
| `set-repository-subscription` | `github.setRepositorySubscription()` | `--owner` `--repo` | 2 | Sets the authenticated user's notification subscription for a repository |
| `set-selected-repos-for-org-variable` | `github.setSelectedReposForOrgVariable()` | `--name` `--org` `--selected-repository-ids` | 0 | Replaces the list of repositories that can access an organization-level variable; the variable's visibility must be 'selected' |
| `set-selected-repositories-for-organization-secret` | `github.setSelectedRepositoriesForOrganizationSecret()` | `--org` `--secret-name` `--selected-repository-ids` | 0 | Replaces the list of repositories that can access an organization secret; only effective if the secret's visibility is 'selected' |
| `set-selected-repositories-for-user-secret` | `github.setSelectedRepositoriesForUserSecret()` | `--secret-name` `--selected-repository-ids` | 0 | Defines the list of repositories permitted to access a specific Codespaces secret for the authenticated user |
| `set-status-check-contexts` | `github.setStatusCheckContexts()` | `--branch` `--contexts` `--owner` `--repo` | 0 | Replaces required status check contexts for a protected branch, requiring admin permissions; an empty `contexts` array removes all checks |
| `set-team-access-restrictions` | `github.setTeamAccessRestrictions()` | `--branch` `--owner` `--repo` `--teams` | 0 | Replaces the list of teams with push access to a protected branch |
| `set-thread-subscription` | `github.setThreadSubscription()` | `--thread-id` | 1 | Sets whether a GitHub notification thread is ignored (muted) or unignored (unmuted), for a `thread_id` that must identify an existing notification thread |
| `set-user-access-restrictions` | `github.setUserAccessRestrictions()` | `--branch` `--owner` `--repo` `--users` | 0 | Replaces the list of users with push access to a protected branch in an organization repository |
| `set-user-interaction-limit-graph-ql` | `github.setUserInteractionLimitGraphQl()` | `--limit` `--userId` | 2 | Set interaction limits on a user's public repositories using GraphQL |
| `set-workflow-external-access` | `github.setWorkflowExternalAccess()` | `--access-level` `--owner` `--repo` | 0 | Sets the access level for workflows outside a repository to use actions and reusable workflows within that repository |
| `star-gist` | `github.starGist()` | `--gist-id` | 0 | Stars a GitHub gist identified by `gist_id`; this action is idempotent and returns a 204 No Content status upon success, even if the gist is already starred |
| `star-repository-for-authenticated-user` ·common | `github.starRepositoryForAuthenticatedUser()` | `--owner` `--repo` | 0 | Stars a specified repository (identified by owner and repo name) for the authenticated user; this action is idempotent and succeeds even if the repository is already starred |
| `start-codespace-for-authenticated-user` | `github.startCodespaceForAuthenticatedUser()` | `--codespace-name` | 0 | Initiates the startup process for an existing GitHub Codespace (identified by `codespace_name`) if it's in a startable state like 'Available' or 'Stopped' |
| `stop-codespace-for-authenticated-user` | `github.stopCodespaceForAuthenticatedUser()` | `--codespace-name` | 0 | Stops a running or available Codespace for the authenticated user, pausing its execution and billing |
| `stop-codespace-for-organization-user` | `github.stopCodespaceForOrganizationUser()` | `--codespace-name` `--org` `--username` | 0 | Stops a running codespace for an organization member |
| `submit-review-for-pull-request` | `github.submitReviewForPullRequest()` | `--event` `--owner` `--pull-number` `--repo` `--review-id` | 1 | Finalizes a pending pull request review (identified by `review_id`) with a required `event` (APPROVE, REQUEST_CHANGES, COMMENT) and an optional `body` |
| `sync-fork-branch-with-upstream` | `github.syncForkBranchWithUpstream()` | `--branch` `--owner` `--repo` | 0 | Synchronizes a branch in a forked GitHub repository with its upstream counterpart, assuming the repository is a fork, the branch exists, an upstream is configured, and the merge is conflict-free |
| `test-repository-webhook` | `github.testRepositoryWebhook()` | `--hook-id` `--owner` `--repo` | 0 | Triggers a simulated push event to test a repository's push webhook; a test event is only delivered if the webhook is subscribed to 'push' events, otherwise, it returns 204 No Content without sending… |
| `transfer-repository` | `github.transferRepository()` | `--new-owner` `--owner` `--repo` | 2 | Initiates a repository transfer to a new owner (who must accept the request); if the new owner is an organization, it must be configured to allow transfers |
| `unblock-user` | `github.unblockUser()` | `--username` | 0 | Unblocks a GitHub user, provided they are currently blocked by the authenticated user |
| `unblock-user-from-organization` | `github.unblockUserFromOrganization()` | `--org` `--username` | 0 | Unblocks a user from an organization, allowing renewed interaction with its resources, provided the user is currently blocked (otherwise, a 404 error may occur) |
| `unfollow-organization` | `github.unfollowOrganization()` | `--organizationId` | 1 | Unfollow a GitHub organization using GraphQL |
| `unfollow-user` | `github.unfollowUser()` | `--user-id` | 1 | Unfollow a GitHub user using GraphQL |
| `unlock-issue` | `github.unlockIssue()` | `--issue-number` `--owner` `--repo` | 0 | Unlocks a currently locked GitHub issue in the specified repository, allowing new comments and interactions |
| `unlock-organization-repository` | `github.unlockOrganizationRepository()` | `--migration-id` `--org` `--repo-name` | 0 | Unlocks a repository that was locked for migration within a GitHub organization |
| `unlock-user-repository` | `github.unlockUserRepository()` | `--migration-id` `--repo-name` | 0 | Unlocks a repository (`repo_name`) that was locked as part of a user migration (`migration_id`), making it usable or deletable; this action requires the repository to be currently locked |
| `unstar-gist` | `github.unstarGist()` | `--gist-id` | 0 | Removes a star from the specified gist; the action is idempotent and will not error if the gist was not previously starred by the user |
| `unstar-repository` | `github.unstarRepository()` | `--owner` `--repo` | 0 | Removes the authenticated user's star from a specified repository, which must already be starred by the user |
| `update-authenticated-user` | `github.updateAuthenticatedUser()` | — | 8 | Updates the authenticated user's GitHub profile; a new public email must be verified, and existing private emails remain private even if specified |
| `update-branch-protection` | `github.updateBranchProtection()` | `--branch` `--owner` `--repo` | 24 | Updates the protection settings for an existing branch in a repository, which must not contain wildcard characters |
| `update-check-run` | `github.updateCheckRun()` | `--check-run-id` `--owner` `--repo` | 13 | Updates an existing check run for a specific commit in a repository, allowing modifications to its status, conclusion, output, and other details |
| `update-code-scanning-alert` | `github.updateCodeScanningAlert()` | `--alert-number` `--owner` `--repo` `--state` | 2 | Updates a specific code scanning alert in a GitHub repository, primarily to change its state (e.g., 'open' or 'dismissed') |
| `update-code-scanning-default-setup` | `github.updateCodeScanningDefaultSetup()` | `--owner` `--repo` | 5 | Updates the default setup configuration for code scanning in a repository; GitHub Advanced Security must be enabled for the repository |
| `update-codespace` | `github.updateCodespace()` | `--codespace-name` | 3 | Updates an existing GitHub Codespace's machine type, display name, or recent folders for the authenticated user; machine type changes take effect on the next start |
| `update-commit-comment` | `github.updateCommitComment()` | `--body` `--comment-id` `--owner` `--repo` | 0 | Changes the body of an existing commit comment |
| `update-custom-organization-role` | `github.updateCustomOrganizationRole()` | `--org` `--role-id` | 4 | Updates an existing custom role in an organization by modifying its name, description, or permissions; at least one of these fields must be provided |
| `update-deployment-branch-policy` | `github.updateDeploymentBranchPolicy()` | `--branch-policy-id` `--environment-name` `--name` `--owner` `--repo` | 0 | Updates the name pattern of an existing deployment branch policy for a specific environment in a repository |
| `update-discussion` | `github.updateDiscussion()` | `--discussion-number` `--org` `--team-slug` | 2 | Updates the title and/or body of a specific team discussion within an organization |
| `update-discussion-comment` | `github.updateDiscussionComment()` | `--body` `--comment-number` `--discussion-number` `--org` `--team-slug` | 0 | Updates the body of a comment in a team's discussion within an organization |
| `update-environment-variable` | `github.updateEnvironmentVariable()` | `--environment-name` `--name` `--owner` `--repo` | 2 | Updates an existing environment variable's name and/or value in a specific GitHub repository environment; requires providing either a new name or a new value |
| `update-gist` | `github.updateGist()` | `--gist-id` | 2 | Updates a gist's description, and/or its files (including content, filename changes, or deletion) |
| `update-gist-comment` | `github.updateGistComment()` | `--body` `--comment-id` `--gist-id` | 0 | Updates an existing comment on a specified gist |
| `update-git-lfs-preference` | `github.updateGitLfsPreference()` | `--owner` `--repo` `--use-lfs` | 0 | Sets the Git Large File Storage (LFS) preference for a repository during a source import |
| `update-issue` | `github.updateIssue()` | `--issue-number` `--owner` `--repo` | 8 | Updates an existing GitHub issue's title, body, state, milestone, labels, or assignees; `state_reason` is only processed if `state` also changes, and use `null` or `[]` to clear applicable fields |
| `update-issue-comment` | `github.updateIssueComment()` | `--body` `--comment-id` `--owner` `--repo` | 0 | Updates an existing comment on an issue or pull request within a specified repository |
| `update-issue-type` | `github.updateIssueType()` | `--is-enabled` `--issue-type-id` `--name` `--org` | 2 | Update an existing issue type for a GitHub organization |
| `update-label` | `github.updateLabel()` | `--name` `--owner` `--repo` | 3 | Updates an existing label's name, color, or description within a specified repository |
| `update-milestone` | `github.updateMilestone()` | `--milestone-number` `--owner` `--repo` | 4 | Updates a milestone in a repository, identified by `owner`, `repo`, and `milestone_number`, by allowing modification of its `title`, `state`, `description`, or `due_on`; at least one of these four… |
| `update-organization` | `github.updateOrganization()` | `--org` | 29 | Updates an organization's settings; changing security-related fields requires admin, owner, or security manager permissions |
| `update-organization-variable` | `github.updateOrganizationVariable()` | `--name` `--org` | 4 | Updates an existing GitHub Actions organization variable's name, value, or visibility (`all`, `private`, `selected`), requiring `selected_repository_ids` with valid repository IDs if visibility is… |
| `update-organization-webhook` | `github.updateOrganizationWebhook()` | `--hook-id` `--org` | 7 | Updates the configuration (URL, content type, secret, SSL verification), subscribed events, active status, or name of an existing webhook for a specified organization |
| `update-organization-webhook-configuration` | `github.updateOrganizationWebhookConfiguration()` | `--hook-id` `--org` | 4 | Updates the configuration (URL, content type, secret, SSL verification) for an existing webhook within a specified organization |
| `update-project` | `github.updateProject()` | `--project-number` | 7 | Updates an existing GitHub project (V2) attributes like title, description, visibility, and state |
| `update-project-card` | `github.updateProjectCard()` | `--card-id` | 2 | Updates an existing project card's note and/or archived status (GitHub Classic Projects) |
| `update-project-column` | `github.updateProjectColumn()` | `--column-id` `--name` | 0 | Updates the name of an existing column, identified by `column_id`, in a GitHub project (classic) |
| `update-pull-request` | `github.updatePullRequest()` | `--owner` `--pull-number` `--repo` | 5 | Updates an existing pull request, allowing changes to attributes like title, body, state, base branch, and maintainer modification settings |
| `update-pull-request-branch` | `github.updatePullRequestBranch()` | `--owner` `--pull-number` `--repo` | 1 | Updates an open pull request's head branch by merging the latest changes from its base branch, if mergeable and repository merging is enabled; operates asynchronously |
| `update-pull-request-review` | `github.updatePullRequestReview()` | `--body` `--owner` `--pull-number` `--repo` `--review-id` | 0 | Updates the body text of an existing pull request review |
| `update-pull-request-review-comment` | `github.updatePullRequestReviewComment()` | `--body` `--comment-id` `--owner` `--repo` | 0 | Updates the body of an existing review comment on a pull request |
| `update-pull-request-review-protection` | `github.updatePullRequestReviewProtection()` | `--branch` `--owner` `--repo` | 10 | Updates pull request review protection settings (e.g., required approvals, review dismissal, bypass allowances) for a branch; branch protection features must be available for the repository |
| `update-reference` ·common | `github.updateReference()` | `--owner` `--ref` `--repo` `--sha` | 1 | Updates an existing Git reference (e.g., a branch or tag) to point to a specific commit SHA |
| `update-release` | `github.updateRelease()` | `--owner` `--release-id` `--repo` | 8 | Updates an existing release in a GitHub repository, allowing modification of its attributes; if linking a discussion, the `discussion_category_name` must refer to an existing category in the… |
| `update-release-asset` | `github.updateReleaseAsset()` | `--asset-id` `--owner` `--repo` | 3 | Updates the name, label, or state of a release asset in a GitHub repository, requiring at least one of these properties to be provided for modification |
| `update-repository` | `github.updateRepository()` | `--owner` `--repo` | 27 | Updates settings for an existing GitHub repository, such as name, description, visibility, merge strategies, and security configurations |
| `update-repository-invitation` | `github.updateRepositoryInvitation()` | `--invitation-id` `--owner` `--repo` | 1 | Updates an active repository invitation to modify the invited user's permissions; the specified repository and invitation must exist |
| `update-repository-preferences-for-check-suites` | `github.updateRepositoryPreferencesForCheckSuites()` | `--owner` `--repo` | 1 | Updates repository preferences for automatic Check Suite creation on code pushes, allowing configuration for specific GitHub Apps that must be installed on the repository with `checks:write`… |
| `update-repository-ruleset` | `github.updateRepositoryRuleset()` | `--owner` `--repo` `--ruleset-id` | 7 | Updates an existing repository ruleset, identified by `ruleset_id` for a given repository, allowing partial updates to its configuration such as name, target, enforcement, bypass actors, conditions… |
| `update-repository-variable` | `github.updateRepositoryVariable()` | `--name` `--owner` `--repo` | 2 | Updates the name and/or value of an existing GitHub Actions variable in a repository |
| `update-repository-webhook` | `github.updateRepositoryWebhook()` | `--hook-id` `--owner` `--repo` | 8 | Updates the URL, content type, secret, SSL verification, events, or active status for an existing repository webhook, specified by `owner`, `repo`, and `hook_id` |
| `update-repository-webhook-configuration` | `github.updateRepositoryWebhookConfiguration()` | `--hook-id` `--owner` `--repo` | 4 | Updates the configuration (e.g., payload URL, content type, secret, SSL verification) for an existing webhook in a specified repository |
| `update-resource-access-with-tokens` | `github.updateResourceAccessWithTokens()` | `--action` `--org` `--pat-ids` | 0 | Revokes organization access for the personal access tokens identified by `pat_ids`; this action must be performed by a GitHub App, and `pat_ids` must be valid and associated with the organization |
| `update-status-check-protection` | `github.updateStatusCheckProtection()` | `--branch` `--owner` `--repo` | 3 | Updates required status checks for a branch, optionally requiring it to be up-to-date before merging |
| `update-subscription` | `github.updateSubscription()` | `--state` `--subscribableId` | 1 | Update notification subscription state for issues, pull requests, or discussions |
| `update-team` | `github.updateTeam()` | `--org` `--team-slug` | 6 | Updates a team's settings (e.g., name, description, privacy, parent team) within a GitHub organization, identified by its slug and organization name |
| `update-token-org-access` | `github.updateTokenOrgAccess()` | `--org` `--pat-id` | 1 | Revokes a fine-grained personal access token's access to an organization |
| `update-user-list` | `github.updateUserList()` | `--list-id` | 4 | Update an existing GitHub user list |
| `update-user-lists-for-item` | `github.updateUserListsForItem()` | `--item-id` `--list-ids` | 2 | Update which of the viewer's lists an item belongs to on GitHub |
| `update-user-project-item` | `github.updateUserProjectItem()` | `--fieldId` `--itemId` `--projectId` `--value` | 0 | Update a field value for an item in a user's GitHub ProjectV2 |
| `update-user-status` | `github.updateUserStatus()` | — | 6 | Update your status on GitHub |
| `upload-release-asset` | `github.uploadReleaseAsset()` | `--asset` `--content-type` `--owner` `--release-id` `--repo` | 1 | Upload a binary asset to an existing GitHub release |
| `upload-sarif-analysis` | `github.uploadSarifAnalysis()` | `--commit-sha` `--owner` `--ref` `--repo` `--sarif` | 4 | Uploads a gzipped and Base64 encoded SARIF file to a GitHub repository for a specific commit and reference; use `checkout_uri` if SARIF paths are absolute |
| `upsert-repo-custom-property-values` | `github.upsertRepoCustomPropertyValues()` | `--owner` `--properties` `--repo` | 0 | Creates or updates up to 30 custom property values for a repository; custom properties must be predefined at the organization or repository level, and setting a property's value to `null` removes it |
| `validate-credential` ·common | `github.validateCredential()` | — | 0 | Validates GitHub API credentials by checking if they can successfully authenticate |
| `verify-dev-container-permissions-accepted` | `github.verifyDevContainerPermissionsAccepted()` | `--devcontainer-path` `--owner` `--ref` `--repo` | 0 | Verifies if the authenticated user has accepted permissions for a specific devcontainer configuration in a repository, typically to ensure awareness before a codespace is created or used |

## Triggers

`github.on("<event>", handler)` in a script; required config goes before the handler as an object.

| Event | Name | Required config | Description |
|---|---|---|---|
| `"artifact-created"` | New Workflow Artifact Created | `owner` `repo` | Triggers when a new workflow artifact is created in a GitHub repository |
| `"branch-changed"` | Branch Changed | `owner` `repo` `branch` | Triggers when a GitHub branch changes |
| `"branch-created"` | New Branch Created | `owner` `repo` | Triggers when a new branch is created in a GitHub repository |
| `"check-run-status-changed"` | Check Run Status / Conclusion Changed | `owner` `repo` `check_run_id` | Triggers when a specific GitHub check run changes its status or conclusion |
| `"check-suite-status-changed"` | Check Suite Status / Conclusion Changed | `owner` `repo` `ref` | Triggers when a GitHub check suite changes its status or conclusion for a given ref |
| `"code-scanning-alert-created"` | New Code Scanning Alert Created | `owner` `repo` | Triggers when a new code scanning alert is created in a repository |
| `"collaborator-added"` | New Repository Collaborator Added | `owner` `repo` | Triggers when a new collaborator is added to a GitHub repository |
| `"commit-event"` | Commit Event | `owner` `repo` | Triggered when a new commit is pushed to a repository |
| `"deployment-created"` | New Deployment Created | `owner` `repo` | Triggers when a new deployment is created in a GitHub repository |
| `"deployment-state-changed"` | GitHub Deployment State Changed | `owner` `repo` `deployment_id` | Triggers when a specific GitHub deployment's fields change |
| `"deployment-status-created"` | New Deployment Status Created | `owner` `repo` `deployment_id` | Triggers when a new deployment status is created for a specific deployment |
| `"follower-event"` | Follower Changes | — | Triggers when new followers are detected on your GitHub account |
| `"git-reference-created"` | New Git Reference Created | `owner` `repo` `ref_prefix` | Triggers when a new Git reference (branch or tag) matching a specified prefix is created in a repository |
| `"issue-added-event"` | Issue Added Event | `owner` `repo` | Triggered when a new issue is added to the repository |
| `"issue-assigned-to-me"` | New Issue Assigned to Me | — | Triggers when a new issue is assigned to the authenticated user |
| `"issue-comment-changed"` | GitHub Issue Comment Changed | `owner` `repo` `comment_id` | Triggers when a specific GitHub issue comment changes |
| `"issue-comment-created"` | New GitHub Issue Comment | `owner` `repo` `issue_number` | Triggers when a new comment is added to a specific GitHub issue |
| `"issue-created"` | New Issue Created | `owner` `repo` | Triggers when a new issue is created in a GitHub repository |
| `"issue-event-occurred"` | New Issue Event | `owner` `repo` | Triggers when a new issue event occurs in a GitHub repository |
| `"issue-label-changed"` | GitHub Issue Labels Changed | `owner` `repo` `issue_number` | Triggers when the labels on a specific GitHub issue change |
| `"issue-state-changed"` | Issue State / Properties Changed | `owner` `repo` `issue_number` | Triggers when a specific GitHub issue changes any of its tracked properties |
| `"issue-updated"` | Issue Updated | `owner` `repo` | Triggers when an existing issue is updated in a GitHub repository |
| `"label-added-event"` | Label Added Event | `owner` `repo` | Triggered when a new label is added to a pull request |
| `"new-stargazer-added"` | New Stargazer Added | `owner` `repo` | Triggers when a new user stars a GitHub repository |
| `"pr-review-comment-created"` | New Pull Request Review Comment | `owner` `repo` `pull_number` | Triggers when a new inline review comment is added to a specific GitHub pull request |
| `"pull-request-commit-added"` | New Commit Added to Pull Request | `owner` `repo` `pull_number` | Triggers when a new commit is pushed to a specific pull request |
| `"pull-request-created"` | New Pull Request Created | — | Triggers when a new pull request is created in GitHub, matching the optional configured filters |
| `"pull-request-event"` | Pull Request Event | `owner` `repo` | Triggered when a pull request is opened, closed, or synchronized |
| `"pull-request-reviewers-changed"` | GitHub Pull Request Reviewers Changed | `owner` `repo` `pull_number` | Triggers when the list of requested reviewers (users or teams) for a pull request changes, for example when a reviewer is added, removed, o |
| `"pull-request-review-submitted"` | Pull Request Review Submitted | `owner` `repo` `pull_number` | Triggers when a new review is submitted for a GitHub pull request |
| `"pull-request-state-changed"` | Pull Request State / Properties Changed | `owner` `repo` `pull_number` | Triggers when a specific GitHub pull request changes any of these tracked properties: state (open/closed), title, body, draft status, lock s |
| `"pull-request-updated"` | Pull Request Updated | `owner` `repo` | Triggers when an existing pull request is updated in a GitHub repository |
| `"readme-changed"` | GitHub Repository README Changed | `owner` `repo` | Triggers when the README file in a specific repository directory changes |
| `"release-asset-added"` | New GitHub Release Asset Added | `owner` `repo` `release_id` | Triggers when a new asset is added to a specific GitHub release |
| `"release-state-changed"` | GitHub Release State Changed | `owner` `repo` `tag` | Triggers when a specific GitHub release (identified by tag name) changes |
| `"repository-content-changed"` | Repository Content Changed | `owner` `repo` | Triggers when the content of a file or directory in a GitHub repository changes |
| `"repository-notification-received"` | Repository Notification Received | `owner` `repo` | Triggers when a new or newly updated notification thread appears for a specific GitHub repository |
| `"repository-tag-created"` | New Repository Tag Created | `owner` `repo` | Triggers when a new tag is created in a GitHub repository |
| `"secret-scanning-alert-detected"` | New Secret Scanning Alert Detected | `owner` `repo` | Triggers when a new secret scanning alert is detected in a GitHub repository |
| `"star-added-event"` | Star Added Event | `owner` `repo` | Triggered when a new star is added to the repository |
| `"workflow-added"` | New GitHub Actions Workflow Added | `owner` `repo` | Triggers when a new GitHub Actions workflow is added to a repository |
| `"workflow-job-added"` | New Workflow Job Added | `owner` `repo` `run_id` | Triggers when a new job appears in a specific GitHub Actions workflow run |
| `"workflow-job-state-changed"` | Workflow Job State Changed | `owner` `repo` `job_id` | Triggers when the status, conclusion, timestamps, runner assignment, or step details of a specific GitHub Actions workflow job change betwee |
| `"workflow-run-artifact-added"` | New Artifact Added to Workflow Run | `owner` `repo` `run_id` | Triggers when a new artifact is uploaded to a specific GitHub Actions workflow run |
| `"workflow-run-created"` | New Workflow Run Created | `owner` `repo` | Triggers when a new workflow run is created in a GitHub repository |
| `"workflow-run-state-changed"` | GitHub Workflow Run State Changed | `owner` `repo` `run_id` | Triggers when a GitHub Actions workflow run's status or conclusion changes |

## Docs

- [run CLI](https://docs.boxd.sh/cli/run): Call connected integrations from the shell, connect new ones, and run automations.
- [Quickstart](https://docs.boxd.sh/guides/integrations/quickstart): Connect an integration, call it from the shell, and turn a script into an automation.
- [Connections](https://docs.boxd.sh/guides/integrations/connections): Connect an account once, for yourself or for your whole organization.
- [Scripts](https://docs.boxd.sh/guides/automations/scripts): Typed integrations, triggers, schedules and state in a .run.ts file.
- [Jobs](https://docs.boxd.sh/guides/automations/jobs): How a script becomes a background job: states, retries, sleep and wake.
- [Beyond the catalog](https://docs.boxd.sh/guides/automations/beyond-the-catalog): Reach your own APIs, databases and cloud accounts from a script.