| 1 | //! The MCP server's tools: a few resource tools, each with an `action`. |
| 2 | //! |
| 3 | //! Every operation is one action of one tool. A call is dispatched to the |
| 4 | //! operation it names, so permissions, the audit log, billing and outcomes |
| 5 | //! are exactly those of the REST API. A token sees only the actions its |
| 6 | //! scopes allow, and a tool none of whose actions it may use is not listed. |
| 7 | //! |
| 8 | //! The listed input schema is one flat object: `action`, then every field |
| 9 | //! any of its actions takes. Which fields each action needs is in the |
| 10 | //! `action` field's description and checked on every call. Claude's API, |
| 11 | //! and so most MCP clients, refuse a tool whose input schema has `oneOf` |
| 12 | //! at its top level, so the schema keyed by action, with each action's |
| 13 | //! required fields, is [`discriminated`], published on the server's card |
| 14 | //! and in the docs. |
| 15 | |
| 16 | use g1t_contracts::credentials::NEVER; |
| 17 | use g1t_contracts::identity::AgentScope; |
| 18 | use g1t_contracts::scopes::{Level, NO_SCOPE, TokenAccess, scope_for}; |
| 19 | use serde_json::{Map, Value, json}; |
| 20 | |
| 21 | use crate::about::AboutOp; |
| 22 | use crate::run_artifacts::ArtifactsOp; |
| 23 | use crate::caches::CachesOp; |
| 24 | use crate::archives::ArchiveOp; |
| 25 | use crate::deploy_keys::DeployKeysOp; |
| 26 | use crate::deployments::DeploymentsOp; |
| 27 | use crate::telemetry::TelemetryOp; |
| 28 | use crate::packages::PackagesOp; |
| 29 | use crate::folios::FoliosOp; |
| 30 | use crate::coordination::CoordinationOp; |
| 31 | use crate::protection::ProtectionOp; |
| 32 | use crate::token_policy::TokenOp; |
| 33 | use crate::sso::SsoOp; |
| 34 | use crate::onboarding::OnboardingOp; |
| 35 | use crate::operations::Op; |
| 36 | use crate::checks::ChecksOp; |
| 37 | use crate::rules::RulesOp; |
| 38 | use crate::security::SecurityOp; |
| 39 | |
| 40 | pub struct Action { |
| 41 | pub name: &'static str, |
| 42 | pub op: Op, |
| 43 | /// One line, for the `action` field's description. |
| 44 | pub summary: &'static str, |
| 45 | } |
| 46 | |
| 47 | pub struct Tool { |
| 48 | pub name: &'static str, |
| 49 | pub title: &'static str, |
| 50 | /// What it is for, in a sentence or two. |
| 51 | pub description: &'static str, |
| 52 | pub actions: &'static [Action], |
| 53 | /// The action a call without one runs. |
| 54 | pub default_action: Option<&'static str>, |
| 55 | } |
| 56 | |
| 57 | const fn a(name: &'static str, op: Op, summary: &'static str) -> Action { |
| 58 | Action { name, op, summary } |
| 59 | } |
| 60 | |
| 61 | pub const TOOLS: &[Tool] = &[ |
| 62 | Tool { |
| 63 | name: "search", |
| 64 | title: "Search", |
| 65 | description: "Find things. `code` (the default) searches all of g1t you can see: repositories, code, work items, pull requests and people, with qualifiers like repo:owner/name, language:rust, is:item. `ticket` reads a Jira, Linear or Sentry item the work refers to.", |
| 66 | default_action: Some("code"), |
| 67 | actions: &[ |
| 68 | a("code", Op::Search, "Search all of g1t: repositories, code, work items, pull requests, people"), |
| 69 | a("ticket", Op::GetContext, "A Jira, Linear or Sentry item the work refers to, as it is now"), |
| 70 | ], |
| 71 | }, |
| 72 | Tool { |
| 73 | name: "repository", |
| 74 | title: "Repositories", |
| 75 | description: "Repositories: find, read and create them, change their settings and rulesets (what may happen to branches and tags, and what a pull request needs to merge), check their CODEOWNERS file, see and dismiss their security alerts (secrets and vulnerable dependencies), read what their default branch says (languages, contributors, license), star them, publish releases and comment on their commits. Name one as \"owner/name\". Deleting, transferring and changing visibility need `confirm`.", |
| 76 | default_action: None, |
| 77 | actions: &[ |
| 78 | a("list", Op::ListRepos, "Repositories you can see"), |
| 79 | a("get", Op::GetRepo, "One repository"), |
| 80 | a("commits", Op::ListCommits, "A branch's commits with their messages (why each was made); with path, the commit that last changed it"), |
| 81 | a("commit_comments", Op::ListCommitComments, "A commit's comments, on it or on lines of its files"), |
| 82 | a("list_commit_comments", Op::ListRepoCommitComments, "All its commit comments, newest first"), |
| 83 | a("comment_on_commit", Op::CreateCommitComment, "Comment on a commit; path and line for one line of a file it changed"), |
| 84 | a("edit_commit_comment", Op::UpdateCommitComment, "Change your commit comment's text"), |
| 85 | a("delete_commit_comment", Op::DeleteCommitComment, "Delete a commit comment: your own, or any with the Maintain role"), |
| 86 | a("contents", Op::GetContents, "A file's text, or a directory's entries and README, at a branch, tag or commit"), |
| 87 | a("tarball", Op::Archives(ArchiveOp::DownloadTarball), "A 10-minute link to a branch, tag or commit as a .tar.gz"), |
| 88 | a("zipball", Op::Archives(ArchiveOp::DownloadZipball), "A 10-minute link to a branch, tag or commit as a .zip"), |
| 89 | a("create", Op::CreateRepo, "Create one, empty or copied from a public git URL; private unless private is false; deploy true turns its g1t.page deployments on"), |
| 90 | a("update", Op::UpdateRepo, "Change description (its project's), website, topics, default branch, protection, forking"), |
| 91 | a("get_settings", Op::GetRepoSettings, "How pull requests merge, and the default branch's protection as its rules stack"), |
| 92 | a("update_settings", Op::UpdateRepoSettings, "Change how pull requests merge and the default branch protection ruleset"), |
| 93 | a("check_names", Op::ListCheckNames, "Check names reported lately, to require in a ruleset"), |
| 94 | a("list_rulesets", Op::Rules(RulesOp::ListRepoRulesets), "Its rulesets, and its workspace's that hold in it"), |
| 95 | a("get_ruleset", Op::Rules(RulesOp::GetRepoRuleset), "One ruleset"), |
| 96 | a("create_ruleset", Op::Rules(RulesOp::CreateRepoRuleset), "Create a ruleset for its branches or tags"), |
| 97 | a("update_ruleset", Op::Rules(RulesOp::UpdateRepoRuleset), "Change a ruleset"), |
| 98 | a("delete_ruleset", Op::Rules(RulesOp::DeleteRepoRuleset), "Delete a ruleset"), |
| 99 | a("branch_rules", Op::Rules(RulesOp::GetBranchRules), "Every rule that holds for a branch or tag, and where it comes from"), |
| 100 | a("rule_evaluations", Op::Rules(RulesOp::ListRuleEvaluations), "How its rules judged pushes and merges, with insights"), |
| 101 | a("codeowners", Op::GetCodeownersErrors, "Problems in its CODEOWNERS file, by line"), |
| 102 | a("list_events", Op::ListEvents, "Timeline: pushes, work items, pull requests, comments"), |
| 103 | a("work", Op::ListRepoWorkItems, "The work items linked to it, in any role or in one"), |
| 104 | a("languages", Op::About(AboutOp::GetLanguages), "Its languages by bytes, with colors and percentages"), |
| 105 | a("contributors", Op::About(AboutOp::ListContributors), "Who made it: commits per person, agent and author, by week"), |
| 106 | a("license", Op::About(AboutOp::GetLicense), "The license its LICENSE file holds"), |
| 107 | a("stargazers", Op::About(AboutOp::ListStargazers), "Who starred it"), |
| 108 | a("starred", Op::About(AboutOp::CheckStarred), "Whether you starred it, and how many have"), |
| 109 | a("star", Op::About(AboutOp::Star), "Star it"), |
| 110 | a("unstar", Op::About(AboutOp::Unstar), "Take your star back"), |
| 111 | a("list_starred", Op::About(AboutOp::ListStarred), "Repositories you starred"), |
| 112 | a("list_releases", Op::About(AboutOp::ListReleases), "Releases, newest first"), |
| 113 | a("latest_release", Op::About(AboutOp::GetLatestRelease), "The latest release"), |
| 114 | a("get_release", Op::About(AboutOp::GetRelease), "One release by id"), |
| 115 | a("get_release_by_tag", Op::About(AboutOp::GetReleaseByTag), "The release of a tag"), |
| 116 | a("create_release", Op::About(AboutOp::CreateRelease), "Publish a release of a tag, making the tag if needed"), |
| 117 | a("update_release", Op::About(AboutOp::UpdateRelease), "Change a release's title, notes, draft or prerelease"), |
| 118 | a("delete_release", Op::About(AboutOp::DeleteRelease), "Delete a release; its tag stays"), |
| 119 | a("rename_branch", Op::RenameBranch, "Rename a branch"), |
| 120 | a("create_branch", Op::CreateBranch, "Make a branch at a branch, tag or commit"), |
| 121 | a("delete_branch", Op::DeleteBranch, "Delete a branch; make it again at its commit to restore it"), |
| 122 | a("rename", Op::RenameRepo, "Rename it; old addresses redirect"), |
| 123 | a("transfer", Op::TransferRepo, "Move it to another workspace you own"), |
| 124 | a("fork", Op::ForkRepo, "Fork it into a workspace: its code and description, linked to it"), |
| 125 | a("forks", Op::ListForks, "Its forks you can see"), |
| 126 | a("sync_fork", Op::SyncFork, "Bring a fork's branch up to date with its parent"), |
| 127 | a("detach_fork", Op::DetachFork, "Make a fork an ordinary repository, no longer linked to its parent"), |
| 128 | a("archive", Op::ArchiveRepo, "Make it read-only"), |
| 129 | a("unarchive", Op::UnarchiveRepo, "Make it writable again"), |
| 130 | a("set_visibility", Op::SetRepoVisibility, "Make it public or private"), |
| 131 | a("delete", Op::DeleteRepo, "Delete it; restorable for 30 days"), |
| 132 | a("list_deleted", Op::ListDeletedRepos, "A workspace's deleted repositories"), |
| 133 | a("restore", Op::RestoreRepo, "Restore a deleted one"), |
| 134 | a("purge", Op::PurgeRepo, "Remove a deleted one for good"), |
| 135 | a("why", Op::Why, "Why a line is the way it is: commit, pull request, work item, decisions, session"), |
| 136 | a("security_alerts", Op::ListSecurityAlerts, "Secret and dependency alerts, filtered by state"), |
| 137 | a("dismiss_alert", Op::DismissSecurityAlert, "Dismiss an alert with a reason"), |
| 138 | a("reopen_alert", Op::ReopenSecurityAlert, "Reopen a dismissed alert"), |
| 139 | ], |
| 140 | }, |
| 141 | Tool { |
| 142 | name: "work_item", |
| 143 | title: "Work items", |
| 144 | description: "Work items: any tracked work of a workspace (a feature, a bug, a chore), numbered in the workspace with its new pull requests, and linked to the repositories it concerns: its origin (where it was filed), its targets (where the work is meant to land) and those it touched. Name one by `workspace` and `number`; `repo` alone names the workspace too (and on `list` filters, on `create` is the origin). To pick up work, `next` gives the work item to take next from the workspace's plan (Now, then Next); `get_plan` reads the plan and `plan` moves one in it. Before working on one, `work` gives everything about it (definition of done, each repository with its pull requests and whether the work landed there, what is missing, suggested targets, who is on it, what it waits on); `claim` says you are on it (advisory and expiring, never a lock), `release` or `handoff` when you stop. `link` a repository as a target to say the work must land there too. `update` with blocked_by sets the work items that must land first. `attach` uploads an image (a screenshot) whose markdown goes in a body or a comment.", |
| 145 | default_action: None, |
| 146 | actions: &[ |
| 147 | a("list", Op::ListWorkItems, "A workspace's work items, newest first; by state, label, milestone, assignee, or a repository linked to them; with horizon, one horizon of the plan in its order, at most limit"), |
| 148 | a("get", Op::GetWorkItem, "One work item with its repositories, comments and pull requests"), |
| 149 | a("create", Op::OpenWorkItem, "Open a work item, filed from repo or in the workspace, with targets"), |
| 150 | a("update", Op::UpdateWorkItem, "Change title, body, labels, milestone, assignees or blocked_by"), |
| 151 | a("close", Op::CloseWorkItem, "Close it without a pull request; commit (with repo) names the default-branch commit that did it"), |
| 152 | a("reopen", Op::ReopenWorkItem, "Reopen it"), |
| 153 | a("next", Op::NextWorkItem, "The work item to take next, for you: the first in Now nobody is on, else the top of Next, never one blocked, claimed or assigned to someone else; repo narrows it to one repository. Picking up work? Call this, then claim what it gives"), |
| 154 | a("get_plan", Op::GetPlan, "The workspace's plan: Now in full with its cap, the top 10 of Next (all for every one), and how many are in Triage, Later (by repository) and Set aside; repo narrows it"), |
| 155 | a("plan", Op::PlanWorkItem, "Move it in the plan: horizon (triage, now, next, later, set_aside), at most one of before or after (another's number) or top; set appetite (small, medium, large), budget_usd or urgent (first in Now); null clears appetite or budget_usd. Triage role; Now and urgent need the Write role"), |
| 156 | a("links", Op::ListWorkItemLinks, "The repositories it is linked to, with roles and where it landed"), |
| 157 | a("link", Op::LinkWorkItem, "Link a repository as a target (or touched)"), |
| 158 | a("unlink", Op::UnlinkWorkItem, "Unlink a repository it no longer concerns"), |
| 159 | a("labels", Op::ListWorkItemLabels, "The labels it carries"), |
| 160 | a("add_labels", Op::AddWorkItemLabels, "Add labels to it"), |
| 161 | a("set_labels", Op::SetWorkItemLabels, "Replace its labels"), |
| 162 | a("remove_labels", Op::RemoveWorkItemLabels, "Take labels off it"), |
| 163 | a("comment", Op::AddWorkItemComment, "Comment on it"), |
| 164 | a("edit_comment", Op::EditWorkItemComment, "Change a comment's text: your own, or any with the Maintain role"), |
| 165 | a("delete_comment", Op::DeleteWorkItemComment, "Delete a comment: your own, or any with the Maintain role"), |
| 166 | a("react", Op::ReactToWorkItem, "React with an emoji to it, or with comment_id to one of its comments; remove takes it back"), |
| 167 | a("decisions", Op::ListWorkItemDecisions, "Decision records on it and its pull requests"), |
| 168 | a("attach", Op::UploadWorkItemAttachment, "Upload an image (base64, PNG/JPEG/GIF/WebP, at most 10 MB; keep it small over MCP) for its markdown, to paste into its body or a comment"), |
| 169 | a("import", Op::ImportWorkItems, "Open a work item from a Jira, Linear or Sentry item"), |
| 170 | a("resolve", Op::ResolveRef, "What #N names in a workspace, or in repo: a work item or a pull request"), |
| 171 | a("work", Op::Coordination(CoordinationOp::GetWork), "Everything to pick it up: done means, repositories and what landed, missing targets, suggested targets, claims, sessions, pull requests, blockers, decisions"), |
| 172 | a("claim", Op::Coordination(CoordinationOp::ClaimWorkItem), "Say you are working on it; lists who else is, and what it is blocked by. Without number, title opens one and claims it"), |
| 173 | a("release", Op::Coordination(CoordinationOp::ReleaseClaim), "Stop working on it"), |
| 174 | a("handoff", Op::Coordination(CoordinationOp::HandOffWorkItem), "Hand it off, to someone or anyone, with a note on where it stands"), |
| 175 | a("list_claims", Op::Coordination(CoordinationOp::ListClaims), "Claims on a workspace's work items: who is working on what"), |
| 176 | ], |
| 177 | }, |
| 178 | Tool { |
| 179 | name: "pull_request", |
| 180 | title: "Pull requests", |
| 181 | description: "Pull requests: start a change for a work item (`item`, its number in the workspace), record your session, comment, mark it ready, ask people and teams to review, review, update its branch, and merge (by merge, squash, rebase or fast_forward) now or with auto-merge. Read `overlaps` and `behind` on `get` before going far, and `code_owners` for whose approval it needs.", |
| 182 | default_action: None, |
| 183 | actions: &[ |
| 184 | a("list", Op::ListPullRequests, "Pull requests on a repository, newest first"), |
| 185 | a("get", Op::GetPullRequest, "Status, checks and required checks, reviews, overlaps, whether it is behind"), |
| 186 | a("changes", Op::GetPullRequestChanges, "Files and line-by-line diff"), |
| 187 | a("create", Op::CreatePullRequest, "Start a draft with its own fork to push to, or open one from a pushed branch"), |
| 188 | a("update", Op::UpdatePullRequest, "Change its base branch, labels, milestone, assignees or reviewers"), |
| 189 | a("record_session", Op::RecordSession, "Append user-facing decision summaries and tool activity to its session"), |
| 190 | a("read_session", Op::ReadSession, "Its recorded session"), |
| 191 | a("record_decision", Op::RecordDecision, "Record why: a proposal, claim, fix or note, kept as claimed"), |
| 192 | a("list_decisions", Op::ListDecisions, "Decision records on a pull request"), |
| 193 | a("comment", Op::AddComment, "Comment on it; path and line for one line of the change"), |
| 194 | a("edit_comment", Op::EditComment, "Change a comment's text: your own, or any with the Maintain role"), |
| 195 | a("delete_comment", Op::DeleteComment, "Delete a comment: your own, or any with the Maintain role"), |
| 196 | a("react", Op::React, "React with an emoji to it, or with comment_id to one of its comments; remove takes it back"), |
| 197 | a("attach", Op::UploadAttachment, "Upload an image (base64, PNG/JPEG/GIF/WebP, at most 10 MB; keep it small over MCP) for its markdown, to paste into its body, its summary or a comment"), |
| 198 | a("ready", Op::MarkPullRequestReady, "Mark a draft ready, with a summary"), |
| 199 | a("draft", Op::ConvertPullRequestToDraft, "Turn it back into a draft"), |
| 200 | a("request_reviewers", Op::RequestReviewers, "Ask people or teams to review it"), |
| 201 | a("remove_requested_reviewers", Op::RemoveRequestedReviewers, "Stop asking people or teams to review it"), |
| 202 | a("review", Op::ReviewPullRequest, "Approve or request changes"), |
| 203 | a("close", Op::ClosePullRequest, "Close without merging"), |
| 204 | a("reopen", Op::ReopenPullRequest, "Reopen a closed one"), |
| 205 | a("merge", Op::MergePullRequest, "Land it (merge, squash, rebase or fast_forward), or join the merge queue"), |
| 206 | a("merge_options", Op::GetPullRequestMergeOptions, "How it may merge now: methods, default messages, whether it is behind"), |
| 207 | a("update_branch", Op::UpdatePullRequestBranch, "Bring its branch up to date with its base, by merge or rebase"), |
| 208 | a("enable_auto_merge", Op::EnablePullRequestAutoMerge, "Merge it on its own once its checks, reviews and rules allow"), |
| 209 | a("disable_auto_merge", Op::DisablePullRequestAutoMerge, "Turn its auto-merge off"), |
| 210 | a("delete_branch", Op::DeletePullRequestHeadBranch, "Delete a merged or closed one's branch; restorable"), |
| 211 | a("restore_branch", Op::RestorePullRequestHeadBranch, "Make its deleted branch again at its head"), |
| 212 | a("merge_queue", Op::GetMergeQueue, "The repository's merge queue"), |
| 213 | ], |
| 214 | }, |
| 215 | Tool { |
| 216 | name: "session", |
| 217 | title: "Sessions", |
| 218 | description: "Your harness session on a repository, so others see who is working on what: `start` once (idempotent on harness_session_id; a subagent starts its own with parent_id), `update` as a heartbeat or to attach a work item, pull request, branch or head commit, `record` user-facing decisions, tool calls, skills used and what it touched (idempotent on key), `end` when done with what it reported. `list` with an item, or a path, shows who else (sibling subagents too) is on the same work; `list` with a `workspace` shows everything cooking across it: people's harnesses, sessions started on g1t, g1t's agent and what was recorded on pull requests. `dispatch` starts work on a work item in a session on the person's own Claude. A session goes idle after 15 minutes without a heartbeat and ends after 30 minutes; a heartbeat brings it back.", |
| 219 | default_action: None, |
| 220 | actions: &[ |
| 221 | a("start", Op::Coordination(CoordinationOp::StartSession), "Start one, or get the one started with this harness_session_id"), |
| 222 | a("update", Op::Coordination(CoordinationOp::UpdateSession), "Heartbeat; or attach a work item, pull request, branch, head commit or title"), |
| 223 | a("record", Op::Coordination(CoordinationOp::RecordSessionEntries), "Record entries and acknowledge exact coordination update IDs after considering them; entry keys make retries idempotent"), |
| 224 | a("end", Op::Coordination(CoordinationOp::EndSession), "End it"), |
| 225 | a("get", Op::Coordination(CoordinationOp::GetSession), "One session, entries and pending coordination updates (reading never acknowledges)"), |
| 226 | a("list", Op::Coordination(CoordinationOp::ListSessions), "A repository's sessions: active, idle or ended, by work item, pull request or file touched; with subagents, each tree whole. With workspace instead: what is cooking across it, every kind of session, with its merge queues and what landed"), |
| 227 | a("dispatch", Op::Coordination(CoordinationOp::StartAgentSession), "Start work on a work item in a session on the person's own Claude (Managed Agents with the workspace's Anthropic key), or get a Claude Code hand-off"), |
| 228 | ], |
| 229 | }, |
| 230 | Tool { |
| 231 | name: "workflow", |
| 232 | title: "Workflows", |
| 233 | description: "GitHub Actions workflows from .g1t/workflows: their runs, jobs and logs, and running, cancelling or rerunning them. Runs' artifacts: listing, a download link, deleting, and how long they are kept. The repository's actions/cache entries: listing them, what they hold against its 10 GiB, and deleting them. Deployments wherever they run (reported from any CI, made by jobs with an `environment:`, or built on g1t.page), their statuses and environments, and reporting your own; environments' protection rules, approving or rejecting the jobs they hold, approving a pull request's run from outside, the token's default permissions, repository dispatch, and the workflows a workspace runs in its repositories without a file in them. Checks on commits: statuses, check runs (a g1t Actions job is one) and check suites, to read where a commit stands or report on it from CI or an integration. Also the self-hosted runners they run on: a workspace's (`workspace`) or a repository's own (`repo`), and their groups.", |
| 234 | default_action: None, |
| 235 | actions: &[ |
| 236 | a("list", Op::ListWorkflows, "Workflows on the default branch"), |
| 237 | a("get", Op::GetWorkflow, "One workflow by id, file or name, with its file on a branch or tag"), |
| 238 | a("list_runs", Op::ListWorkflowRuns, "Runs, newest first"), |
| 239 | a("get_run", Op::GetWorkflowRun, "One run with its jobs and steps; an earlier attempt with attempt"), |
| 240 | a("job_logs", Op::GetJobLogs, "A job's log after a sequence number, or its last lines with tail (why it failed)"), |
| 241 | a("dispatch", Op::DispatchWorkflow, "Run a workflow_dispatch workflow"), |
| 242 | a("cancel", Op::CancelWorkflowRun, "Cancel a run, letting its jobs clean up; force stops them outright"), |
| 243 | a("rerun", Op::RerunWorkflowRun, "Run a finished run again: all, failed_only, or one job; debug for debug logging"), |
| 244 | a("update", Op::UpdateWorkflow, "Turn a workflow on or off"), |
| 245 | a("list_artifacts", Op::Artifacts(ArtifactsOp::ListArtifacts), "A repository's artifacts, newest first; or a run's with run_artifacts"), |
| 246 | a("run_artifacts", Op::Artifacts(ArtifactsOp::ListRunArtifacts), "One run's artifacts"), |
| 247 | a("get_artifact", Op::Artifacts(ArtifactsOp::GetArtifact), "One artifact: size, digest, expiry, run"), |
| 248 | a("download_artifact", Op::Artifacts(ArtifactsOp::DownloadArtifact), "A 10-minute link to an artifact's zip"), |
| 249 | a("delete_artifact", Op::Artifacts(ArtifactsOp::DeleteArtifact), "Delete an artifact before it expires"), |
| 250 | a("artifact_retention", Op::Artifacts(ArtifactsOp::GetArtifactRetention), "Days the repository keeps artifacts"), |
| 251 | a("set_artifact_retention", Op::Artifacts(ArtifactsOp::SetArtifactRetention), "Change the days the repository keeps artifacts"), |
| 252 | a("list_caches", Op::Caches(CachesOp::ListCaches), "The repository's actions/cache entries: by key prefix or ref, largest or least used first"), |
| 253 | a("cache_usage", Op::Caches(CachesOp::GetCacheUsage), "What the repository's cache entries hold, against its 10 GiB"), |
| 254 | a("delete_caches", Op::Caches(CachesOp::DeleteCachesByKey), "Delete the cache entries with a key, on every ref or one"), |
| 255 | a("delete_cache", Op::Caches(CachesOp::DeleteCache), "Delete one cache entry by its id"), |
| 256 | a("combined_status", Op::Checks(ChecksOp::GetCombinedStatus), "A commit's statuses and the state they add up to"), |
| 257 | a("list_statuses", Op::Checks(ChecksOp::ListCommitStatuses), "A commit's statuses, newest first"), |
| 258 | a("set_status", Op::Checks(ChecksOp::CreateCommitStatus), "Set a status on a commit"), |
| 259 | a("list_check_runs", Op::Checks(ChecksOp::ListCheckRunsForRef), "A commit's check runs, g1t Actions jobs included"), |
| 260 | a("get_check_run", Op::Checks(ChecksOp::GetCheckRun), "One check run with its report"), |
| 261 | a("check_run_annotations", Op::Checks(ChecksOp::ListCheckRunAnnotations), "What a check run says about lines of files"), |
| 262 | a("create_check_run", Op::Checks(ChecksOp::CreateCheckRun), "Report a check run on a commit"), |
| 263 | a("update_check_run", Op::Checks(ChecksOp::UpdateCheckRun), "Move a check run on, complete it, add annotations"), |
| 264 | a("rerequest_check_run", Op::Checks(ChecksOp::RerequestCheckRun), "Ask for a check run to run again"), |
| 265 | a("list_check_suites", Op::Checks(ChecksOp::ListCheckSuitesForRef), "A commit's check suites, one per reporter or workflow run"), |
| 266 | a("get_check_suite", Op::Checks(ChecksOp::GetCheckSuite), "One check suite"), |
| 267 | a("rerequest_check_suite", Op::Checks(ChecksOp::RerequestCheckSuite), "Ask for a check suite to run again"), |
| 268 | a("list_deployments", Op::Deployments(DeploymentsOp::ListDeployments), "Deployments wherever they run, newest first, filtered"), |
| 269 | a("get_deployment", Op::Deployments(DeploymentsOp::GetDeployment), "One deployment with every status it has had"), |
| 270 | a("create_deployment", Op::Deployments(DeploymentsOp::CreateDeployment), "Report a deployment of a ref to an environment"), |
| 271 | a("deployment_statuses", Op::Deployments(DeploymentsOp::ListDeploymentStatuses), "A deployment's statuses, newest first"), |
| 272 | a("create_deployment_status", Op::Deployments(DeploymentsOp::CreateDeploymentStatus), "Report where a deployment is: in_progress, success, failure"), |
| 273 | a("list_environments", Op::Deployments(DeploymentsOp::ListEnvironments), "Environments with their current and latest deployments"), |
| 274 | a("get_environment", Op::Deployments(DeploymentsOp::GetEnvironment), "One environment by name, with its protection rules"), |
| 275 | a("start_deployment_build", Op::Deployments(DeploymentsOp::StartDeploymentBuild), "From a workflow job: open a g1t.page build it runs itself"), |
| 276 | a("get_deployment_settings", Op::Deployments(DeploymentsOp::GetDeploymentSettings), "A project's g1t.page settings: whether it deploys, production's address, how it builds"), |
| 277 | a("update_deployment_settings", Op::Deployments(DeploymentsOp::UpdateDeploymentSettings), "Turn a project's g1t.page deployments on (enabled true) or off, or change how it builds"), |
| 278 | a("update_environment", Op::Protection(ProtectionOp::UpdateEnvironment), "Set an environment's reviewers, wait timer and branches"), |
| 279 | a("delete_environment", Op::Protection(ProtectionOp::DeleteEnvironment), "Remove an environment's protection rules"), |
| 280 | a("pending_deployments", Op::Protection(ProtectionOp::GetPendingDeployments), "The environments holding a run's jobs"), |
| 281 | a("review_deployments", Op::Protection(ProtectionOp::ReviewPendingDeployments), "Approve or reject a run's jobs for its environments"), |
| 282 | a("approve_run", Op::Protection(ProtectionOp::ApproveWorkflowRun), "Let a run of a pull request from outside start"), |
| 283 | a("get_permissions", Op::Protection(ProtectionOp::GetWorkflowPermissions), "What a job's token gets without `permissions:`"), |
| 284 | a("set_permissions", Op::Protection(ProtectionOp::SetWorkflowPermissions), "Set it: read or write"), |
| 285 | a("get_approval_policy", Op::Protection(ProtectionOp::GetForkPrApproval), "Which pull requests' runs wait for approval"), |
| 286 | a("set_approval_policy", Op::Protection(ProtectionOp::SetForkPrApproval), "Set which pull requests' runs wait for approval"), |
| 287 | a("get_access", Op::Protection(ProtectionOp::GetActionsAccess), "Which repositories may use this one's actions and workflows"), |
| 288 | a("set_access", Op::Protection(ProtectionOp::SetActionsAccess), "Let the workspace's private repositories use them, or not"), |
| 289 | a("get_enabled", Op::Protection(ProtectionOp::GetActionsPermissions), "Whether its workflows run at all; off for a fork until turned on"), |
| 290 | a("set_enabled", Op::Protection(ProtectionOp::SetActionsPermissions), "Turn its workflows on or off"), |
| 291 | a("repository_dispatch", Op::Protection(ProtectionOp::CreateRepositoryDispatch), "Start repository_dispatch workflows with an event"), |
| 292 | a("get_workspace_permissions", Op::Protection(ProtectionOp::GetWorkspaceWorkflowPermissions), "A workspace's default and maximum token permissions"), |
| 293 | a("set_workspace_permissions", Op::Protection(ProtectionOp::SetWorkspaceWorkflowPermissions), "Set them, and whether jobs may open pull requests"), |
| 294 | a("list_managed_workflows", Op::Protection(ProtectionOp::ListWorkspaceManagedWorkflows), "The workflows a workspace runs in its repositories"), |
| 295 | a("add_managed_workflow", Op::Protection(ProtectionOp::CreateWorkspaceManagedWorkflow), "Run a workflow in the workspace's repositories, required or default"), |
| 296 | a("update_managed_workflow", Op::Protection(ProtectionOp::UpdateWorkspaceManagedWorkflow), "Change one's repositories or mode, or copy its source again"), |
| 297 | a("remove_managed_workflow", Op::Protection(ProtectionOp::DeleteWorkspaceManagedWorkflow), "Take one out of the workspace's repositories"), |
| 298 | a("list_runners", Op::ListRunners, "Self-hosted runners, with status, labels and what each is doing"), |
| 299 | a("create_runner_token", Op::CreateRunnerRegistrationToken, "A one-hour token for g1t-runner register"), |
| 300 | a("remove_runner", Op::RemoveRunner, "Remove a self-hosted runner"), |
| 301 | a("list_runner_groups", Op::ListRunnerGroups, "A workspace's runner groups"), |
| 302 | a("create_runner_group", Op::CreateRunnerGroup, "Make a group, for some repositories"), |
| 303 | a("update_runner_group", Op::UpdateRunnerGroup, "Rename a group or change its repositories"), |
| 304 | a("delete_runner_group", Op::DeleteRunnerGroup, "Delete a group; its runners join the default"), |
| 305 | a("get_runner_settings", Op::GetRunnerSettings, "Where checks and the merge queue run; whether forks may use runners"), |
| 306 | a("update_runner_settings", Op::UpdateRunnerSettings, "Change them"), |
| 307 | ], |
| 308 | }, |
| 309 | Tool { |
| 310 | name: "observability", |
| 311 | title: "Observability", |
| 312 | description: "What a project's running software did in production, to debug it: its requests, logs, traces, grouped errors and metrics, from its apps on g1t.page and from OpenTelemetry sent from anywhere. Name the project by workspace and project slug. Start with overview (error rate, latency, the routes and the deployment a regression began with) or errors, then follow a request or trace_id to its logs and spans. Times are RFC 3339 or Unix milliseconds; the last 24 hours unless you say. Needs a role of your own on the project's repository; resolving errors, Triage.", |
| 313 | default_action: None, |
| 314 | actions: &[ |
| 315 | a("overview", Op::Telemetry(TelemetryOp::GetOverview), "Requests, errors, latency and CPU over a period, by route, deployment, service and region, against the period before"), |
| 316 | a("requests", Op::Telemetry(TelemetryOp::ListRequests), "Requests answered, newest first: q, status (5xx, 404), errors_only, route, min_duration_ms"), |
| 317 | a("request", Op::Telemetry(TelemetryOp::GetRequest), "One request with every log line it wrote"), |
| 318 | a("logs", Op::Telemetry(TelemetryOp::ListLogs), "Search a project's logs: words or a phrase in q, level (error,warn), trace_id, request_id"), |
| 319 | a("traces", Op::Telemetry(TelemetryOp::ListTraces), "Traces, newest first: q, errors_only, min_duration_ms"), |
| 320 | a("trace", Op::Telemetry(TelemetryOp::GetTrace), "One trace: every span, with its timing, status and attributes, and its logs"), |
| 321 | a("errors", Op::Telemetry(TelemetryOp::ListErrors), "Errors grouped by exception, most recent first, with the deployment that brought each in"), |
| 322 | a("update_error", Op::Telemetry(TelemetryOp::UpdateError), "Resolve, ignore or reopen an error group, or link the work item made for it"), |
| 323 | a("metrics", Op::Telemetry(TelemetryOp::ListMetrics), "The metrics the project's software sends"), |
| 324 | a("metric", Op::Telemetry(TelemetryOp::GetMetric), "One metric over time: aggregate (avg, sum, p95), group_by an attribute"), |
| 325 | ], |
| 326 | }, |
| 327 | Tool { |
| 328 | name: "package", |
| 329 | title: "Packages", |
| 330 | description: "A workspace's packages in every registry (container images, npm, Cargo, Maven, NuGet, RubyGems, Composer): their versions and downloads, deleting and restoring them within 30 days, their visibility and repository, who has a role on them, and which repositories' workflows may use them (Manage Actions access). Name one by workspace, package_type and package_name.", |
| 331 | default_action: None, |
| 332 | actions: &[ |
| 333 | a("list", Op::Packages(PackagesOp::ListPackages), "A workspace's packages; state deleted for restorable ones"), |
| 334 | a("get", Op::Packages(PackagesOp::GetPackage), "One package: address, visibility, repository, downloads"), |
| 335 | a("versions", Op::Packages(PackagesOp::ListVersions), "Its versions with tags and downloads; state deleted too"), |
| 336 | a("get_version", Op::Packages(PackagesOp::GetVersion), "One version by id, version, digest or tag"), |
| 337 | a("update", Op::Packages(PackagesOp::UpdatePackage), "Set visibility, or inherit_access for a linked one"), |
| 338 | a("link", Op::Packages(PackagesOp::LinkPackage), "Link it to a repository of its workspace"), |
| 339 | a("unlink", Op::Packages(PackagesOp::UnlinkPackage), "Unlink it: the workspace's, private"), |
| 340 | a("access", Op::Packages(PackagesOp::ListAccess), "People and teams with a role on it"), |
| 341 | a("set_access", Op::Packages(PackagesOp::SetAccess), "Give a person or team read, write or admin"), |
| 342 | a("remove_access", Op::Packages(PackagesOp::RemoveAccess), "Take a person's or team's role away"), |
| 343 | a("actions_access", Op::Packages(PackagesOp::ListActionsAccess), "Repositories whose workflows may use it"), |
| 344 | a("set_actions_access", Op::Packages(PackagesOp::SetActionsAccess), "Let a repository's workflows read or write it"), |
| 345 | a("remove_actions_access", Op::Packages(PackagesOp::RemoveActionsAccess), "Stop a repository's workflows using it"), |
| 346 | a("delete", Op::Packages(PackagesOp::DeletePackage), "Delete it; restorable for 30 days"), |
| 347 | a("restore", Op::Packages(PackagesOp::RestorePackage), "Restore a deleted package"), |
| 348 | a("delete_version", Op::Packages(PackagesOp::DeleteVersion), "Delete a version; restorable for 30 days"), |
| 349 | a("restore_version", Op::Packages(PackagesOp::RestoreVersion), "Restore a deleted version"), |
| 350 | ], |
| 351 | }, |
| 352 | Tool { |
| 353 | name: "secret", |
| 354 | title: "Secrets and variables", |
| 355 | description: "A repository's or workspace's secrets and variables, read by workflows and deployments. Secret values are never returned.", |
| 356 | default_action: None, |
| 357 | actions: &[ |
| 358 | a("list_secrets", Op::ListActionsSecrets, "Secrets, without values"), |
| 359 | a("set_secret", Op::SetActionsSecret, "Add or change a secret"), |
| 360 | a("delete_secret", Op::DeleteActionsSecret, "Remove a secret"), |
| 361 | a("list_variables", Op::ListActionsVariables, "Variables, with values"), |
| 362 | a("set_variable", Op::SetActionsVariable, "Add or change a variable"), |
| 363 | a("delete_variable", Op::DeleteActionsVariable, "Remove a variable"), |
| 364 | ], |
| 365 | }, |
| 366 | Tool { |
| 367 | name: "webhook", |
| 368 | title: "Webhooks", |
| 369 | description: "HTTPS addresses sent signed events as they happen, for a repository or a whole workspace.", |
| 370 | default_action: None, |
| 371 | actions: &[ |
| 372 | a("list", Op::ListWebhooks, "Webhooks, without secrets"), |
| 373 | a("create", Op::CreateWebhook, "Register one; a ping is sent"), |
| 374 | a("update", Op::UpdateWebhook, "Change address, events or active"), |
| 375 | a("delete", Op::DeleteWebhook, "Remove one"), |
| 376 | a("ping", Op::PingWebhook, "Send a ping"), |
| 377 | a("list_deliveries", Op::ListWebhookDeliveries, "Latest deliveries"), |
| 378 | a("redeliver", Op::RedeliverWebhook, "Send a delivery again"), |
| 379 | ], |
| 380 | }, |
| 381 | Tool { |
| 382 | name: "access", |
| 383 | title: "Who has access", |
| 384 | description: "Who has access to a repository and with which role (read, triage, write, maintain, admin), outside collaborators, a workspace's base permission, and a repository's deploy keys.", |
| 385 | default_action: None, |
| 386 | actions: &[ |
| 387 | a("list_collaborators", Op::ListCollaborators, "Everyone with a role, and pending invitations"), |
| 388 | a("get_permission", Op::GetCollaboratorPermission, "One person's role and capabilities"), |
| 389 | a("add_collaborator", Op::AddCollaborator, "Give someone a role, by username or email"), |
| 390 | a("update_collaborator", Op::UpdateCollaborator, "Change a direct role"), |
| 391 | a("remove_collaborator", Op::RemoveCollaborator, "Take away a direct role"), |
| 392 | a("list_invitations", Op::ListRepoInvitations, "Pending invitations to a repository"), |
| 393 | a("revoke_invitation", Op::RevokeRepoInvitation, "Withdraw one"), |
| 394 | a("set_base_permission", Op::SetBasePermission, "What every member gets on each repository"), |
| 395 | a("list_outside_collaborators", Op::ListOutsideCollaborators, "People with roles who are not members"), |
| 396 | a("list_deploy_keys", Op::DeployKeys(DeployKeysOp::ListDeployKeys), "SSH keys that reach this one repository"), |
| 397 | a("get_deploy_key", Op::DeployKeys(DeployKeysOp::GetDeployKey), "One deploy key, by id"), |
| 398 | a("add_deploy_key", Op::DeployKeys(DeployKeysOp::CreateDeployKey), "Add one; read-only unless read_only is false"), |
| 399 | a("remove_deploy_key", Op::DeployKeys(DeployKeysOp::DeleteDeployKey), "Delete one"), |
| 400 | ], |
| 401 | }, |
| 402 | Tool { |
| 403 | name: "team", |
| 404 | title: "Teams", |
| 405 | description: "Teams: groups of a workspace's members, given roles on repositories together, mentioned as @workspace/team and asked to review together. Name one by `workspace` and its slug (`team`). Any member may create a team; the workspace's owners and the team's maintainers manage it. A secret team is seen only by its people and the owners.", |
| 406 | default_action: None, |
| 407 | actions: &[ |
| 408 | a("list", Op::ListTeams, "A workspace's teams you can see"), |
| 409 | a("get", Op::GetTeam, "One team"), |
| 410 | a("create", Op::CreateTeam, "Create a team; you become its maintainer"), |
| 411 | a("update", Op::UpdateTeam, "Change its name, slug, description, visibility, parent or notifications"), |
| 412 | a("delete", Op::DeleteTeam, "Delete it; its child teams move up"), |
| 413 | a("list_members", Op::ListTeamMembers, "Its people and their roles, child teams' with include_child_teams"), |
| 414 | a("set_member", Op::SetTeamMember, "Add a member of the workspace, or change their role"), |
| 415 | a("remove_member", Op::RemoveTeamMember, "Take someone out of it"), |
| 416 | a("list_child_teams", Op::ListChildTeams, "The teams nested under it"), |
| 417 | a("list_repos", Op::ListTeamRepos, "The repositories it has a role on"), |
| 418 | a("set_repo", Op::SetTeamRepo, "Give it a role on a repository"), |
| 419 | a("remove_repo", Op::RemoveTeamRepo, "Take its role on a repository away"), |
| 420 | a("set_review_assignment", Op::SetTeamReviewAssignment, "Whom it picks when asked to review"), |
| 421 | a("list_user_teams", Op::ListUserTeams, "The teams someone is in"), |
| 422 | ], |
| 423 | }, |
| 424 | Tool { |
| 425 | name: "workspace", |
| 426 | title: "Workspaces", |
| 427 | description: "Workspaces own repositories (g1t.sh/{workspace}/{repo}) and work items (g1t.sh/{workspace}/-/work): read what happened across its repositories (`activity`: what merged, shipped and deployed, by whom, over a span), create, update or delete one, invite members, manage its labels and milestones (which its work items and pull requests carry) and how many work items its plan's Now holds, connect integrations, set rulesets that hold across its repositories, read and change its projects (what each is, where it runs, its links), and keep your own pinned projects at the top of its sidebar.", |
| 428 | default_action: None, |
| 429 | actions: &[ |
| 430 | a("get", Op::GetWorkspace, "A workspace's details and settings"), |
| 431 | a("create", Op::CreateWorkspace, "Create a workspace"), |
| 432 | a("delete", Op::DeleteWorkspace, "Delete a workspace and everything in it (support can restore it for 30 days)"), |
| 433 | a("update", Op::UpdateWorkspace, "Change its name, description, base permission, who may create teams, member privileges or the two-factor requirement"), |
| 434 | a("list_members", Op::ListMembers, "Its members, owners first, with their roles"), |
| 435 | a("update_member", Op::UpdateMember, "Make someone an owner or a member, billing manager or security manager"), |
| 436 | a("remove_member", Op::RemoveMember, "Remove someone from it"), |
| 437 | a("transfer_ownership", Op::TransferOwnership, "Hand it to another member: they become an owner, you a member"), |
| 438 | a("leave", Op::LeaveWorkspace, "Leave it yourself"), |
| 439 | a("list_invites", Op::ListWorkspaceInvites, "Its invites"), |
| 440 | a("invite_member", Op::InviteMember, "Invite someone by username or email address"), |
| 441 | a("revoke_invite", Op::RevokeWorkspaceInvite, "Revoke a pending invite"), |
| 442 | a("list_labels", Op::ListLabels, "Its labels, with colors and how many work items and pull requests carry each"), |
| 443 | a("create_label", Op::CreateLabel, "Create a label"), |
| 444 | a("update_label", Op::UpdateLabel, "Rename a label or change its color or description"), |
| 445 | a("delete_label", Op::DeleteLabel, "Delete a label, from everything that carries it"), |
| 446 | a("add_default_labels", Op::AddDefaultLabels, "Add the default labels it is missing"), |
| 447 | a("list_milestones", Op::ListMilestones, "Its milestones, with progress and due dates"), |
| 448 | a("get_milestone", Op::GetMilestone, "One milestone with its work items and pull requests"), |
| 449 | a("create_milestone", Op::CreateMilestone, "Create a milestone"), |
| 450 | a("update_milestone", Op::UpdateMilestone, "Change a milestone's title, description, due date or state"), |
| 451 | a("delete_milestone", Op::DeleteMilestone, "Delete a milestone"), |
| 452 | a("configure_plan", Op::ConfigurePlan, "Set now_cap, how many work items its plan's Now holds before it says it is over (1 to 50)"), |
| 453 | a("list_integrations", Op::ListIntegrations, "Alert sources and issue trackers"), |
| 454 | a("connect_integration", Op::ConnectIntegration, "Connect one"), |
| 455 | a("update_integration", Op::UpdateIntegration, "Change one: rotate its key or its settings"), |
| 456 | a("disconnect_integration", Op::DisconnectIntegration, "Remove one"), |
| 457 | a("test_integration", Op::TestIntegration, "Check its credentials"), |
| 458 | a("activity", Op::GetWorkspaceActivity, "What happened across its repositories over a span: merged pull requests, releases, deployments, pushes, work items; what shipped"), |
| 459 | a("list_projects", Op::ListProjects, "Its projects you can see: what each is, where it runs, its links"), |
| 460 | a("get_project", Op::GetProject, "One project"), |
| 461 | a("update_project", Op::UpdateProject, "Change a project's name, description, kind, where it runs or its links"), |
| 462 | a("list_pinned_projects", Op::ListPinnedProjects, "Your pinned projects in it, in your order"), |
| 463 | a("pin_project", Op::PinProject, "Pin a project, at a position or the end"), |
| 464 | a("unpin_project", Op::UnpinProject, "Unpin a project"), |
| 465 | a("reorder_pinned_projects", Op::ReorderPinnedProjects, "Put your pins in a new order"), |
| 466 | a("list_rulesets", Op::Rules(RulesOp::ListWorkspaceRulesets), "Its rulesets, which hold across its repositories"), |
| 467 | a("get_ruleset", Op::Rules(RulesOp::GetWorkspaceRuleset), "One of its rulesets"), |
| 468 | a("create_ruleset", Op::Rules(RulesOp::CreateWorkspaceRuleset), "Create a ruleset for some or all of its repositories"), |
| 469 | a("update_ruleset", Op::Rules(RulesOp::UpdateWorkspaceRuleset), "Change one of its rulesets"), |
| 470 | a("delete_ruleset", Op::Rules(RulesOp::DeleteWorkspaceRuleset), "Delete one of its rulesets"), |
| 471 | a("rule_evaluations", Op::Rules(RulesOp::ListWorkspaceRuleEvaluations), "How rules judged changes across its repositories"), |
| 472 | a("get_token_policy", Op::Tokens(TokenOp::GetTokenPolicy), "Its rules for personal access tokens"), |
| 473 | a("set_token_policy", Op::Tokens(TokenOp::SetTokenPolicy), "Change them: which tokens reach it, approval, lifetime"), |
| 474 | a("list_member_tokens", Op::Tokens(TokenOp::ListMemberTokens), "Members' personal access tokens that reach it"), |
| 475 | a("list_token_requests", Op::Tokens(TokenOp::ListTokenRequests), "Tokens waiting for approval"), |
| 476 | a("review_token_request", Op::Tokens(TokenOp::ReviewTokenRequest), "Approve or deny one"), |
| 477 | a("revoke_member_token", Op::Tokens(TokenOp::RevokeMemberToken), "Revoke a member's token in it"), |
| 478 | a("get_sso", Op::Sso(SsoOp::GetSso), "Its single sign-on: the provider, whether it is required, who is linked, and where to point the provider"), |
| 479 | a("configure_sso", Op::Sso(SsoOp::ConfigureSso), "Set up or change its single sign-on over OpenID Connect, OAuth 2.0 or SAML"), |
| 480 | a("set_sso_required", Op::Sso(SsoOp::SetSsoRequired), "Require single sign-on of members, or stop"), |
| 481 | a("delete_sso", Op::Sso(SsoOp::DeleteSso), "Remove its single sign-on"), |
| 482 | a("list_sso_identities", Op::Sso(SsoOp::ListSsoIdentities), "The people linked through single sign-on"), |
| 483 | a("unlink_sso_identity", Op::Sso(SsoOp::UnlinkSsoIdentity), "Unlink someone from single sign-on"), |
| 484 | a("enable_scim", Op::Sso(SsoOp::EnableScim), "Turn on SCIM, or make a new SCIM token"), |
| 485 | a("disable_scim", Op::Sso(SsoOp::DisableScim), "Turn off SCIM"), |
| 486 | ], |
| 487 | }, |
| 488 | Tool { |
| 489 | name: "ai", |
| 490 | title: "AI", |
| 491 | description: "A workspace's AI: the AI providers it keeps keys for (frontier labs, model platforms and self-hosted endpoints) and what Ask g1t answers with. Keys are sealed and never returned. g1t hosts no model and bills nothing for it: it runs on the workspace's own account. Members read it; changing it is for owners.", |
| 492 | default_action: Some("list_providers"), |
| 493 | actions: &[ |
| 494 | a("list_providers", Op::ListAiProviders, "Its AI providers, with the models each offered and its last error"), |
| 495 | a("add_provider", Op::AddAiProvider, "Add one with its key, checked as it is saved"), |
| 496 | a("update_provider", Op::UpdateAiProvider, "Change one: rotate its key, its name or its settings"), |
| 497 | a("remove_provider", Op::RemoveAiProvider, "Remove one and its key"), |
| 498 | a("test_provider", Op::TestAiProvider, "Check its key works"), |
| 499 | a("get_ask", Op::GetAskSettings, "What Ask g1t answers with, or why it cannot"), |
| 500 | a("set_ask", Op::SetAskSettings, "Choose the provider and model Ask answers with, Auto, or turn Ask off"), |
| 501 | ], |
| 502 | }, |
| 503 | Tool { |
| 504 | name: "billing", |
| 505 | title: "Billing", |
| 506 | description: "A workspace's billing: its usage by product, project and day, its budget (the monthly spend limit, alerts and whether usage pauses at it) and its invoices. Amounts are whole millionths of a dollar (`_micros`), or cents (`_cents`) where named. Members read it; changing the budget is for owners, as people, and never for a run's token.", |
| 507 | default_action: Some("usage"), |
| 508 | actions: &[ |
| 509 | a("usage", Op::GetUsage, "Usage over a range of days, by product, meter, project and day, and what paid for it"), |
| 510 | a("budget", Op::GetBudget, "The monthly spend limit, what was spent, alerts and whether usage pauses at the limit"), |
| 511 | a("set_budget", Op::SetBudget, "Change the spend limit, alerts, pausing or the alert webhook"), |
| 512 | a("invoices", Op::ListInvoices, "Every invoice, the itemised usage invoices, and the next one so far"), |
| 513 | a("billing_details", Op::GetBillingDetails, "Who invoices are made out to and the payment method on file"), |
| 514 | ], |
| 515 | }, |
| 516 | Tool { |
| 517 | name: "security", |
| 518 | title: "Security", |
| 519 | description: "A repository's security: secret scanning alerts and push protection bypasses, custom secret patterns, code scanning alerts and SARIF uploads, vulnerability alerts, the dependency graph and its SBOM, dependency review, settings, a workspace's overview, security advisories and private vulnerability reports. Findings are shown to those who can change the code only; published advisories to anyone who can see the repository. Give `repo` (owner/name), or `workspace` for lists across one.", |
| 520 | default_action: Some("secret_alerts"), |
| 521 | actions: &[ |
| 522 | a("secret_alerts", Op::Security(SecurityOp::ListSecretAlerts), "Secret scanning alerts; by state, secret_type, validity, bypassed"), |
| 523 | a("secret_alert", Op::Security(SecurityOp::GetSecretAlert), "One secret alert, with where it was found and its bypass requests"), |
| 524 | a("update_secret_alert", Op::Security(SecurityOp::UpdateSecretAlert), "Dismiss a secret alert with a reason, or reopen it"), |
| 525 | a("secret_locations", Op::Security(SecurityOp::ListSecretLocations), "Every file, line and commit a secret is in"), |
| 526 | a("bypass", Op::Security(SecurityOp::BypassPushProtection), "Push past push protection with a reason, or ask to"), |
| 527 | a("check_validity", Op::Security(SecurityOp::CheckSecretValidity), "Ask a secret's issuer whether it still works"), |
| 528 | a("bypass_requests", Op::Security(SecurityOp::ListBypassRequests), "A workspace's push protection bypass requests"), |
| 529 | a("review_bypass", Op::Security(SecurityOp::ReviewBypassRequest), "Approve, deny or cancel a bypass request"), |
| 530 | a("patterns", Op::Security(SecurityOp::ListCustomPatterns), "Custom secret patterns of a repository or workspace"), |
| 531 | a("create_pattern", Op::Security(SecurityOp::CreateCustomPattern), "Create a custom secret pattern, as a draft or published"), |
| 532 | a("update_pattern", Op::Security(SecurityOp::UpdateCustomPattern), "Change, publish or unpublish a custom pattern"), |
| 533 | a("delete_pattern", Op::Security(SecurityOp::DeleteCustomPattern), "Delete a custom pattern"), |
| 534 | a("dry_run_pattern", Op::Security(SecurityOp::DryRunCustomPattern), "Run a pattern over the default branch without saving it"), |
| 535 | a("code_alerts", Op::Security(SecurityOp::ListCodeAlerts), "Code scanning alerts; by state, severity, tool, rule_id"), |
| 536 | a("code_alert", Op::Security(SecurityOp::GetCodeAlert), "One code scanning alert by number"), |
| 537 | a("update_code_alert", Op::Security(SecurityOp::UpdateCodeAlert), "Dismiss a code scanning alert with a reason, or reopen it"), |
| 538 | a("analyses", Op::Security(SecurityOp::ListAnalyses), "Code scanning analyses, newest first"), |
| 539 | a("upload_sarif", Op::Security(SecurityOp::UploadSarif), "Upload a SARIF file, gzipped and base64-encoded"), |
| 540 | a("sarif_upload", Op::Security(SecurityOp::GetSarifUpload), "Whether a SARIF upload was read, and its analyses"), |
| 541 | a("vulnerability_alerts", Op::Security(SecurityOp::ListVulnerabilityAlerts), "Vulnerable dependencies; by state, severity, ecosystem, package"), |
| 542 | a("vulnerability_alert", Op::Security(SecurityOp::GetVulnerabilityAlert), "One vulnerability alert"), |
| 543 | a("update_vulnerability_alert", Op::Security(SecurityOp::UpdateVulnerabilityAlert), "Dismiss a vulnerability alert with a reason, or reopen it"), |
| 544 | a("dependency_graph", Op::Security(SecurityOp::GetDependencyGraph), "Every package the lockfiles resolve, direct or transitive"), |
| 545 | a("sbom", Op::Security(SecurityOp::GetSbom), "The dependency graph as an SPDX 2.3 document"), |
| 546 | a("compare_dependencies", Op::Security(SecurityOp::CompareDependencies), "What changes in dependencies between base...head"), |
| 547 | a("rerun_dependency_review", Op::Security(SecurityOp::RerunDependencyReview), "Run a pull request's Dependency review check again"), |
| 548 | a("settings", Op::Security(SecurityOp::GetSettings), "A repository's security settings"), |
| 549 | a("update_settings", Op::Security(SecurityOp::UpdateSettings), "Change when checks fail and dependency review's policy"), |
| 550 | a("workspace_settings", Op::Security(SecurityOp::GetWorkspaceSettings), "A workspace's delegated bypass and validity checks"), |
| 551 | a("update_workspace_settings", Op::Security(SecurityOp::UpdateWorkspaceSettings), "Turn delegated bypass or validity checks on or off"), |
| 552 | a("overview", Op::Security(SecurityOp::GetOverview), "A workspace's alerts, trends and coverage"), |
| 553 | a("advisories", Op::Security(SecurityOp::ListAdvisories), "A repository's security advisories; by state"), |
| 554 | a("advisory", Op::Security(SecurityOp::GetAdvisory), "One advisory by adv_… or G1TSA-… id"), |
| 555 | a("create_advisory", Op::Security(SecurityOp::CreateAdvisory), "Draft a security advisory"), |
| 556 | a("update_advisory", Op::Security(SecurityOp::UpdateAdvisory), "Change an advisory's fields"), |
| 557 | a("set_advisory_state", Op::Security(SecurityOp::SetAdvisoryState), "Publish or withdraw an advisory"), |
| 558 | a("reports", Op::Security(SecurityOp::ListReports), "Vulnerability reports sent to the maintainers; by state"), |
| 559 | a("report_vulnerability", Op::Security(SecurityOp::ReportVulnerability), "Report a vulnerability privately to a repository's maintainers"), |
| 560 | a("review_report", Op::Security(SecurityOp::ReviewReport), "Accept a report as a draft advisory, or decline it"), |
| 561 | ], |
| 562 | }, |
| 563 | Tool { |
| 564 | name: "notifications", |
| 565 | title: "Notifications", |
| 566 | description: "Your inbox: what needs you, and what you follow. One thread per work item, pull request, workflow or deployment, with why you were told (`reason`): a review asked of you, an assignment, a mention, your work's checks, or what you subscribe to and watch. Mark threads read or done once handled, and choose what you hear of with subscribe, unsubscribe and watch. Your own: a personal token.", |
| 567 | default_action: Some("list"), |
| 568 | actions: &[ |
| 569 | a("list", Op::ListNotifications, "Unread threads, latest first; all, a view, a reason, a repository"), |
| 570 | a("get", Op::GetNotificationThread, "One thread with its recent activity and your subscription"), |
| 571 | a("mark_read", Op::MarkThreadRead, "Mark a thread read, or unread"), |
| 572 | a("mark_all_read", Op::MarkNotificationsRead, "Mark everything read up to a time, or one repository's"), |
| 573 | a("done", Op::MarkThreadDone, "Mark a thread done; new activity brings it back"), |
| 574 | a("save", Op::SaveThread, "Save a thread, or unsave it"), |
| 575 | a("snooze", Op::SnoozeThread, "Snooze a thread until a time, or bring it back"), |
| 576 | a("subscription", Op::GetThreadSubscription, "Your subscription to a work item or pull request"), |
| 577 | a("subscribe", Op::SetThreadSubscription, "Subscribe to a work item or pull request, or ignore it"), |
| 578 | a("unsubscribe", Op::DeleteThreadSubscription, "Unsubscribe until you comment or are mentioned"), |
| 579 | a("watching", Op::GetRepoSubscription, "How you watch a repository"), |
| 580 | a("watch", Op::SetRepoSubscription, "Watch a repository: participating, all, ignore or custom"), |
| 581 | a("unwatch", Op::DeleteRepoSubscription, "Stop watching a repository"), |
| 582 | a("watched", Op::ListWatchedRepos, "Repositories you watch other than the default way"), |
| 583 | ], |
| 584 | }, |
| 585 | Tool { |
| 586 | name: "account", |
| 587 | title: "Your account", |
| 588 | description: "Who this token acts as and its workspaces (`whoami`), your email addresses, your invites to g1t, and invitations to workspaces and repositories waiting for you.", |
| 589 | default_action: Some("whoami"), |
| 590 | actions: &[ |
| 591 | a("whoami", Op::Whoami, "Who the token acts as, and its workspaces"), |
| 592 | a("list_emails", Op::ListEmails, "Your addresses"), |
| 593 | a("add_email", Op::AddEmail, "Add an address"), |
| 594 | a("confirm_email", Op::ConfirmEmail, "Confirm an address with the code from its email"), |
| 595 | a("remove_email", Op::RemoveEmail, "Remove an address"), |
| 596 | a("update_email_settings", Op::UpdateEmailSettings, "Primary, backup and privacy"), |
| 597 | a("list_invites", Op::ListInvites, "Your invites to g1t, and how many are left"), |
| 598 | a("create_invite", Op::CreateInvite, "Invite a friend to g1t by email"), |
| 599 | a("revoke_invite", Op::RevokeInvite, "Revoke one; it comes back"), |
| 600 | a("resend_invite", Op::ResendInvite, "Send a pending one again"), |
| 601 | a("list_workspace_invitations", Op::ListInvitations, "Invitations to workspaces for you"), |
| 602 | a("accept_workspace_invitation", Op::AcceptInvitation, "Accept one and join"), |
| 603 | a("decline_workspace_invitation", Op::DeclineInvitation, "Decline one"), |
| 604 | a("list_repository_invitations", Op::ListMyRepoInvitations, "Invitations to repositories for you"), |
| 605 | a("accept_repository_invitation", Op::AcceptRepoInvitation, "Accept one"), |
| 606 | a("decline_repository_invitation", Op::DeclineRepoInvitation, "Decline one"), |
| 607 | ], |
| 608 | }, |
| 609 | Tool { |
| 610 | name: "artifact", |
| 611 | title: "Artifacts", |
| 612 | description: "A workspace's docs, slides, designs and dashboards (Artifacts mode), as you can open them: list, search and read them (a doc's content is Markdown, with block ids to target), make them, edit them (a change with the edit role, a suggestion with comment), move, trash and restore them, their versions, and who can open them. Name one by its id (fol_…) or its address. Not the `workflow` tool's run artifacts. Slides, designs and dashboards answer that they are not here yet.", |
| 613 | default_action: None, |
| 614 | actions: &[ |
| 615 | a("list", Op::Folios(FoliosOp::List), "Artifacts you can open; tab, kind, space, q; state trashed for the trash"), |
| 616 | a("search", Op::Folios(FoliosOp::Search), "Search them by words and meaning, with the passage that matched"), |
| 617 | a("get", Op::Folios(FoliosOp::Get), "One artifact: kind, title, space, owner, your role, who it is shared with"), |
| 618 | a("read", Op::Folios(FoliosOp::GetContent), "Its content: a doc's Markdown and block ids, and what you may do"), |
| 619 | a("versions", Op::Folios(FoliosOp::ListVersions), "Its saved versions, newest first"), |
| 620 | a("access", Op::Folios(FoliosOp::GetAccess), "Who can open it, and how"), |
| 621 | a("templates", Op::Folios(FoliosOp::ListTemplates), "Templates to start one from"), |
| 622 | a("spaces", Op::Folios(FoliosOp::ListSpaces), "The spaces in your sidebar"), |
| 623 | a("query_data", Op::Folios(FoliosOp::QueryDataset), "Run a dataset query as you, over what you can read"), |
| 624 | a("create", Op::Folios(FoliosOp::Create), "Make one: in a space, under a doc, or in your Private"), |
| 625 | a("update", Op::Folios(FoliosOp::Update), "Rename it, change its icon, or move it"), |
| 626 | a("edit", Op::Folios(FoliosOp::Edit), "Change its content: append, replace it all, a section or blocks"), |
| 627 | a("trash", Op::Folios(FoliosOp::Trash), "Move it to the trash; restorable for 30 days"), |
| 628 | a("restore", Op::Folios(FoliosOp::Restore), "Bring it back from the trash"), |
| 629 | a("restore_version", Op::Folios(FoliosOp::RestoreVersion), "Make an earlier version its content again"), |
| 630 | a("share", Op::Folios(FoliosOp::SetAccess), "Share it, change general access, or take access away"), |
| 631 | a("purge", Op::Folios(FoliosOp::Purge), "Delete one in the trash for good"), |
| 632 | ], |
| 633 | }, |
| 634 | ]; |
| 635 | |
| 636 | /// Operations offered over REST alone, not as an action of any tool: how |
| 637 | /// a project's telemetry is collected (settings, ingest tokens, exports, |
| 638 | /// usage) is for people setting it up, not for agents debugging. |
| 639 | pub const REST_ONLY: &[Op] = &[ |
| 640 | Op::Telemetry(TelemetryOp::GetSettings), |
| 641 | Op::Telemetry(TelemetryOp::UpdateSettings), |
| 642 | Op::Telemetry(TelemetryOp::ListTokens), |
| 643 | Op::Telemetry(TelemetryOp::CreateToken), |
| 644 | Op::Telemetry(TelemetryOp::DeleteToken), |
| 645 | Op::Telemetry(TelemetryOp::ListExports), |
| 646 | Op::Telemetry(TelemetryOp::CreateExport), |
| 647 | Op::Telemetry(TelemetryOp::UpdateExport), |
| 648 | Op::Telemetry(TelemetryOp::DeleteExport), |
| 649 | Op::Telemetry(TelemetryOp::GetUsage), |
| 650 | // A person's own Getting started is about them at a page, not for agents. |
| 651 | Op::Onboarding(OnboardingOp::GetOnboarding), |
| 652 | Op::Onboarding(OnboardingOp::UpdateOnboarding), |
| 653 | // Sessions across a workspace are the `session` tool's `list` and |
| 654 | // `get` with a `workspace`. |
| 655 | Op::Coordination(CoordinationOp::ListWorkspaceSessions), |
| 656 | Op::Coordination(CoordinationOp::GetWorkspaceSession), |
| 657 | ]; |
| 658 | |
| 659 | /// Operations that cannot be undone, or reach beyond g1t's own records: |
| 660 | /// clients ask before running a tool that has any of them. |
| 661 | fn destructive(op: Op) -> bool { |
| 662 | matches!( |
| 663 | op, |
| 664 | Op::Security(SecurityOp::DeleteCustomPattern | SecurityOp::BypassPushProtection) |
| 665 | | Op::Rules(RulesOp::DeleteRepoRuleset | RulesOp::DeleteWorkspaceRuleset) |
| 666 | | Op::DeleteWorkspace |
| 667 | | Op::UpdateWorkspace |
| 668 | | Op::Tokens(TokenOp::RevokeMemberToken | TokenOp::SetTokenPolicy) |
| 669 | | Op::Sso(SsoOp::ConfigureSso | SsoOp::DeleteSso | SsoOp::UnlinkSsoIdentity | SsoOp::EnableScim | SsoOp::DisableScim) |
| 670 | | Op::RemoveMember |
| 671 | | Op::TransferOwnership |
| 672 | | Op::LeaveWorkspace |
| 673 | | Op::DeleteRepo |
| 674 | | Op::PurgeRepo |
| 675 | | Op::TransferRepo |
| 676 | | Op::SetRepoVisibility |
| 677 | | Op::RemoveEmail |
| 678 | | Op::RemoveCollaborator |
| 679 | | Op::DisconnectIntegration |
| 680 | | Op::UpdateIntegration |
| 681 | | Op::RemoveAiProvider |
| 682 | | Op::UpdateAiProvider |
| 683 | | Op::DeleteWebhook |
| 684 | | Op::DeleteActionsSecret |
| 685 | | Op::DeleteActionsVariable |
| 686 | | Op::SetActionsSecret |
| 687 | | Op::SetActionsVariable |
| 688 | | Op::SetBasePermission |
| 689 | | Op::DeleteTeam |
| 690 | | Op::RemoveTeamRepo |
| 691 | | Op::MergePullRequest |
| 692 | | Op::DeleteCommitComment |
| 693 | | Op::RemoveRunner |
| 694 | | Op::DeleteRunnerGroup |
| 695 | | Op::UpdateRunnerSettings |
| 696 | | Op::Folios(FoliosOp::SetAccess | FoliosOp::Purge) |
| 697 | ) |
| 698 | } |
| 699 | |
| 700 | /// Whether an operation only reads. |
| 701 | pub fn reads_only(op: Op) -> bool { |
| 702 | NO_SCOPE.contains(&op.name()) |
| 703 | || scope_for(op.name()).is_some_and(|scope| scope.level() == Level::Read) |
| 704 | } |
| 705 | |
| 706 | /// What decides which actions a caller sees. |
| 707 | pub enum Gate<'a> { |
| 708 | /// No limit beyond the person's own role. |
| 709 | Everything, |
| 710 | /// A run's token (a checks, merge queue or deploy job): the |
| 711 | /// operations its run lists. |
| 712 | Agent(&'a AgentScope), |
| 713 | /// An access token with scopes. |
| 714 | Token(&'a TokenAccess), |
| 715 | } |
| 716 | |
| 717 | impl Gate<'_> { |
| 718 | pub fn allows(&self, op: Op) -> bool { |
| 719 | match self { |
| 720 | Gate::Everything => true, |
| 721 | Gate::Agent(scope) => op.allowed_by(scope) && !NEVER.contains(&op.name()), |
| 722 | Gate::Token(access) => { |
| 723 | if NO_SCOPE.contains(&op.name()) { |
| 724 | return true; |
| 725 | } |
| 726 | match scope_for(op.name()) { |
| 727 | Some(scope) => access.allows(scope), |
| 728 | None => access.scopes.is_none(), |
| 729 | } |
| 730 | } |
| 731 | } |
| 732 | } |
| 733 | } |
| 734 | |
| 735 | impl Tool { |
| 736 | pub fn by_name(name: &str) -> Option<&'static Tool> { |
| 737 | TOOLS.iter().find(|tool| tool.name == name) |
| 738 | } |
| 739 | |
| 740 | pub fn action(&self, name: &str) -> Option<&'static Action> { |
| 741 | // The tools are 'static; find through TOOLS to keep the lifetime. |
| 742 | TOOLS |
| 743 | .iter() |
| 744 | .find(|tool| tool.name == self.name) |
| 745 | .and_then(|tool| tool.actions.iter().find(|action| action.name == name)) |
| 746 | } |
| 747 | |
| 748 | pub fn visible(&self, gate: &Gate) -> Vec<&'static Action> { |
| 749 | TOOLS |
| 750 | .iter() |
| 751 | .find(|tool| tool.name == self.name) |
| 752 | .map(|tool| tool.actions.iter().filter(|action| gate.allows(action.op)).collect()) |
| 753 | .unwrap_or_default() |
| 754 | } |
| 755 | |
| 756 | /// The flat input schema of the actions given. |
| 757 | pub fn input_schema(&self, actions: &[&Action]) -> Value { |
| 758 | let mut properties = Map::new(); |
| 759 | let lines: Vec<String> = actions |
| 760 | .iter() |
| 761 | .map(|action| { |
| 762 | let required: Vec<String> = action.op.required(); |
| 763 | if required.is_empty() { |
| 764 | format!("{}: {}.", action.name, action.summary) |
| 765 | } else { |
| 766 | format!("{} ({}): {}.", action.name, required.join(", "), action.summary) |
| 767 | } |
| 768 | }) |
| 769 | .collect(); |
| 770 | let mut action_schema = json!({ |
| 771 | "type": "string", |
| 772 | "enum": actions.iter().map(|action| action.name).collect::<Vec<_>>(), |
| 773 | "description": lines.join("\n"), |
| 774 | }); |
| 775 | if let Some(default) = self.default_action.filter(|name| actions.iter().any(|action| action.name == *name)) { |
| 776 | action_schema["default"] = json!(default); |
| 777 | } |
| 778 | properties.insert("action".to_owned(), action_schema); |
| 779 | for action in actions { |
| 780 | for (name, schema) in action.op.properties() { |
| 781 | merge_property(&mut properties, name, schema); |
| 782 | } |
| 783 | } |
| 784 | let mut required = vec![]; |
| 785 | if self.default_action.is_none() { |
| 786 | required.push("action"); |
| 787 | } |
| 788 | let mut schema = json!({ "type": "object", "properties": properties }); |
| 789 | if !required.is_empty() { |
| 790 | schema["required"] = json!(required); |
| 791 | } |
| 792 | schema |
| 793 | } |
| 794 | |
| 795 | /// The input schema keyed by action: one `oneOf` branch per action, |
| 796 | /// each with its own fields and the ones it needs. |
| 797 | pub fn discriminated(&self, actions: &[&Action]) -> Value { |
| 798 | let branches: Vec<Value> = actions |
| 799 | .iter() |
| 800 | .map(|action| { |
| 801 | let mut properties = Map::new(); |
| 802 | properties.insert("action".to_owned(), json!({ "const": action.name })); |
| 803 | properties.extend(action.op.properties()); |
| 804 | let mut required = vec![Value::String("action".to_owned())]; |
| 805 | // The default action may leave `action` out. |
| 806 | if self.default_action == Some(action.name) { |
| 807 | required.clear(); |
| 808 | } |
| 809 | required.extend(action.op.required().into_iter().map(Value::String)); |
| 810 | json!({ |
| 811 | "title": action.name, |
| 812 | "description": action.summary, |
| 813 | "type": "object", |
| 814 | "properties": properties, |
| 815 | "required": required, |
| 816 | }) |
| 817 | }) |
| 818 | .collect(); |
| 819 | json!({ "type": "object", "oneOf": branches }) |
| 820 | } |
| 821 | |
| 822 | /// MCP's hints about the actions given: whether the tool only reads, |
| 823 | /// whether it can destroy something, and whether calling it twice is |
| 824 | /// the same as once. |
| 825 | pub fn annotations(&self, actions: &[&Action]) -> Value { |
| 826 | let read_only = actions.iter().all(|action| reads_only(action.op)); |
| 827 | json!({ |
| 828 | "title": self.title, |
| 829 | "readOnlyHint": read_only, |
| 830 | "destructiveHint": !read_only && actions.iter().any(|action| destructive(action.op)), |
| 831 | "idempotentHint": read_only, |
| 832 | "openWorldHint": false, |
| 833 | }) |
| 834 | } |
| 835 | |
| 836 | /// The tool as `tools/list` gives it, for a caller behind `gate`, or |
| 837 | /// `None` when it may use none of its actions. |
| 838 | pub fn listed(&self, gate: &Gate) -> Option<Value> { |
| 839 | let actions = self.visible(gate); |
| 840 | if actions.is_empty() { |
| 841 | return None; |
| 842 | } |
| 843 | Some(json!({ |
| 844 | "name": self.name, |
| 845 | "title": self.title, |
| 846 | "description": self.description, |
| 847 | "inputSchema": self.input_schema(&actions), |
| 848 | "annotations": self.annotations(&actions), |
| 849 | })) |
| 850 | } |
| 851 | } |
| 852 | |
| 853 | /// Adds a property to a tool's flat schema. The first action to use a name |
| 854 | /// describes it; a later one with other allowed values adds them. |
| 855 | fn merge_property(properties: &mut Map<String, Value>, name: String, schema: Value) { |
| 856 | match properties.get_mut(&name) { |
| 857 | None => { |
| 858 | properties.insert(name, schema); |
| 859 | } |
| 860 | Some(existing) => { |
| 861 | if let (Some(Value::Array(had)), Some(Value::Array(more))) = |
| 862 | (existing.get("enum").cloned(), schema.get("enum")) |
| 863 | { |
| 864 | let mut merged = had; |
| 865 | for value in more { |
| 866 | if !merged.contains(value) { |
| 867 | merged.push(value.clone()); |
| 868 | } |
| 869 | } |
| 870 | existing["enum"] = Value::Array(merged); |
| 871 | } |
| 872 | // Different kinds of value under one name: say less, accept both. |
| 873 | if existing.get("type") != schema.get("type") |
| 874 | && let Some(fields) = existing.as_object_mut() |
| 875 | { |
| 876 | fields.remove("type"); |
| 877 | fields.remove("items"); |
| 878 | } |
| 879 | } |
| 880 | } |
| 881 | } |
| 882 | |
| 883 | /// A call's arguments with the MCP server's own defaults, where they differ |
| 884 | /// from the REST API's: a repository an agent creates is private unless it |
| 885 | /// says otherwise (`private: false`, or `visibility: "public"`), so nothing |
| 886 | /// it starts is public by accident. REST keeps its default, public. |
| 887 | pub fn with_defaults(op: Op, arguments: &Value) -> Value { |
| 888 | let mut arguments = arguments.clone(); |
| 889 | if op == Op::CreateRepo |
| 890 | && let Some(fields) = arguments.as_object_mut() |
| 891 | && !fields.get("private").is_some_and(Value::is_boolean) |
| 892 | { |
| 893 | let public = fields.get("visibility").and_then(Value::as_str).is_some_and(|v| v.eq_ignore_ascii_case("public")); |
| 894 | fields.insert("private".to_owned(), Value::Bool(!public)); |
| 895 | } |
| 896 | arguments |
| 897 | } |
| 898 | |
| 899 | /// What a call to a tool runs: the operation its action names, or why not. |
| 900 | pub fn resolve(tool: &Tool, arguments: &Value) -> Result<Op, String> { |
| 901 | let names = || { |
| 902 | tool.actions |
| 903 | .iter() |
| 904 | .map(|action| action.name) |
| 905 | .collect::<Vec<_>>() |
| 906 | .join(", ") |
| 907 | }; |
| 908 | let Some(name) = arguments["action"].as_str().or(tool.default_action) else { |
| 909 | return Err(format!("Give an action: one of {}.", names())); |
| 910 | }; |
| 911 | let Some(action) = tool.action(name) else { |
| 912 | return Err(format!("{} has no action {name}. Its actions: {}.", tool.name, names())); |
| 913 | }; |
| 914 | let missing: Vec<String> = action |
| 915 | .op |
| 916 | .required() |
| 917 | .into_iter() |
| 918 | .filter(|field| arguments.get(field).is_none_or(Value::is_null)) |
| 919 | .collect(); |
| 920 | if !missing.is_empty() { |
| 921 | return Err(format!("{}.{name} needs {}.", tool.name, missing.join(", "))); |
| 922 | } |
| 923 | Ok(action.op) |
| 924 | } |
| 925 | |
| 926 | #[cfg(test)] |
| 927 | mod tests { |
| 928 | use super::*; |
| 929 | use g1t_contracts::scopes::{Preset, Scope}; |
| 930 | |
| 931 | fn listed(gate: &Gate) -> Vec<Value> { |
| 932 | TOOLS.iter().filter_map(|tool| tool.listed(gate)).collect() |
| 933 | } |
| 934 | |
| 935 | fn token(scopes: Option<Vec<Scope>>) -> TokenAccess { |
| 936 | TokenAccess { |
| 937 | token_id: "tok_1".to_owned(), |
| 938 | scopes: scopes.map(|scopes| scopes.iter().map(|scope| scope.as_str().to_owned()).collect()), |
| 939 | legacy: false, |
| 940 | name: None, |
| 941 | ..TokenAccess::default() |
| 942 | } |
| 943 | } |
| 944 | |
| 945 | #[test] |
| 946 | fn a_repository_created_over_mcp_is_private_unless_it_says_public() { |
| 947 | let made = |arguments: Value| with_defaults(Op::CreateRepo, &arguments)["private"].clone(); |
| 948 | assert_eq!(made(json!({ "name": "web" })), json!(true)); |
| 949 | assert_eq!(made(json!({ "name": "web", "private": null })), json!(true)); |
| 950 | assert_eq!(made(json!({ "name": "web", "private": true })), json!(true)); |
| 951 | assert_eq!(made(json!({ "name": "web", "private": false })), json!(false)); |
| 952 | assert_eq!(made(json!({ "name": "web", "visibility": "public" })), json!(false)); |
| 953 | assert_eq!(made(json!({ "name": "web", "visibility": "private" })), json!(true)); |
| 954 | // Other operations' arguments are left as given. |
| 955 | assert_eq!(with_defaults(Op::UpdateRepo, &json!({ "repo": "acme/web" })), json!({ "repo": "acme/web" })); |
| 956 | let repository = Tool::by_name("repository").unwrap(); |
| 957 | assert!(repository.action("create").unwrap().summary.contains("private unless private is false")); |
| 958 | } |
| 959 | |
| 960 | #[test] |
| 961 | fn every_operation_is_exactly_one_action_of_one_tool() { |
| 962 | for op in Op::ALL { |
| 963 | let count = TOOLS |
| 964 | .iter() |
| 965 | .flat_map(|tool| tool.actions.iter()) |
| 966 | .filter(|action| action.op == op) |
| 967 | .count(); |
| 968 | let expected = usize::from(!REST_ONLY.contains(&op)); |
| 969 | assert_eq!(count, expected, "{} is {count} actions", op.name()); |
| 970 | } |
| 971 | for tool in TOOLS { |
| 972 | let mut names = std::collections::HashSet::new(); |
| 973 | for action in tool.actions { |
| 974 | assert!(names.insert(action.name), "{}.{} twice", tool.name, action.name); |
| 975 | } |
| 976 | if let Some(default) = tool.default_action { |
| 977 | assert!(tool.action(default).is_some(), "{}", tool.name); |
| 978 | } |
| 979 | } |
| 980 | assert!(TOOLS.len() <= 19, "{} tools", TOOLS.len()); |
| 981 | } |
| 982 | |
| 983 | #[test] |
| 984 | fn every_operation_needs_exactly_one_scope_or_none() { |
| 985 | use g1t_contracts::scopes::OPERATIONS; |
| 986 | for op in Op::ALL { |
| 987 | let mapped = OPERATIONS.iter().filter(|(name, _)| *name == op.name()).count(); |
| 988 | let free = NO_SCOPE.contains(&op.name()); |
| 989 | assert_eq!(mapped + usize::from(free), 1, "{}", op.name()); |
| 990 | } |
| 991 | for (name, _) in OPERATIONS { |
| 992 | assert!(Op::by_name(name).is_some(), "{name} is not an operation"); |
| 993 | } |
| 994 | } |
| 995 | |
| 996 | #[test] |
| 997 | fn each_tool_schema_is_valid_with_one_branch_per_action() { |
| 998 | for tool in TOOLS { |
| 999 | let actions: Vec<&Action> = tool.actions.iter().collect(); |
| 1000 | let flat = tool.input_schema(&actions); |
| 1001 | assert_eq!(flat["type"], "object"); |
| 1002 | assert!(flat.get("oneOf").is_none(), "no oneOf at the top level"); |
| 1003 | let listed: Vec<&str> = flat["properties"]["action"]["enum"] |
| 1004 | .as_array() |
| 1005 | .unwrap() |
| 1006 | .iter() |
| 1007 | .map(|name| name.as_str().unwrap()) |
| 1008 | .collect(); |
| 1009 | assert_eq!(listed, tool.actions.iter().map(|action| action.name).collect::<Vec<_>>()); |
| 1010 | for action in tool.actions { |
| 1011 | for field in action.op.required() { |
| 1012 | assert!(flat["properties"].get(&field).is_some(), "{}.{}: {field}", tool.name, action.name); |
| 1013 | } |
| 1014 | } |
| 1015 | let keyed = tool.discriminated(&actions); |
| 1016 | let branches = keyed["oneOf"].as_array().unwrap(); |
| 1017 | assert_eq!(branches.len(), tool.actions.len()); |
| 1018 | for (branch, action) in branches.iter().zip(tool.actions) { |
| 1019 | assert_eq!(branch["properties"]["action"]["const"], action.name); |
| 1020 | for field in branch["required"].as_array().unwrap() { |
| 1021 | assert!(branch["properties"].get(field.as_str().unwrap()).is_some(), "{}.{}: {field}", tool.name, action.name); |
| 1022 | } |
| 1023 | } |
| 1024 | // A well-formed JSON Schema object throughout. |
| 1025 | let text = serde_json::to_string(&flat).unwrap(); |
| 1026 | assert!(serde_json::from_str::<Value>(&text).is_ok()); |
| 1027 | } |
| 1028 | } |
| 1029 | |
| 1030 | #[test] |
| 1031 | fn a_read_only_token_sees_read_actions_only() { |
| 1032 | let access = token(Preset::ReadOnly.scopes()); |
| 1033 | let gate = Gate::Token(&access); |
| 1034 | for tool in TOOLS { |
| 1035 | for action in tool.visible(&gate) { |
| 1036 | assert!(reads_only(action.op), "{}.{}", tool.name, action.name); |
| 1037 | } |
| 1038 | } |
| 1039 | let tools = listed(&gate); |
| 1040 | for tool in &tools { |
| 1041 | assert_eq!(tool["annotations"]["readOnlyHint"], true, "{}", tool["name"]); |
| 1042 | assert_eq!(tool["annotations"]["destructiveHint"], false); |
| 1043 | } |
| 1044 | let work_item = tools.iter().find(|tool| tool["name"] == "work_item").unwrap(); |
| 1045 | assert_eq!( |
| 1046 | work_item["inputSchema"]["properties"]["action"]["enum"], |
| 1047 | json!(["list", "get", "next", "get_plan", "links", "labels", "decisions", "resolve", "work", "list_claims"]) |
| 1048 | ); |
| 1049 | } |
| 1050 | |
| 1051 | #[test] |
| 1052 | fn a_narrow_token_sees_only_its_tools() { |
| 1053 | let access = token(Some(vec![Scope::WorkWrite])); |
| 1054 | let names: Vec<Value> = listed(&Gate::Token(&access)).into_iter().map(|tool| tool["name"].clone()).collect(); |
| 1055 | // Labels and milestones are the workspace's, managed with work:write; |
| 1056 | // looking up the ticket a work item refers to is search's, and a |
| 1057 | // repository's commit comments and its work list are the |
| 1058 | // repository's; an image for a pull request is its attach. |
| 1059 | assert_eq!(names, vec![json!("search"), json!("repository"), json!("work_item"), json!("pull_request"), json!("workspace"), json!("account")]); |
| 1060 | // Notifications are a resource of their own: reading them lists |
| 1061 | // only what reads. |
| 1062 | let reader = token(Some(vec![Scope::NotificationsRead])); |
| 1063 | let tools = listed(&Gate::Token(&reader)); |
| 1064 | let notifications = tools.iter().find(|tool| tool["name"] == "notifications").unwrap(); |
| 1065 | assert_eq!( |
| 1066 | notifications["inputSchema"]["properties"]["action"]["enum"], |
| 1067 | json!(["list", "get", "subscription", "watching", "watched"]) |
| 1068 | ); |
| 1069 | assert_eq!(notifications["annotations"]["readOnlyHint"], true); |
| 1070 | let full = token(None); |
| 1071 | assert_eq!(listed(&Gate::Token(&full)).len(), TOOLS.len()); |
| 1072 | assert_eq!(listed(&Gate::Everything).len(), TOOLS.len()); |
| 1073 | } |
| 1074 | |
| 1075 | #[test] |
| 1076 | fn a_tool_that_can_destroy_says_so() { |
| 1077 | let tools = listed(&Gate::Everything); |
| 1078 | let repository = tools.iter().find(|tool| tool["name"] == "repository").unwrap(); |
| 1079 | assert_eq!(repository["annotations"]["destructiveHint"], true); |
| 1080 | assert_eq!(repository["annotations"]["readOnlyHint"], false); |
| 1081 | let session = tools.iter().find(|tool| tool["name"] == "session").unwrap(); |
| 1082 | assert_eq!(session["annotations"]["destructiveHint"], false); |
| 1083 | } |
| 1084 | |
| 1085 | #[test] |
| 1086 | fn calls_resolve_to_their_operation_or_say_what_is_missing() { |
| 1087 | let work_item = Tool::by_name("work_item").unwrap(); |
| 1088 | assert_eq!(resolve(work_item, &json!({ "action": "get", "workspace": "a", "number": 1 })), Ok(Op::GetWorkItem)); |
| 1089 | assert_eq!(resolve(work_item, &json!({ "action": "get", "repo": "a/b" })), Err("work_item.get needs number.".to_owned())); |
| 1090 | assert!(resolve(work_item, &json!({})).unwrap_err().starts_with("Give an action")); |
| 1091 | assert!(resolve(work_item, &json!({ "action": "explode" })).unwrap_err().contains("no action explode")); |
| 1092 | assert!(Tool::by_name("issue").is_none()); |
| 1093 | // Labels and milestones are the workspace's. |
| 1094 | let workspace = Tool::by_name("workspace").unwrap(); |
| 1095 | assert_eq!(resolve(workspace, &json!({ "action": "list_labels", "workspace": "a" })), Ok(Op::ListLabels)); |
| 1096 | assert!(Tool::by_name("repository").unwrap().action("list_labels").is_none()); |
| 1097 | let pull = Tool::by_name("pull_request").unwrap(); |
| 1098 | assert_eq!(resolve(pull, &json!({ "action": "comment", "repo": "a/b", "number": 2, "body": "x" })), Ok(Op::AddComment)); |
| 1099 | let search = Tool::by_name("search").unwrap(); |
| 1100 | assert_eq!(resolve(search, &json!({ "query": "x" })), Ok(Op::Search)); |
| 1101 | let account = Tool::by_name("account").unwrap(); |
| 1102 | assert_eq!(resolve(account, &json!({})), Ok(Op::Whoami)); |
| 1103 | } |
| 1104 | |
| 1105 | #[test] |
| 1106 | fn teams_are_one_tool_and_a_workspace_reader_sees_only_its_reads() { |
| 1107 | let team = Tool::by_name("team").unwrap(); |
| 1108 | let names: Vec<&str> = team.actions.iter().map(|action| action.name).collect(); |
| 1109 | assert_eq!( |
| 1110 | names, |
| 1111 | [ |
| 1112 | "list", |
| 1113 | "get", |
| 1114 | "create", |
| 1115 | "update", |
| 1116 | "delete", |
| 1117 | "list_members", |
| 1118 | "set_member", |
| 1119 | "remove_member", |
| 1120 | "list_child_teams", |
| 1121 | "list_repos", |
| 1122 | "set_repo", |
| 1123 | "remove_repo", |
| 1124 | "set_review_assignment", |
| 1125 | "list_user_teams", |
| 1126 | ] |
| 1127 | ); |
| 1128 | let reader = token(Some(vec![Scope::WorkspaceRead])); |
| 1129 | let tools = listed(&Gate::Token(&reader)); |
| 1130 | let listed_team = tools.iter().find(|tool| tool["name"] == "team").unwrap(); |
| 1131 | assert_eq!( |
| 1132 | listed_team["inputSchema"]["properties"]["action"]["enum"], |
| 1133 | json!(["list", "get", "list_members", "list_child_teams", "list_repos", "list_user_teams"]) |
| 1134 | ); |
| 1135 | assert_eq!(listed_team["annotations"]["readOnlyHint"], true); |
| 1136 | // A team's role on a repository is who has access. |
| 1137 | let admin = token(Some(vec![Scope::WorkspaceAdmin])); |
| 1138 | let tools = listed(&Gate::Token(&admin)); |
| 1139 | let listed_team = tools.iter().find(|tool| tool["name"] == "team").unwrap(); |
| 1140 | let actions = listed_team["inputSchema"]["properties"]["action"]["enum"].as_array().unwrap(); |
| 1141 | assert!(actions.contains(&json!("set_review_assignment")) && !actions.contains(&json!("set_repo"))); |
| 1142 | let access = token(Some(vec![Scope::AccessAdmin])); |
| 1143 | let tools = listed(&Gate::Token(&access)); |
| 1144 | let listed_team = tools.iter().find(|tool| tool["name"] == "team").unwrap(); |
| 1145 | assert_eq!(listed_team["inputSchema"]["properties"]["action"]["enum"], json!(["set_repo", "remove_repo"])); |
| 1146 | // Both kinds of role a schema names are offered. |
| 1147 | let roles = &listed(&Gate::Everything).into_iter().find(|tool| tool["name"] == "team").unwrap()["inputSchema"] |
| 1148 | ["properties"]["role"]["enum"]; |
| 1149 | for role in ["member", "maintainer", "read", "admin"] { |
| 1150 | assert!(roles.as_array().unwrap().contains(&json!(role)), "{role}"); |
| 1151 | } |
| 1152 | assert_eq!( |
| 1153 | resolve(team, &json!({ "action": "set_repo", "workspace": "acme", "team": "backend", "repo": "rocket" })), |
| 1154 | Err("team.set_repo needs role.".to_owned()) |
| 1155 | ); |
| 1156 | } |
| 1157 | |
| 1158 | #[test] |
| 1159 | fn reviewers_and_code_owners_are_actions_of_their_tools() { |
| 1160 | let pull = Tool::by_name("pull_request").unwrap(); |
| 1161 | assert_eq!( |
| 1162 | resolve(pull, &json!({ "action": "request_reviewers", "repo": "a/b", "number": 1, "team_reviewers": ["backend"] })), |
| 1163 | Ok(Op::RequestReviewers) |
| 1164 | ); |
| 1165 | assert_eq!(pull.action("remove_requested_reviewers").map(|action| action.op), Some(Op::RemoveRequestedReviewers)); |
| 1166 | let repository = Tool::by_name("repository").unwrap(); |
| 1167 | assert_eq!(resolve(repository, &json!({ "action": "codeowners", "repo": "a/b" })), Ok(Op::GetCodeownersErrors)); |
| 1168 | assert!(reads_only(Op::GetCodeownersErrors)); |
| 1169 | assert!(!reads_only(Op::RequestReviewers)); |
| 1170 | } |
| 1171 | |
| 1172 | /// The `artifact` tool offers each token only what its artifacts scope |
| 1173 | /// allows: reading, then changing, then sharing and deleting for good. |
| 1174 | /// Workflow runs' artifacts are the `workflow` tool's, under their own |
| 1175 | /// scope, and neither scope reaches the other's. |
| 1176 | #[test] |
| 1177 | fn the_artifact_tool_offers_what_the_artifacts_scope_allows() { |
| 1178 | let actions = |scopes: Vec<Scope>| -> Option<Value> { |
| 1179 | let access = token(Some(scopes)); |
| 1180 | Tool::by_name("artifact").unwrap().listed(&Gate::Token(&access)).map(|tool| tool["inputSchema"]["properties"]["action"]["enum"].clone()) |
| 1181 | }; |
| 1182 | let reads = json!(["list", "search", "get", "read", "versions", "access", "templates", "spaces", "query_data"]); |
| 1183 | assert_eq!(actions(vec![Scope::ArtifactsRead]), Some(reads.clone())); |
| 1184 | let writes = actions(vec![Scope::ArtifactsWrite]).unwrap(); |
| 1185 | for action in ["create", "update", "edit", "trash", "restore", "restore_version"] { |
| 1186 | assert!(writes.as_array().unwrap().contains(&json!(action)), "{action}"); |
| 1187 | } |
| 1188 | assert!(!writes.as_array().unwrap().contains(&json!("share")) && !writes.as_array().unwrap().contains(&json!("purge"))); |
| 1189 | let admin = actions(vec![Scope::ArtifactsAdmin]).unwrap(); |
| 1190 | assert_eq!(admin.as_array().unwrap().len(), Tool::by_name("artifact").unwrap().actions.len()); |
| 1191 | // Without an artifacts scope there is no artifact tool at all. |
| 1192 | assert_eq!(actions(vec![Scope::WorkflowsWrite, Scope::WorkWrite]), None); |
| 1193 | // And an artifacts scope shows nothing of workflow runs' artifacts. |
| 1194 | let access = token(Some(vec![Scope::ArtifactsAdmin])); |
| 1195 | assert!(Tool::by_name("workflow").unwrap().listed(&Gate::Token(&access)).is_none()); |
| 1196 | // The read-only and agent presets read artifacts and change none. |
| 1197 | for preset in [Preset::ReadOnly, Preset::Agent] { |
| 1198 | let access = token(preset.scopes()); |
| 1199 | let tool = Tool::by_name("artifact").unwrap().listed(&Gate::Token(&access)).unwrap(); |
| 1200 | assert_eq!(tool["inputSchema"]["properties"]["action"]["enum"], reads, "{}", preset.as_str()); |
| 1201 | assert_eq!(tool["annotations"]["readOnlyHint"], true); |
| 1202 | } |
| 1203 | // Sharing and deleting for good can't be undone the same way. |
| 1204 | let tools = listed(&Gate::Everything); |
| 1205 | let artifact = tools.iter().find(|tool| tool["name"] == "artifact").unwrap(); |
| 1206 | assert_eq!(artifact["annotations"]["destructiveHint"], true); |
| 1207 | assert!(artifact["description"].as_str().unwrap().contains("Not the `workflow` tool's run artifacts")); |
| 1208 | let tool = Tool::by_name("artifact").unwrap(); |
| 1209 | assert_eq!(resolve(tool, &json!({ "action": "read", "workspace": "acme" })), Err("artifact.read needs artifact_id.".to_owned())); |
| 1210 | assert_eq!( |
| 1211 | resolve(tool, &json!({ "action": "edit", "workspace": "acme", "artifact_id": "fol_1", "markdown": "x" })), |
| 1212 | Ok(Op::Folios(FoliosOp::Edit)) |
| 1213 | ); |
| 1214 | } |
| 1215 | |
| 1216 | /// How much smaller `tools/list` is than one tool per operation. Run |
| 1217 | /// with `--nocapture` to see the numbers. |
| 1218 | #[test] |
| 1219 | fn the_tool_list_is_much_smaller_than_one_tool_per_operation() { |
| 1220 | let before: Vec<Value> = Op::ALL |
| 1221 | .into_iter() |
| 1222 | .map(|op| json!({ "name": op.name(), "description": op.description(), "inputSchema": op.input() })) |
| 1223 | .collect(); |
| 1224 | let after = listed(&Gate::Everything); |
| 1225 | let before_bytes = serde_json::to_string(&json!({ "tools": before })).unwrap().len(); |
| 1226 | let after_bytes = serde_json::to_string(&json!({ "tools": after })).unwrap().len(); |
| 1227 | let agent = token(Preset::Agent.scopes()); |
| 1228 | let agent_bytes = serde_json::to_string(&json!({ "tools": listed(&Gate::Token(&agent)) })).unwrap().len(); |
| 1229 | let read = token(Preset::ReadOnly.scopes()); |
| 1230 | let read_bytes = serde_json::to_string(&json!({ "tools": listed(&Gate::Token(&read)) })).unwrap().len(); |
| 1231 | println!( |
| 1232 | "tools/list: before {} tools, {before_bytes} bytes (~{} tokens); after {} tools, {after_bytes} bytes (~{} tokens); agent preset {agent_bytes} bytes (~{} tokens); read only {read_bytes} bytes (~{} tokens)", |
| 1233 | before.len(), |
| 1234 | before_bytes / 4, |
| 1235 | after.len(), |
| 1236 | after_bytes / 4, |
| 1237 | agent_bytes / 4, |
| 1238 | read_bytes / 4, |
| 1239 | ); |
| 1240 | assert!(after_bytes * 2 < before_bytes, "{after_bytes} vs {before_bytes}"); |
| 1241 | } |
| 1242 | } |