Skip to content
Sign up

flagon-io/g1t

public
00

Where people and agents ship software together. The open-source git platform for the whole job: issues, agents, checks and deploys to the edge.

g1t.sh
gitagentscloudflarerustforgemcp
1,943 linesCodeBlameRaw

Pick any line to see why it is the way it is: the commit, the pull request and issue it came from, and what the agent was thinking.

Mission control counts people's direct pushes to the default branch1//! Scopes: what an access token may do on its owner's behalf.
2//!
3//! A personal access token, a workspace's token and an application signed
4//! in with OAuth each carry a set of scopes. A token reaches whatever the
5//! one it acts as can reach: a person's token, that person's workspaces and
6//! repositories; a workspace's token, that workspace. What a request may do
7//! is the intersection of two things: the role of whoever the token acts as
8//! (see [`crate::access`]) and the token's scopes.
9//!
10//! Each scope is a resource and a level, written `resource:level`, such as
11//! `issues:write`. A higher level of a resource includes the lower ones:
12//! `repo:admin` includes `repo:write`, which includes `repo:read`.
13//!
14//! This module is the one source of truth: the API (REST and MCP) and git
15//! enforce it, and identity stores it. `packages/contracts/src/scopes.ts`
16//! mirrors the table for the site; a test keeps the two the same.
17
18use serde::{Deserialize, Serialize};
19
20use crate::credentials::Decision;
21
22/// Something a token can be given access to.
23#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
24pub enum Resource {
25 Account,
API: notifications over REST and MCP, with notifications scopes26 Notifications,
The phone app: Chat in full with phone notifications, plus Code and Customize (#4)27 /// Chat: the conversations a person is in (channels, direct messages,
28 /// threads), read and answered as them on the site's chat routes and
29 /// live sockets. A person's own; no preset gives it.
30 Chat,
Mission control counts people's direct pushes to the default branch31 Workspace,
Usage, Billing settings and prepaid AI credit; fixes from the UX audit32 Billing,
Mission control counts people's direct pushes to the default branch33 Repo,
34 Code,
Teams and CODEOWNERS, labels and milestones, dependency updates, the security suite, and a clearer top bar35 Security,
Mission control counts people's direct pushes to the default branch36 Packages,
37 Issues,
38 PullRequests,
39 Agents,
40 Workflows,
Token reach: workflow_files scope, fine-grained reach, workspace token cap41 WorkflowFiles,
Merge checks: statuses and check runs on every commit42 Checks,
Merge branch 'main' into worktree-agent-a69aeabc4b0deeb9743 Deployments,
Projects have Observability: their requests, logs, traces, metrics and errors, from apps on g1t.page with nothing to set up, and from software anywhere else over OpenTelemetry.44 /// Observability: what a project's running software did, as requests,
45 /// logs, traces, errors and metrics, and how they are collected.
46 Observability,
Mission control counts people's direct pushes to the default branch47 Memory,
48 Access,
49 Webhooks,
50 Secrets,
51 Runners,
Merge the AI Gateway: Anthropic's Messages API on a workspace's tokens52 Models,
Artifacts contracts: folios, their four kinds, dashboard datasets, folio events and the artifacts scopes are typed and validated the same in TypeScript and Rust, with nothing using them yet53 /// Artifacts mode's docs, slides, designs and dashboards (folios in
Merge main into Artifacts Phase 254 /// code): the `artifact` MCP tool and `/workspaces/{ws}/artifacts`.
55 /// Not workflow runs' artifacts, which are `workflows:*`.
Artifacts contracts: folios, their four kinds, dashboard datasets, folio events and the artifacts scopes are typed and validated the same in TypeScript and Rust, with nothing using them yet56 Artifacts,
Mission control counts people's direct pushes to the default branch57}
58
59impl Resource {
Projects have Observability: their requests, logs, traces, metrics and errors, from apps on g1t.page with nothing to set up, and from software anywhere else over OpenTelemetry.60 pub const ALL: [Resource; 24] = [
Mission control counts people's direct pushes to the default branch61 Resource::Repo,
62 Resource::Code,
Teams and CODEOWNERS, labels and milestones, dependency updates, the security suite, and a clearer top bar63 Resource::Security,
Mission control counts people's direct pushes to the default branch64 Resource::Packages,
65 Resource::Issues,
66 Resource::PullRequests,
67 Resource::Agents,
68 Resource::Workflows,
Token reach: workflow_files scope, fine-grained reach, workspace token cap69 Resource::WorkflowFiles,
Merge checks: statuses and check runs on every commit70 Resource::Checks,
Merge branch 'main' into worktree-agent-a69aeabc4b0deeb9771 Resource::Deployments,
Projects have Observability: their requests, logs, traces, metrics and errors, from apps on g1t.page with nothing to set up, and from software anywhere else over OpenTelemetry.72 Resource::Observability,
Mission control counts people's direct pushes to the default branch73 Resource::Memory,
74 Resource::Account,
API: notifications over REST and MCP, with notifications scopes75 Resource::Notifications,
The phone app: Chat in full with phone notifications, plus Code and Customize (#4)76 Resource::Chat,
Mission control counts people's direct pushes to the default branch77 Resource::Workspace,
Usage, Billing settings and prepaid AI credit; fixes from the UX audit78 Resource::Billing,
Mission control counts people's direct pushes to the default branch79 Resource::Access,
80 Resource::Webhooks,
81 Resource::Secrets,
82 Resource::Runners,
Merge the AI Gateway: Anthropic's Messages API on a workspace's tokens83 Resource::Models,
Artifacts contracts: folios, their four kinds, dashboard datasets, folio events and the artifacts scopes are typed and validated the same in TypeScript and Rust, with nothing using them yet84 Resource::Artifacts,
Mission control counts people's direct pushes to the default branch85 ];
86
87 pub fn as_str(self) -> &'static str {
88 match self {
89 Resource::Account => "account",
API: notifications over REST and MCP, with notifications scopes90 Resource::Notifications => "notifications",
The phone app: Chat in full with phone notifications, plus Code and Customize (#4)91 Resource::Chat => "chat",
Mission control counts people's direct pushes to the default branch92 Resource::Workspace => "workspace",
Usage, Billing settings and prepaid AI credit; fixes from the UX audit93 Resource::Billing => "billing",
Mission control counts people's direct pushes to the default branch94 Resource::Repo => "repo",
95 Resource::Code => "code",
Teams and CODEOWNERS, labels and milestones, dependency updates, the security suite, and a clearer top bar96 Resource::Security => "security",
Mission control counts people's direct pushes to the default branch97 Resource::Packages => "packages",
98 Resource::Issues => "issues",
99 Resource::PullRequests => "pull_requests",
100 Resource::Agents => "agents",
101 Resource::Workflows => "workflows",
Token reach: workflow_files scope, fine-grained reach, workspace token cap102 Resource::WorkflowFiles => "workflow_files",
Merge checks: statuses and check runs on every commit103 Resource::Checks => "checks",
Merge branch 'main' into worktree-agent-a69aeabc4b0deeb97104 Resource::Deployments => "deployments",
Projects have Observability: their requests, logs, traces, metrics and errors, from apps on g1t.page with nothing to set up, and from software anywhere else over OpenTelemetry.105 Resource::Observability => "observability",
Mission control counts people's direct pushes to the default branch106 Resource::Memory => "memory",
107 Resource::Access => "access",
108 Resource::Webhooks => "webhooks",
109 Resource::Secrets => "secrets",
110 Resource::Runners => "runners",
Merge the AI Gateway: Anthropic's Messages API on a workspace's tokens111 Resource::Models => "models",
Artifacts contracts: folios, their four kinds, dashboard datasets, folio events and the artifacts scopes are typed and validated the same in TypeScript and Rust, with nothing using them yet112 Resource::Artifacts => "artifacts",
Mission control counts people's direct pushes to the default branch113 }
114 }
115
116 /// Its name, for people.
117 pub fn label(self) -> &'static str {
118 match self {
119 Resource::Account => "Your account",
API: notifications over REST and MCP, with notifications scopes120 Resource::Notifications => "Notifications",
The phone app: Chat in full with phone notifications, plus Code and Customize (#4)121 Resource::Chat => "Chat",
Mission control counts people's direct pushes to the default branch122 Resource::Workspace => "Workspaces",
Usage, Billing settings and prepaid AI credit; fixes from the UX audit123 Resource::Billing => "Billing",
Mission control counts people's direct pushes to the default branch124 Resource::Repo => "Repositories",
125 Resource::Code => "Code",
Teams and CODEOWNERS, labels and milestones, dependency updates, the security suite, and a clearer top bar126 Resource::Security => "Security",
Mission control counts people's direct pushes to the default branch127 Resource::Packages => "Packages",
128 Resource::Issues => "Issues",
129 Resource::PullRequests => "Pull requests",
130 Resource::Agents => "g1t agents",
131 Resource::Workflows => "Workflows",
Token reach: workflow_files scope, fine-grained reach, workspace token cap132 Resource::WorkflowFiles => "Workflow files",
Merge checks: statuses and check runs on every commit133 Resource::Checks => "Checks and statuses",
Merge branch 'main' into worktree-agent-a69aeabc4b0deeb97134 Resource::Deployments => "Deployments",
Projects have Observability: their requests, logs, traces, metrics and errors, from apps on g1t.page with nothing to set up, and from software anywhere else over OpenTelemetry.135 Resource::Observability => "Observability",
The contracts no longer describe g1t's own agents, and workspaces can keep their AI providers. Every consumer had already stopped using them, so the TypeScript and Rust contracts drop the workspace-agent, ability, look, skill-library, context, runner-agent and mention modules, the chat and docs RPCs agents posted and read through, the folio agent methods, the agent_waiting notification, agent.asked and memory.changed events, AI credit, token and gateway billing types, model routes and sessions, team agents, agent tokens, plan, review, message and confidence types, command rules, cost caps and confidence rules. The agents:run and models:* scopes are no longer offered by any preset, OAuth default or permission form, but a stored token or grant that names them still reads; and the removed operations are gone from the scope table, so the API's check that every operation has exactly one scope is strict again. What stored data needs in order to parse (old run and credential kinds, an agent team lead, retired rules and webhook events, old guardrail and integration settings) still parses, and a run's token is still PrincipalKind::Agent, which now means a run's token and the @g1t rows written before. The customize, marketplace, skills and claude-plugin contracts stay only until the mobile app drops its Customize screens.136 Resource::Memory => "Memory",
Mission control counts people's direct pushes to the default branch137 Resource::Access => "Who has access",
138 Resource::Webhooks => "Webhooks",
139 Resource::Secrets => "Secrets and variables",
140 Resource::Runners => "Self-hosted runners",
Merge the AI Gateway: Anthropic's Messages API on a workspace's tokens141 Resource::Models => "AI Gateway",
Artifacts contracts: folios, their four kinds, dashboard datasets, folio events and the artifacts scopes are typed and validated the same in TypeScript and Rust, with nothing using them yet142 Resource::Artifacts => "Artifacts",
Mission control counts people's direct pushes to the default branch143 }
144 }
Artifacts contracts: folios, their four kinds, dashboard datasets, folio events and the artifacts scopes are typed and validated the same in TypeScript and Rust, with nothing using them yet145
The contracts no longer describe g1t's own agents, and workspaces can keep their AI providers. Every consumer had already stopped using them, so the TypeScript and Rust contracts drop the workspace-agent, ability, look, skill-library, context, runner-agent and mention modules, the chat and docs RPCs agents posted and read through, the folio agent methods, the agent_waiting notification, agent.asked and memory.changed events, AI credit, token and gateway billing types, model routes and sessions, team agents, agent tokens, plan, review, message and confidence types, command rules, cost caps and confidence rules. The agents:run and models:* scopes are no longer offered by any preset, OAuth default or permission form, but a stored token or grant that names them still reads; and the removed operations are gone from the scope table, so the API's check that every operation has exactly one scope is strict again. What stored data needs in order to parse (old run and credential kinds, an agent team lead, retired rules and webhook events, old guardrail and integration settings) still parses, and a run's token is still PrincipalKind::Agent, which now means a run's token and the @g1t rows written before. The customize, marketplace, skills and claude-plugin contracts stay only until the mobile app drops its Customize screens.146 /// Whether tokens are offered it. A resource being built can be in
Merge main into Artifacts Phase 2147 /// the table before its API ships (so its scopes parse, and the
148 /// TypeScript mirror lists it under `UPCOMING_RESOURCES`) while nothing
149 /// hands it out: presets, full access, OAuth and the token form leave
The contracts no longer describe g1t's own agents, and workspaces can keep their AI providers. Every consumer had already stopped using them, so the TypeScript and Rust contracts drop the workspace-agent, ability, look, skill-library, context, runner-agent and mention modules, the chat and docs RPCs agents posted and read through, the folio agent methods, the agent_waiting notification, agent.asked and memory.changed events, AI credit, token and gateway billing types, model routes and sessions, team agents, agent tokens, plan, review, message and confidence types, command rules, cost caps and confidence rules. The agents:run and models:* scopes are no longer offered by any preset, OAuth default or permission form, but a stored token or grant that names them still reads; and the removed operations are gone from the scope table, so the API's check that every operation has exactly one scope is strict again. What stored data needs in order to parse (old run and credential kinds, an agent team lead, retired rules and webhook events, old guardrail and integration settings) still parses, and a run's token is still PrincipalKind::Agent, which now means a run's token and the @g1t rows written before. The customize, marketplace, skills and claude-plugin contracts stay only until the mobile app drops its Customize screens.150 /// it out, and no operation needs it. A [`Resource::retired`] one is
151 /// never offered again.
Artifacts contracts: folios, their four kinds, dashboard datasets, folio events and the artifacts scopes are typed and validated the same in TypeScript and Rust, with nothing using them yet152 pub fn offered(self) -> bool {
The contracts no longer describe g1t's own agents, and workspaces can keep their AI providers. Every consumer had already stopped using them, so the TypeScript and Rust contracts drop the workspace-agent, ability, look, skill-library, context, runner-agent and mention modules, the chat and docs RPCs agents posted and read through, the folio agent methods, the agent_waiting notification, agent.asked and memory.changed events, AI credit, token and gateway billing types, model routes and sessions, team agents, agent tokens, plan, review, message and confidence types, command rules, cost caps and confidence rules. The agents:run and models:* scopes are no longer offered by any preset, OAuth default or permission form, but a stored token or grant that names them still reads; and the removed operations are gone from the scope table, so the API's check that every operation has exactly one scope is strict again. What stored data needs in order to parse (old run and credential kinds, an agent team lead, retired rules and webhook events, old guardrail and integration settings) still parses, and a run's token is still PrincipalKind::Agent, which now means a run's token and the @g1t rows written before. The customize, marketplace, skills and claude-plugin contracts stay only until the mobile app drops its Customize screens.153 !self.retired()
154 }
155
156 /// Whether it belonged to something g1t no longer has: `agents` (g1t's
157 /// own agents) and `models` (its model proxy and AI Gateway). Their
158 /// scopes still parse, so tokens and OAuth grants that stored them read
159 /// as before, but [`parse_scopes`] leaves them out, nothing hands them
160 /// out and no operation needs them: they grant nothing. The TypeScript
161 /// mirror lists them under `RETIRED_RESOURCES` and `RETIRED_SCOPES`.
162 pub fn retired(self) -> bool {
163 matches!(self, Resource::Agents | Resource::Models)
Artifacts contracts: folios, their four kinds, dashboard datasets, folio events and the artifacts scopes are typed and validated the same in TypeScript and Rust, with nothing using them yet164 }
Mission control counts people's direct pushes to the default branch165}
166
167/// How much of a resource.
168#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
169pub enum Level {
170 Read,
171 Write,
The contracts no longer describe g1t's own agents, and workspaces can keep their AI providers. Every consumer had already stopped using them, so the TypeScript and Rust contracts drop the workspace-agent, ability, look, skill-library, context, runner-agent and mention modules, the chat and docs RPCs agents posted and read through, the folio agent methods, the agent_waiting notification, agent.asked and memory.changed events, AI credit, token and gateway billing types, model routes and sessions, team agents, agent tokens, plan, review, message and confidence types, command rules, cost caps and confidence rules. The agents:run and models:* scopes are no longer offered by any preset, OAuth default or permission form, but a stored token or grant that names them still reads; and the removed operations are gone from the scope table, so the API's check that every operation has exactly one scope is strict again. What stored data needs in order to parse (old run and credential kinds, an agent team lead, retired rules and webhook events, old guardrail and integration settings) still parses, and a run's token is still PrincipalKind::Agent, which now means a run's token and the @g1t rows written before. The customize, marketplace, skills and claude-plugin contracts stay only until the mobile app drops its Customize screens.172 /// Starting g1t's own agents: only `agents:run`, which is retired.
Mission control counts people's direct pushes to the default branch173 Run,
174 /// Deleting what cannot be brought back, such as a package's versions.
175 Delete,
176 Admin,
177}
178
179impl Level {
180 pub fn as_str(self) -> &'static str {
181 match self {
182 Level::Read => "read",
183 Level::Write => "write",
184 Level::Run => "run",
185 Level::Delete => "delete",
186 Level::Admin => "admin",
187 }
188 }
189}
190
191/// One scope. Its text form, `resource:level`, is what tokens store, OAuth
192/// clients ask for, and errors name.
193#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
194pub enum Scope {
195 RepoRead,
196 RepoWrite,
197 RepoAdmin,
198 CodeRead,
199 CodeWrite,
Teams and CODEOWNERS, labels and milestones, dependency updates, the security suite, and a clearer top bar200 SecurityRead,
201 SecurityWrite,
Mission control counts people's direct pushes to the default branch202 PackagesRead,
203 PackagesWrite,
204 PackagesDelete,
205 IssuesRead,
206 IssuesWrite,
207 PullRequestsRead,
208 PullRequestsWrite,
The contracts no longer describe g1t's own agents, and workspaces can keep their AI providers. Every consumer had already stopped using them, so the TypeScript and Rust contracts drop the workspace-agent, ability, look, skill-library, context, runner-agent and mention modules, the chat and docs RPCs agents posted and read through, the folio agent methods, the agent_waiting notification, agent.asked and memory.changed events, AI credit, token and gateway billing types, model routes and sessions, team agents, agent tokens, plan, review, message and confidence types, command rules, cost caps and confidence rules. The agents:run and models:* scopes are no longer offered by any preset, OAuth default or permission form, but a stored token or grant that names them still reads; and the removed operations are gone from the scope table, so the API's check that every operation has exactly one scope is strict again. What stored data needs in order to parse (old run and credential kinds, an agent team lead, retired rules and webhook events, old guardrail and integration settings) still parses, and a run's token is still PrincipalKind::Agent, which now means a run's token and the @g1t rows written before. The customize, marketplace, skills and claude-plugin contracts stay only until the mobile app drops its Customize screens.209 /// Retired with g1t's own agents ([`Resource::retired`]): parses, so
210 /// stored tokens still read, but is never granted and gates nothing.
Mission control counts people's direct pushes to the default branch211 AgentsRun,
212 WorkflowsRead,
213 WorkflowsWrite,
Token reach: workflow_files scope, fine-grained reach, workspace token cap214 WorkflowFilesWrite,
Merge checks: statuses and check runs on every commit215 ChecksRead,
216 ChecksWrite,
Merge branch 'main' into worktree-agent-a69aeabc4b0deeb97217 DeploymentsRead,
218 DeploymentsWrite,
Projects have Observability: their requests, logs, traces, metrics and errors, from apps on g1t.page with nothing to set up, and from software anywhere else over OpenTelemetry.219 ObservabilityRead,
220 ObservabilityWrite,
Mission control counts people's direct pushes to the default branch221 MemoryRead,
222 MemoryWrite,
223 AccountRead,
224 AccountWrite,
API: notifications over REST and MCP, with notifications scopes225 NotificationsRead,
226 NotificationsWrite,
The phone app: Chat in full with phone notifications, plus Code and Customize (#4)227 ChatRead,
228 ChatWrite,
Mission control counts people's direct pushes to the default branch229 WorkspaceRead,
230 WorkspaceAdmin,
Usage, Billing settings and prepaid AI credit; fixes from the UX audit231 BillingRead,
232 BillingWrite,
Mission control counts people's direct pushes to the default branch233 AccessRead,
234 AccessAdmin,
235 WebhooksRead,
236 WebhooksAdmin,
237 SecretsRead,
238 SecretsAdmin,
239 RunnersRead,
240 RunnersAdmin,
The contracts no longer describe g1t's own agents, and workspaces can keep their AI providers. Every consumer had already stopped using them, so the TypeScript and Rust contracts drop the workspace-agent, ability, look, skill-library, context, runner-agent and mention modules, the chat and docs RPCs agents posted and read through, the folio agent methods, the agent_waiting notification, agent.asked and memory.changed events, AI credit, token and gateway billing types, model routes and sessions, team agents, agent tokens, plan, review, message and confidence types, command rules, cost caps and confidence rules. The agents:run and models:* scopes are no longer offered by any preset, OAuth default or permission form, but a stored token or grant that names them still reads; and the removed operations are gone from the scope table, so the API's check that every operation has exactly one scope is strict again. What stored data needs in order to parse (old run and credential kinds, an agent team lead, retired rules and webhook events, old guardrail and integration settings) still parses, and a run's token is still PrincipalKind::Agent, which now means a run's token and the @g1t rows written before. The customize, marketplace, skills and claude-plugin contracts stay only until the mobile app drops its Customize screens.241 /// Retired with the AI Gateway ([`Resource::retired`]): parses, so
242 /// stored tokens still read, but is never granted and gates nothing.
Merge the AI Gateway: Anthropic's Messages API on a workspace's tokens243 ModelsRead,
244 ModelsWrite,
Artifacts contracts: folios, their four kinds, dashboard datasets, folio events and the artifacts scopes are typed and validated the same in TypeScript and Rust, with nothing using them yet245 ArtifactsRead,
246 ArtifactsWrite,
247 ArtifactsAdmin,
Mission control counts people's direct pushes to the default branch248}
249
250impl Scope {
251 /// Every scope, grouped by resource, least first.
Projects have Observability: their requests, logs, traces, metrics and errors, from apps on g1t.page with nothing to set up, and from software anywhere else over OpenTelemetry.252 pub const ALL: [Scope; 49] = [
Mission control counts people's direct pushes to the default branch253 Scope::RepoRead,
254 Scope::RepoWrite,
255 Scope::RepoAdmin,
256 Scope::CodeRead,
257 Scope::CodeWrite,
Teams and CODEOWNERS, labels and milestones, dependency updates, the security suite, and a clearer top bar258 Scope::SecurityRead,
259 Scope::SecurityWrite,
Mission control counts people's direct pushes to the default branch260 Scope::PackagesRead,
261 Scope::PackagesWrite,
262 Scope::PackagesDelete,
263 Scope::IssuesRead,
264 Scope::IssuesWrite,
265 Scope::PullRequestsRead,
266 Scope::PullRequestsWrite,
267 Scope::AgentsRun,
268 Scope::WorkflowsRead,
269 Scope::WorkflowsWrite,
Token reach: workflow_files scope, fine-grained reach, workspace token cap270 Scope::WorkflowFilesWrite,
Merge checks: statuses and check runs on every commit271 Scope::ChecksRead,
272 Scope::ChecksWrite,
Merge branch 'main' into worktree-agent-a69aeabc4b0deeb97273 Scope::DeploymentsRead,
274 Scope::DeploymentsWrite,
Projects have Observability: their requests, logs, traces, metrics and errors, from apps on g1t.page with nothing to set up, and from software anywhere else over OpenTelemetry.275 Scope::ObservabilityRead,
276 Scope::ObservabilityWrite,
Mission control counts people's direct pushes to the default branch277 Scope::MemoryRead,
278 Scope::MemoryWrite,
279 Scope::AccountRead,
280 Scope::AccountWrite,
API: notifications over REST and MCP, with notifications scopes281 Scope::NotificationsRead,
282 Scope::NotificationsWrite,
The phone app: Chat in full with phone notifications, plus Code and Customize (#4)283 Scope::ChatRead,
284 Scope::ChatWrite,
Mission control counts people's direct pushes to the default branch285 Scope::WorkspaceRead,
286 Scope::WorkspaceAdmin,
Usage, Billing settings and prepaid AI credit; fixes from the UX audit287 Scope::BillingRead,
288 Scope::BillingWrite,
Mission control counts people's direct pushes to the default branch289 Scope::AccessRead,
290 Scope::AccessAdmin,
291 Scope::WebhooksRead,
292 Scope::WebhooksAdmin,
293 Scope::SecretsRead,
294 Scope::SecretsAdmin,
295 Scope::RunnersRead,
296 Scope::RunnersAdmin,
Merge the AI Gateway: Anthropic's Messages API on a workspace's tokens297 Scope::ModelsRead,
298 Scope::ModelsWrite,
Artifacts contracts: folios, their four kinds, dashboard datasets, folio events and the artifacts scopes are typed and validated the same in TypeScript and Rust, with nothing using them yet299 Scope::ArtifactsRead,
300 Scope::ArtifactsWrite,
301 Scope::ArtifactsAdmin,
Mission control counts people's direct pushes to the default branch302 ];
303
304 pub fn as_str(self) -> &'static str {
305 match self {
306 Scope::RepoRead => "repo:read",
307 Scope::RepoWrite => "repo:write",
308 Scope::RepoAdmin => "repo:admin",
309 Scope::CodeRead => "code:read",
310 Scope::CodeWrite => "code:write",
Teams and CODEOWNERS, labels and milestones, dependency updates, the security suite, and a clearer top bar311 Scope::SecurityRead => "security:read",
312 Scope::SecurityWrite => "security:write",
Mission control counts people's direct pushes to the default branch313 Scope::PackagesRead => "packages:read",
314 Scope::PackagesWrite => "packages:write",
315 Scope::PackagesDelete => "packages:delete",
316 Scope::IssuesRead => "issues:read",
317 Scope::IssuesWrite => "issues:write",
318 Scope::PullRequestsRead => "pull_requests:read",
319 Scope::PullRequestsWrite => "pull_requests:write",
320 Scope::AgentsRun => "agents:run",
321 Scope::WorkflowsRead => "workflows:read",
322 Scope::WorkflowsWrite => "workflows:write",
Token reach: workflow_files scope, fine-grained reach, workspace token cap323 Scope::WorkflowFilesWrite => "workflow_files:write",
Merge checks: statuses and check runs on every commit324 Scope::ChecksRead => "checks:read",
325 Scope::ChecksWrite => "checks:write",
Merge branch 'main' into worktree-agent-a69aeabc4b0deeb97326 Scope::DeploymentsRead => "deployments:read",
327 Scope::DeploymentsWrite => "deployments:write",
Projects have Observability: their requests, logs, traces, metrics and errors, from apps on g1t.page with nothing to set up, and from software anywhere else over OpenTelemetry.328 Scope::ObservabilityRead => "observability:read",
329 Scope::ObservabilityWrite => "observability:write",
Mission control counts people's direct pushes to the default branch330 Scope::MemoryRead => "memory:read",
331 Scope::MemoryWrite => "memory:write",
332 Scope::AccountRead => "account:read",
333 Scope::AccountWrite => "account:write",
API: notifications over REST and MCP, with notifications scopes334 Scope::NotificationsRead => "notifications:read",
335 Scope::NotificationsWrite => "notifications:write",
The phone app: Chat in full with phone notifications, plus Code and Customize (#4)336 Scope::ChatRead => "chat:read",
337 Scope::ChatWrite => "chat:write",
Mission control counts people's direct pushes to the default branch338 Scope::WorkspaceRead => "workspace:read",
339 Scope::WorkspaceAdmin => "workspace:admin",
Usage, Billing settings and prepaid AI credit; fixes from the UX audit340 Scope::BillingRead => "billing:read",
341 Scope::BillingWrite => "billing:write",
Mission control counts people's direct pushes to the default branch342 Scope::AccessRead => "access:read",
343 Scope::AccessAdmin => "access:admin",
344 Scope::WebhooksRead => "webhooks:read",
345 Scope::WebhooksAdmin => "webhooks:admin",
346 Scope::SecretsRead => "secrets:read",
347 Scope::SecretsAdmin => "secrets:admin",
348 Scope::RunnersRead => "runners:read",
349 Scope::RunnersAdmin => "runners:admin",
Merge the AI Gateway: Anthropic's Messages API on a workspace's tokens350 Scope::ModelsRead => "models:read",
351 Scope::ModelsWrite => "models:write",
Artifacts contracts: folios, their four kinds, dashboard datasets, folio events and the artifacts scopes are typed and validated the same in TypeScript and Rust, with nothing using them yet352 Scope::ArtifactsRead => "artifacts:read",
353 Scope::ArtifactsWrite => "artifacts:write",
354 Scope::ArtifactsAdmin => "artifacts:admin",
Mission control counts people's direct pushes to the default branch355 }
356 }
357
358 pub fn parse(text: &str) -> Option<Scope> {
359 let text = text.trim().to_ascii_lowercase();
360 Scope::ALL.into_iter().find(|scope| scope.as_str() == text)
361 }
362
363 pub fn resource(self) -> Resource {
364 let name = self.as_str().split_once(':').map_or("", |(resource, _)| resource);
365 Resource::ALL
366 .into_iter()
367 .find(|resource| resource.as_str() == name)
368 .unwrap_or(Resource::Account)
369 }
370
371 pub fn level(self) -> Level {
372 match self.as_str().rsplit_once(':').map_or("", |(_, level)| level) {
373 "write" => Level::Write,
374 "run" => Level::Run,
375 "delete" => Level::Delete,
376 "admin" => Level::Admin,
377 _ => Level::Read,
378 }
379 }
380
381 /// Whether holding `self` gives `other`: the same resource, at the same
382 /// level or a lower one.
383 pub fn includes(self, other: Scope) -> bool {
384 self.resource() == other.resource() && self.level() >= other.level()
385 }
386
387 /// Changes that are hard or impossible to undo, or that decide who can
388 /// reach what. Shown behind a warning wherever scopes are chosen.
389 pub fn dangerous(self) -> bool {
390 matches!(self.level(), Level::Admin | Level::Delete)
391 }
392
393 /// What it lets a token do, in plain words.
394 pub fn describe(self) -> &'static str {
395 match self {
Merge branch 'main' into worktree-agent-a69aeabc4b0deeb97396 Scope::RepoRead => "See repositories, their settings, labels, timelines, releases, languages, contributors and security alerts, and search",
The Branches page does things to branches now. It has tabs (Overview, Yours, Active, Stale, All, kept in the address as ?tab=) and search; Overview shows the default branch, then the first five of your branches, the active ones and the stale ones, each linking to the rest. Each branch is a row with its name in a code chip with a copy button, who made its latest commit and when, that commit's checks, behind and ahead counts with bars drawn against the largest shown, and its pull request (the open one, else the newest merged or closed) with its state; on a phone the columns fold under the name. Yours is branches whose latest commit is the viewer's; stale is no commit in 90 days.397 Scope::RepoWrite => "Create repositories, create, rename and delete branches, change how pull requests merge and publish releases",
Merge rulesets: branch and tag rules, agent-first, enforced on push and merge398 Scope::RepoAdmin => "Rename, archive, transfer, delete or change who can see a repository, change its rulesets, and dismiss security alerts",
Mission control counts people's direct pushes to the default branch399 Scope::CodeRead => "Clone and fetch private repositories with git",
400 Scope::CodeWrite => "Push commits with git",
Teams and CODEOWNERS, labels and milestones, dependency updates, the security suite, and a clearer top bar401 Scope::SecurityRead => "See secret scanning, code scanning and vulnerability alerts, custom patterns, the dependency graph and SBOM, and security settings",
402 Scope::SecurityWrite => "Dismiss and reopen alerts, bypass push protection, review bypass requests, manage custom patterns, upload SARIF and change security settings",
Mission control counts people's direct pushes to the default branch403 Scope::PackagesRead => "Pull container images and install private packages",
404 Scope::PackagesWrite => "Push container images and publish packages",
Merge packages: roles, Actions access, source label, soft delete, API405 Scope::PackagesDelete => "Delete and restore packages and their versions",
The contracts no longer describe g1t's own agents, and workspaces can keep their AI providers. Every consumer had already stopped using them, so the TypeScript and Rust contracts drop the workspace-agent, ability, look, skill-library, context, runner-agent and mention modules, the chat and docs RPCs agents posted and read through, the folio agent methods, the agent_waiting notification, agent.asked and memory.changed events, AI credit, token and gateway billing types, model routes and sessions, team agents, agent tokens, plan, review, message and confidence types, command rules, cost caps and confidence rules. The agents:run and models:* scopes are no longer offered by any preset, OAuth default or permission form, but a stored token or grant that names them still reads; and the removed operations are gone from the scope table, so the API's check that every operation has exactly one scope is strict again. What stored data needs in order to parse (old run and credential kinds, an agent team lead, retired rules and webhook events, old guardrail and integration settings) still parses, and a run's token is still PrincipalKind::Agent, which now means a run's token and the @g1t rows written before. The customize, marketplace, skills and claude-plugin contracts stay only until the mobile app drops its Customize screens.406 Scope::IssuesRead => "Read issues and comments",
Mission control counts people's direct pushes to the default branch407 Scope::IssuesWrite => "Open, edit, close and comment on issues",
408 Scope::PullRequestsRead => "Read pull requests, their changes, sessions and merge queues",
409 Scope::PullRequestsWrite => "Open, review, close and merge pull requests",
The contracts no longer describe g1t's own agents, and workspaces can keep their AI providers. Every consumer had already stopped using them, so the TypeScript and Rust contracts drop the workspace-agent, ability, look, skill-library, context, runner-agent and mention modules, the chat and docs RPCs agents posted and read through, the folio agent methods, the agent_waiting notification, agent.asked and memory.changed events, AI credit, token and gateway billing types, model routes and sessions, team agents, agent tokens, plan, review, message and confidence types, command rules, cost caps and confidence rules. The agents:run and models:* scopes are no longer offered by any preset, OAuth default or permission form, but a stored token or grant that names them still reads; and the removed operations are gone from the scope table, so the API's check that every operation has exactly one scope is strict again. What stored data needs in order to parse (old run and credential kinds, an agent team lead, retired rules and webhook events, old guardrail and integration settings) still parses, and a run's token is still PrincipalKind::Agent, which now means a run's token and the @g1t rows written before. The customize, marketplace, skills and claude-plugin contracts stay only until the mobile app drops its Customize screens.410 Scope::AgentsRun => "Retired: put g1t's own agents to work. Grants nothing now",
Mission control counts people's direct pushes to the default branch411 Scope::WorkflowsRead => "Read workflows, runs and logs",
412 Scope::WorkflowsWrite => "Run, cancel, rerun and turn workflows on or off",
Token reach: workflow_files scope, fine-grained reach, workspace token cap413 Scope::WorkflowFilesWrite => "Add, change and delete workflow files under .g1t/workflows and .github/workflows, with git or the API",
Merge checks: statuses and check runs on every commit414 Scope::ChecksRead => "Read commits' statuses, check runs, check suites and annotations",
415 Scope::ChecksWrite => "Report statuses and check runs on commits, and ask for checks to run again",
Merge branch 'main' into worktree-agent-a69aeabc4b0deeb97416 Scope::DeploymentsRead => "See deployments, their statuses and environments",
417 Scope::DeploymentsWrite => "Report deployments and their statuses, from any CI",
Projects have Observability: their requests, logs, traces, metrics and errors, from apps on g1t.page with nothing to set up, and from software anywhere else over OpenTelemetry.418 Scope::ObservabilityRead => "See projects' requests, logs, traces, errors and metrics, and their observability settings, ingest tokens and exports",
419 Scope::ObservabilityWrite => "Resolve and ignore errors, and change projects' observability settings, ingest tokens and exports",
The contracts no longer describe g1t's own agents, and workspaces can keep their AI providers. Every consumer had already stopped using them, so the TypeScript and Rust contracts drop the workspace-agent, ability, look, skill-library, context, runner-agent and mention modules, the chat and docs RPCs agents posted and read through, the folio agent methods, the agent_waiting notification, agent.asked and memory.changed events, AI credit, token and gateway billing types, model routes and sessions, team agents, agent tokens, plan, review, message and confidence types, command rules, cost caps and confidence rules. The agents:run and models:* scopes are no longer offered by any preset, OAuth default or permission form, but a stored token or grant that names them still reads; and the removed operations are gone from the scope table, so the API's check that every operation has exactly one scope is strict again. What stored data needs in order to parse (old run and credential kinds, an agent team lead, retired rules and webhook events, old guardrail and integration settings) still parses, and a run's token is still PrincipalKind::Agent, which now means a run's token and the @g1t rows written before. The customize, marketplace, skills and claude-plugin contracts stay only until the mobile app drops its Customize screens.420 Scope::MemoryRead => "Recall memory",
421 Scope::MemoryWrite => "Save memory for whoever works on the project next",
Merge branch 'main' into worktree-agent-a69aeabc4b0deeb97422 Scope::AccountRead => "Read your email addresses, invites, invitations, pinned projects and stars",
423 Scope::AccountWrite => "Change your email addresses, make invites, answer invitations, pin projects and star repositories",
API: notifications over REST and MCP, with notifications scopes424 Scope::NotificationsRead => "See your inbox, its threads, and what you subscribe to and watch",
425 Scope::NotificationsWrite => "Mark notifications read, done, saved or snoozed, subscribe to threads and watch repositories",
The phone app: Chat in full with phone notifications, plus Code and Customize (#4)426 Scope::ChatRead => "Read the conversations you are in: channels, direct messages, threads and reactions, live",
427 Scope::ChatWrite => "Send, edit and delete your messages, react, mark conversations read, and answer cards in chat",
The contracts no longer describe g1t's own agents, and workspaces can keep their AI providers. Every consumer had already stopped using them, so the TypeScript and Rust contracts drop the workspace-agent, ability, look, skill-library, context, runner-agent and mention modules, the chat and docs RPCs agents posted and read through, the folio agent methods, the agent_waiting notification, agent.asked and memory.changed events, AI credit, token and gateway billing types, model routes and sessions, team agents, agent tokens, plan, review, message and confidence types, command rules, cost caps and confidence rules. The agents:run and models:* scopes are no longer offered by any preset, OAuth default or permission form, but a stored token or grant that names them still reads; and the removed operations are gone from the scope table, so the API's check that every operation has exactly one scope is strict again. What stored data needs in order to parse (old run and credential kinds, an agent team lead, retired rules and webhook events, old guardrail and integration settings) still parses, and a run's token is still PrincipalKind::Agent, which now means a run's token and the @g1t rows written before. The customize, marketplace, skills and claude-plugin contracts stay only until the mobile app drops its Customize screens.428 Scope::WorkspaceRead => "Read workspace settings, invites, integrations, teams and rulesets",
Merge rulesets: branch and tag rules, agent-first, enforced on push and merge429 Scope::WorkspaceAdmin => "Create and delete workspaces, invite members, connect integrations, create, change and delete teams, and change the workspace's rulesets",
The contracts no longer describe g1t's own agents, and workspaces can keep their AI providers. Every consumer had already stopped using them, so the TypeScript and Rust contracts drop the workspace-agent, ability, look, skill-library, context, runner-agent and mention modules, the chat and docs RPCs agents posted and read through, the folio agent methods, the agent_waiting notification, agent.asked and memory.changed events, AI credit, token and gateway billing types, model routes and sessions, team agents, agent tokens, plan, review, message and confidence types, command rules, cost caps and confidence rules. The agents:run and models:* scopes are no longer offered by any preset, OAuth default or permission form, but a stored token or grant that names them still reads; and the removed operations are gone from the scope table, so the API's check that every operation has exactly one scope is strict again. What stored data needs in order to parse (old run and credential kinds, an agent team lead, retired rules and webhook events, old guardrail and integration settings) still parses, and a run's token is still PrincipalKind::Agent, which now means a run's token and the @g1t rows written before. The customize, marketplace, skills and claude-plugin contracts stay only until the mobile app drops its Customize screens.430 Scope::BillingRead => "See a workspace's usage, budget and invoices",
431 Scope::BillingWrite => "Change a workspace's budget",
Mission control counts people's direct pushes to the default branch432 Scope::AccessRead => "See who has access to repositories",
Teams and CODEOWNERS, labels and milestones, dependency updates, the security suite, and a clearer top bar433 Scope::AccessAdmin => "Give and take away access to repositories, a team's included",
Mission control counts people's direct pushes to the default branch434 Scope::WebhooksRead => "See webhooks and their deliveries",
435 Scope::WebhooksAdmin => "Create, change and delete webhooks",
436 Scope::SecretsRead => "List secrets (never their values) and read variables",
437 Scope::SecretsAdmin => "Set and delete secrets and variables",
The contracts no longer describe g1t's own agents, and workspaces can keep their AI providers. Every consumer had already stopped using them, so the TypeScript and Rust contracts drop the workspace-agent, ability, look, skill-library, context, runner-agent and mention modules, the chat and docs RPCs agents posted and read through, the folio agent methods, the agent_waiting notification, agent.asked and memory.changed events, AI credit, token and gateway billing types, model routes and sessions, team agents, agent tokens, plan, review, message and confidence types, command rules, cost caps and confidence rules. The agents:run and models:* scopes are no longer offered by any preset, OAuth default or permission form, but a stored token or grant that names them still reads; and the removed operations are gone from the scope table, so the API's check that every operation has exactly one scope is strict again. What stored data needs in order to parse (old run and credential kinds, an agent team lead, retired rules and webhook events, old guardrail and integration settings) still parses, and a run's token is still PrincipalKind::Agent, which now means a run's token and the @g1t rows written before. The customize, marketplace, skills and claude-plugin contracts stay only until the mobile app drops its Customize screens.438 Scope::RunnersRead => "See self-hosted runners and their groups",
Mission control counts people's direct pushes to the default branch439 Scope::RunnersAdmin => "Register and remove self-hosted runners, change their groups and settings",
The contracts no longer describe g1t's own agents, and workspaces can keep their AI providers. Every consumer had already stopped using them, so the TypeScript and Rust contracts drop the workspace-agent, ability, look, skill-library, context, runner-agent and mention modules, the chat and docs RPCs agents posted and read through, the folio agent methods, the agent_waiting notification, agent.asked and memory.changed events, AI credit, token and gateway billing types, model routes and sessions, team agents, agent tokens, plan, review, message and confidence types, command rules, cost caps and confidence rules. The agents:run and models:* scopes are no longer offered by any preset, OAuth default or permission form, but a stored token or grant that names them still reads; and the removed operations are gone from the scope table, so the API's check that every operation has exactly one scope is strict again. What stored data needs in order to parse (old run and credential kinds, an agent team lead, retired rules and webhook events, old guardrail and integration settings) still parses, and a run's token is still PrincipalKind::Agent, which now means a run's token and the @g1t rows written before. The customize, marketplace, skills and claude-plugin contracts stay only until the mobile app drops its Customize screens.440 Scope::ModelsRead => "Retired: see the AI Gateway's requests. Grants nothing now",
441 Scope::ModelsWrite => "Retired: send requests through the AI Gateway. Grants nothing now",
Artifacts contracts: folios, their four kinds, dashboard datasets, folio events and the artifacts scopes are typed and validated the same in TypeScript and Rust, with nothing using them yet442 Scope::ArtifactsRead => "List, read and search artifacts you can see, their versions, and the numbers their dashboards show",
443 Scope::ArtifactsWrite => "Create, rename, move, edit, trash and restore artifacts, and propose changes to them",
444 Scope::ArtifactsAdmin => "Share artifacts, change who can open them, and delete them for good",
Mission control counts people's direct pushes to the default branch445 }
446 }
Artifacts contracts: folios, their four kinds, dashboard datasets, folio events and the artifacts scopes are typed and validated the same in TypeScript and Rust, with nothing using them yet447
448 /// Whether tokens are offered it yet: its resource's [`Resource::offered`].
449 pub fn offered(self) -> bool {
450 self.resource().offered()
451 }
452}
453
454/// Every scope tokens are offered, in table order: what OAuth advertises.
455pub fn offered_scopes() -> Vec<Scope> {
456 Scope::ALL.into_iter().filter(|scope| scope.offered()).collect()
Mission control counts people's direct pushes to the default branch457}
458
459impl Serialize for Scope {
460 fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
461 serializer.serialize_str(self.as_str())
462 }
463}
464
465impl<'de> Deserialize<'de> for Scope {
466 fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
467 let text = String::deserialize(deserializer)?;
468 Scope::parse(&text).ok_or_else(|| serde::de::Error::custom(format!("unknown scope {text}")))
469 }
470}
471
472/// Scopes as written in a token's row or an OAuth request: separated by
473/// spaces or commas. Unknown names are left out, so a client asking for a
474/// scope from a newer version gets the rest.
475pub fn parse_scopes(text: &str) -> Vec<Scope> {
476 let mut scopes: Vec<Scope> = text
477 .split(|c: char| c.is_whitespace() || c == ',')
478 .filter_map(Scope::parse)
Artifacts contracts: folios, their four kinds, dashboard datasets, folio events and the artifacts scopes are typed and validated the same in TypeScript and Rust, with nothing using them yet479 .filter(|scope| scope.offered())
Mission control counts people's direct pushes to the default branch480 .collect();
481 normalize(&mut scopes);
482 scopes
483}
484
485/// In table order, without repeats.
486pub fn normalize(scopes: &mut Vec<Scope>) {
487 let given = std::mem::take(scopes);
488 scopes.extend(Scope::ALL.into_iter().filter(|scope| given.contains(scope)));
489}
490
491/// Space-separated, as stored and as OAuth writes them.
492pub fn scopes_text(scopes: &[Scope]) -> String {
493 scopes.iter().map(|scope| scope.as_str()).collect::<Vec<_>>().join(" ")
494}
495
One kind of access token; presence and status; usernames keep their case; the tour is a miniature of the real app; icons for password managers496/// Where a resource sits on the token form, and which tokens may hold it.
497#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
498#[serde(rename_all = "snake_case")]
499pub enum ResourceGroup {
500 /// About repositories: what they hold and how they are run.
501 Repository,
502 /// About a workspace itself.
503 Workspace,
504 /// About the person: only a personal token may hold these.
505 Account,
506}
507
508impl ResourceGroup {
509 pub const ALL: [ResourceGroup; 3] = [ResourceGroup::Repository, ResourceGroup::Workspace, ResourceGroup::Account];
510
511 pub fn as_str(self) -> &'static str {
512 match self {
513 ResourceGroup::Repository => "repository",
514 ResourceGroup::Workspace => "workspace",
515 ResourceGroup::Account => "account",
516 }
517 }
518}
519
520impl Resource {
521 pub fn group(self) -> ResourceGroup {
522 match self {
The phone app: Chat in full with phone notifications, plus Code and Customize (#4)523 Resource::Account | Resource::Notifications | Resource::Chat => ResourceGroup::Account,
Artifacts contracts: folios, their four kinds, dashboard datasets, folio events and the artifacts scopes are typed and validated the same in TypeScript and Rust, with nothing using them yet524 Resource::Workspace | Resource::Billing | Resource::Runners | Resource::Models | Resource::Artifacts => ResourceGroup::Workspace,
One kind of access token; presence and status; usernames keep their case; the tour is a miniature of the real app; icons for password managers525 _ => ResourceGroup::Repository,
526 }
527 }
528
529 pub fn parse(text: &str) -> Option<Resource> {
530 let text = text.trim().to_ascii_lowercase();
531 Resource::ALL.into_iter().find(|resource| resource.as_str() == text)
532 }
533
534 /// Its scopes, least first.
535 pub fn scopes(self) -> Vec<Scope> {
536 Scope::ALL.into_iter().filter(|scope| scope.resource() == self).collect()
537 }
538}
539
540// --- Permissions --------------------------------------------------------------
541//
542// A token's permissions are its scopes read per resource: each resource
543// at none or one level (`{"issues": "write", "repo": "read"}`). A level
544// includes the ones below it, so the highest scope held of each resource
545// says everything; that is what a token stores. Personal tokens and a
546// workspace's own tokens are made, shown and checked this way alike.
547
548/// The highest scope of each resource held, in table order: the fewest
549/// scopes that give the same access, as tokens store them.
550pub fn top_scopes(scopes: &[Scope]) -> Vec<Scope> {
551 let mut top: Vec<Scope> = Vec::new();
552 for resource in Resource::ALL {
553 if let Some(best) = scopes.iter().filter(|scope| scope.resource() == resource).max_by_key(|scope| scope.level()) {
554 top.push(*best);
555 }
556 }
557 normalize(&mut top);
558 top
559}
560
561/// Every resource at its highest level: all a token can be given.
562pub fn everything() -> Vec<Scope> {
Artifacts contracts: folios, their four kinds, dashboard datasets, folio events and the artifacts scopes are typed and validated the same in TypeScript and Rust, with nothing using them yet563 top_scopes(&offered_scopes())
One kind of access token; presence and status; usernames keep their case; the tour is a miniature of the real app; icons for password managers564}
565
566/// Scopes as permissions: each resource held, by name, at its highest
567/// level held.
568pub fn permissions_of(scopes: &[Scope]) -> std::collections::BTreeMap<String, String> {
569 top_scopes(scopes)
570 .into_iter()
571 .map(|scope| (scope.resource().as_str().to_owned(), scope.level().as_str().to_owned()))
572 .collect()
573}
574
575/// Permissions as asked for (`{"issues": "write"}`, `none` or empty left
576/// out) into the scopes a token stores, or why they cannot be. `personal`
577/// is whether the token is a person's: only theirs may hold account ones.
578pub fn resolve_permissions(asked: &std::collections::BTreeMap<String, String>, personal: bool) -> Result<Vec<Scope>, String> {
579 let mut scopes = Vec::new();
580 for (name, level) in asked {
Artifacts contracts: folios, their four kinds, dashboard datasets, folio events and the artifacts scopes are typed and validated the same in TypeScript and Rust, with nothing using them yet581 let Some(resource) = Resource::parse(name).filter(|resource| resource.offered()) else {
One kind of access token; presence and status; usernames keep their case; the tour is a miniature of the real app; icons for password managers582 return Err(format!("There is no permission called {name}."));
583 };
584 let level = level.trim().to_ascii_lowercase();
585 if level.is_empty() || level == "none" {
586 continue;
587 }
588 let Some(scope) = Scope::parse(&format!("{}:{level}", resource.as_str())) else {
589 let levels: Vec<&str> = resource.scopes().iter().map(|scope| scope.level().as_str()).collect();
590 return Err(format!("{} is none or {}, not {level}.", resource.as_str(), levels.join(", ")));
591 };
592 if resource.group() == ResourceGroup::Account && !personal {
593 return Err(format!("{} is about a person's account: a workspace's token cannot hold it.", resource.as_str()));
594 }
595 scopes.push(scope);
596 }
597 Ok(top_scopes(&scopes))
598}
599
Mission control counts people's direct pushes to the default branch600/// What a token stores for full access, which is not a scope a client can
601/// ask for by name.
602pub const FULL_ACCESS: &str = "*";
603
604/// Starting points for choosing scopes.
605#[derive(Clone, Copy, Debug, PartialEq, Eq)]
606pub enum Preset {
607 ReadOnly,
608 Agent,
609 Ci,
610 Full,
611}
612
613impl Preset {
614 pub const ALL: [Preset; 4] = [Preset::ReadOnly, Preset::Agent, Preset::Ci, Preset::Full];
615
616 pub fn as_str(self) -> &'static str {
617 match self {
618 Preset::ReadOnly => "read_only",
619 Preset::Agent => "agent",
620 Preset::Ci => "ci",
621 Preset::Full => "full",
622 }
623 }
624
625 pub fn label(self) -> &'static str {
626 match self {
627 Preset::ReadOnly => "Read only",
628 Preset::Agent => "Agent",
629 Preset::Ci => "CI",
630 Preset::Full => "Full access",
631 }
632 }
633
634 /// Its scopes; `None` for full access.
635 pub fn scopes(self) -> Option<Vec<Scope>> {
The phone app: Chat in full with phone notifications, plus Code and Customize (#4)636 // Chat is not in any: a person's conversations go to an application
637 // only when it asks for them by name.
638 let reads = || {
639 Scope::ALL
640 .into_iter()
641 .filter(|scope| scope.level() == Level::Read && scope.offered() && scope.resource() != Resource::Chat)
642 };
Mission control counts people's direct pushes to the default branch643 match self {
644 Preset::ReadOnly => Some(reads().collect()),
645 Preset::Agent => {
646 // Not the machines work runs on: an agent has no business
647 // knowing a workspace's own runners.
648 let mut scopes: Vec<Scope> = reads().filter(|scope| scope.resource() != Resource::Runners).collect();
API: notifications over REST and MCP, with notifications scopes649 // And answering what needs the person it works for: marking
650 // it done, subscribing, watching.
Mission control counts people's direct pushes to the default branch651 scopes.extend([
652 Scope::CodeWrite,
653 Scope::IssuesWrite,
654 Scope::PullRequestsWrite,
655 Scope::MemoryWrite,
API: notifications over REST and MCP, with notifications scopes656 Scope::NotificationsWrite,
Mission control counts people's direct pushes to the default branch657 ]);
658 normalize(&mut scopes);
659 Some(scopes)
660 }
661 Preset::Ci => Some(vec![
662 Scope::RepoRead,
663 Scope::CodeRead,
664 Scope::CodeWrite,
665 Scope::PackagesRead,
666 Scope::PackagesWrite,
667 Scope::WorkflowsRead,
668 Scope::WorkflowsWrite,
Merge checks: statuses and check runs on every commit669 Scope::ChecksRead,
670 Scope::ChecksWrite,
Merge branch 'main' into worktree-agent-a69aeabc4b0deeb97671 Scope::DeploymentsRead,
672 Scope::DeploymentsWrite,
Mission control counts people's direct pushes to the default branch673 ]),
674 Preset::Full => None,
675 }
676 }
677}
678
679/// What an OAuth client gets when it asks for nothing in particular: the
680/// agent preset. Never an admin scope.
681pub fn oauth_default() -> Vec<Scope> {
682 Preset::Agent.scopes().unwrap_or_default()
683}
684
685/// Set on a [`crate::User`] resolved from an access token: what the token
686/// may do. Absent on a signed-in session, which may do whatever its person
687/// can.
688#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
689pub struct TokenAccess {
690 /// The token's id, as audit entries and errors name it.
691 #[serde(default)]
692 pub token_id: String,
693 /// Its scopes, as `resource:level`. Absent: full access, everything the
694 /// person (or workspace) can do.
695 #[serde(default, skip_serializing_if = "Option::is_none")]
696 pub scopes: Option<Vec<String>>,
697 /// Made before tokens had scopes: full access until someone narrows it.
698 #[serde(default, skip_serializing_if = "std::ops::Not::not")]
699 pub legacy: bool,
Merge branch 'worktree-agent-a3abfcce648e87dca'700 /// Set on a workflow job's token (`G1T_TOKEN`): the one repository it
701 /// reaches, as `owner/name`. Every other is refused, whatever its owner
702 /// could reach.
703 #[serde(default, skip_serializing_if = "Option::is_none")]
704 pub repo: Option<String>,
705 /// Set on a workflow job's token: the run and job it was made for. The
706 /// audit log records its changes as that job's, and what it changes
707 /// starts no workflows (only `workflow_dispatch` and
708 /// `repository_dispatch` do), so a workflow cannot set itself off.
709 #[serde(default, skip_serializing_if = "Option::is_none")]
710 pub job: Option<JobToken>,
Merge the AI Gateway: Anthropic's Messages API on a workspace's tokens711 /// The token's name, as its owner gave it, so a log can say which
712 /// token made a request. Absent where whoever resolved it did not say.
713 #[serde(default, skip_serializing_if = "Option::is_none")]
714 pub name: Option<String>,
One kind of access token; presence and status; usernames keep their case; the tour is a miniature of the real app; icons for password managers715 /// Set on a token narrowed to less than its owner can reach: one
716 /// workspace (all, selected or none of its private repositories), or
717 /// none at all (its owner's account and public repositories). Absent
718 /// on a token that reaches every workspace its owner can.
719 ///
720 /// The wire key is `fine_grained`, kept from before tokens were one
721 /// kind, so services deployed at different moments agree on it.
722 #[serde(rename = "fine_grained", default, skip_serializing_if = "Option::is_none")]
723 pub reach: Option<TokenReach>,
Token reach: workflow_files scope, fine-grained reach, workspace token cap724 /// Set on a workspace's own token that an owner gave Admin when making
725 /// it. Without it a workspace's token has Write on the workspace's
726 /// repositories, as a member would (see [`crate::access`]).
727 #[serde(default, skip_serializing_if = "std::ops::Not::not")]
728 pub admin: bool,
729 /// Set on what a repository's deploy key resolves to: the key's id. Its
730 /// `repo` is the one repository it reaches.
731 #[serde(default, skip_serializing_if = "Option::is_none")]
732 pub deploy_key: Option<String>,
Merge main into Artifacts Phase 2733 /// Set on a person's token whose owner let it use the website (g1t.sh)
734 /// as them, sent as `Authorization: Bearer`. Not a scope: no preset,
735 /// full access or OAuth grant includes it, and git, the API and MCP
736 /// ignore it.
737 #[serde(default, skip_serializing_if = "std::ops::Not::not")]
738 pub website: bool,
Token reach: workflow_files scope, fine-grained reach, workspace token cap739}
740
One kind of access token; presence and status; usernames keep their case; the tour is a miniature of the real app; icons for password managers741/// Which repositories a token reaches in the workspace it is made for.
Token reach: workflow_files scope, fine-grained reach, workspace token cap742#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
743#[serde(rename_all = "snake_case")]
744pub enum RepositorySelection {
745 /// Every repository of the workspace, ones made later included.
746 #[default]
747 All,
748 /// The repositories chosen, by id.
749 Selected,
750 /// None of the workspace's private repositories: public repositories,
751 /// read-only, and the workspace's own settings its permissions allow.
One kind of access token; presence and status; usernames keep their case; the tour is a miniature of the real app; icons for password managers752 /// With no workspace: the owner's account and public repositories only.
Token reach: workflow_files scope, fine-grained reach, workspace token cap753 Public,
Mission control counts people's direct pushes to the default branch754}
755
Token reach: workflow_files scope, fine-grained reach, workspace token cap756impl RepositorySelection {
757 pub fn as_str(self) -> &'static str {
758 match self {
759 RepositorySelection::All => "all",
760 RepositorySelection::Selected => "selected",
761 RepositorySelection::Public => "public",
762 }
763 }
764
765 pub fn parse(text: &str) -> Option<RepositorySelection> {
766 match text.trim().to_ascii_lowercase().as_str() {
767 "all" => Some(RepositorySelection::All),
768 "selected" => Some(RepositorySelection::Selected),
769 "public" | "public_only" | "none" => Some(RepositorySelection::Public),
770 _ => None,
771 }
772 }
773}
774
One kind of access token; presence and status; usernames keep their case; the tour is a miniature of the real app; icons for password managers775/// What a narrowed token reaches, as identity resolves it on each use.
Token reach: workflow_files scope, fine-grained reach, workspace token cap776#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
One kind of access token; presence and status; usernames keep their case; the tour is a miniature of the real app; icons for password managers777pub struct TokenReach {
778 /// The workspace whose repositories and settings it reaches, by slug as
779 /// it is now. Absent: its owner's account only, with public
780 /// repositories read-only.
Token reach: workflow_files scope, fine-grained reach, workspace token cap781 #[serde(default, skip_serializing_if = "Option::is_none")]
782 pub workspace: Option<String>,
783 #[serde(default)]
784 pub repositories: RepositorySelection,
785 /// With [`RepositorySelection::Selected`]: the repositories' ids.
786 #[serde(default, skip_serializing_if = "Vec::is_empty")]
787 pub repo_ids: Vec<String>,
788}
789
One kind of access token; presence and status; usernames keep their case; the tour is a miniature of the real app; icons for password managers790impl TokenReach {
Token reach: workflow_files scope, fine-grained reach, workspace token cap791 /// Whether it reaches the repository with this id in the workspace
792 /// `namespace` for more than what anyone may do with a public one.
793 pub fn covers(&self, repo_id: &str, namespace: &str) -> bool {
794 let Some(workspace) = self.workspace.as_deref() else {
795 return false;
796 };
797 if !workspace.eq_ignore_ascii_case(namespace) {
798 return false;
799 }
800 match self.repositories {
801 RepositorySelection::All => true,
802 RepositorySelection::Selected => self.repo_ids.iter().any(|id| id == repo_id),
803 RepositorySelection::Public => false,
804 }
805 }
806
One kind of access token; presence and status; usernames keep their case; the tour is a miniature of the real app; icons for password managers807 /// Whether it is made for the workspace `slug`.
Token reach: workflow_files scope, fine-grained reach, workspace token cap808 pub fn owned_by(&self, slug: &str) -> bool {
809 self.workspace.as_deref().is_some_and(|workspace| workspace.eq_ignore_ascii_case(slug))
810 }
811}
812
813/// Where workflow files live. Adding, changing or deleting a file under
814/// one, with git or through g1t, needs [`Scope::WorkflowFilesWrite`] from a
815/// token: what GitHub's `workflow` scope and `workflows` permission do.
816pub const WORKFLOW_DIRS: [&str; 2] = [".g1t/workflows/", ".github/workflows/"];
817
818/// Whether `path` is a workflow file, or a file in one's directory.
819pub fn is_workflow_file(path: &str) -> bool {
820 let path = path.trim_start_matches('/');
821 WORKFLOW_DIRS.iter().any(|dir| {
822 path.len() >= dir.len() && path.is_char_boundary(dir.len()) && path[..dir.len()].eq_ignore_ascii_case(dir)
823 }) || WORKFLOW_DIRS.iter().any(|dir| path.eq_ignore_ascii_case(dir.trim_end_matches('/')))
824}
825
826/// Whether a token may add, change or delete the files at `paths`: a
827/// refusal naming the first workflow file it may not touch, else `None`.
828/// A signed-in person (no token) is never refused here; their role decides.
829pub fn decide_workflow_files<'a>(access: Option<&TokenAccess>, paths: impl IntoIterator<Item = &'a str>) -> Option<Decision> {
830 let access = access?;
831 if access.allows(Scope::WorkflowFilesWrite) && access.job.is_none() {
832 return None;
833 }
834 let path = paths.into_iter().find(|path| is_workflow_file(path))?;
835 let why = if access.job.is_some() {
836 "a workflow job's token can never add or change workflow files".to_owned()
837 } else {
838 format!("it needs the {} scope", Scope::WorkflowFilesWrite.as_str())
839 };
840 Some(Decision::deny(
841 "token:workflows",
842 format!("This access token cannot change the workflow file {path}: {why}."),
843 ))
844}
845
Merge branch 'worktree-agent-a3abfcce648e87dca'846/// The workflow job a token was made for.
847#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
848pub struct JobToken {
849 /// The run, `run_…`.
850 pub run_id: String,
851 /// The job, `job_…`.
852 pub job_id: String,
853 /// Whether it may open pull requests and approve them, by its
854 /// repository's and workspace's choice ("Allow g1t Actions to create and
855 /// approve pull requests"). Off unless chosen.
856 #[serde(default)]
857 pub pull_requests: bool,
858}
859
Mission control counts people's direct pushes to the default branch860impl TokenAccess {
861 /// Full access to everything: the access tokens made before scopes had.
862 pub fn full() -> Self {
863 TokenAccess::default()
864 }
865
Merge branch 'worktree-agent-a3abfcce648e87dca'866 /// Whether it may reach the repository `owner/name`: every token but a
867 /// workflow job's, which reaches its own repository only.
868 pub fn reaches(&self, repo: &str) -> bool {
869 self.repo.as_deref().is_none_or(|only| only.eq_ignore_ascii_case(repo))
870 }
871
Mission control counts people's direct pushes to the default branch872 pub fn is_full(&self) -> bool {
873 self.scopes.is_none()
874 }
875
876 /// The scopes it holds, or `None` for full access.
877 pub fn granted(&self) -> Option<Vec<Scope>> {
878 self.scopes
879 .as_ref()
880 .map(|scopes| scopes.iter().filter_map(|scope| Scope::parse(scope)).collect())
881 }
882
883 pub fn allows(&self, needed: Scope) -> bool {
884 match self.granted() {
885 None => true,
886 Some(granted) => granted.iter().any(|held| held.includes(needed)),
887 }
888 }
Token reach: workflow_files scope, fine-grained reach, workspace token cap889
890 /// Whether it reaches the repository with this id in `namespace` for
One kind of access token; presence and status; usernames keep their case; the tour is a miniature of the real app; icons for password managers891 /// more than reading a public one: every token but a narrowed one
892 /// outside its workspace or repository selection. Its owner's role
Token reach: workflow_files scope, fine-grained reach, workspace token cap893 /// still decides; see [`crate::access`].
894 pub fn covers_repo(&self, repo_id: &str, namespace: &str) -> bool {
One kind of access token; presence and status; usernames keep their case; the tour is a miniature of the real app; icons for password managers895 self.reach.as_ref().is_none_or(|reach| reach.covers(repo_id, namespace))
Token reach: workflow_files scope, fine-grained reach, workspace token cap896 }
Mission control counts people's direct pushes to the default branch897}
898
899/// Every operation of the API and MCP server, with the scope it needs. An
900/// operation in [`NO_SCOPE`] needs none. The API checks that every one of
901/// its operations is in exactly one of the two.
902pub const OPERATIONS: &[(&str, Scope)] = &[
903 // Your account.
904 ("list_emails", Scope::AccountRead),
905 ("add_email", Scope::AccountWrite),
Merge email confirmation gate: a code and a link, nothing until confirmed (identity 0036)906 ("confirm_email", Scope::AccountWrite),
Mission control counts people's direct pushes to the default branch907 ("remove_email", Scope::AccountWrite),
908 ("update_email_settings", Scope::AccountWrite),
Merge workspace invitations: nobody joins a workspace without saying yes, people are found by username, your own invites can bring someone in, and nobody is left without a workspace (identity 0040)909 ("list_invitations", Scope::AccountRead),
910 ("accept_invitation", Scope::AccountWrite),
911 ("decline_invitation", Scope::AccountWrite),
Mission control counts people's direct pushes to the default branch912 ("list_my_repo_invitations", Scope::AccountRead),
913 ("accept_repo_invitation", Scope::AccountWrite),
914 ("decline_repo_invitation", Scope::AccountWrite),
API: pinned projects over REST and MCP915 // Your pinned projects: a preference of your account.
916 ("list_pinned_projects", Scope::AccountRead),
917 ("pin_project", Scope::AccountWrite),
Merge branch 'main' into worktree-agent-a69aeabc4b0deeb97918 // Your stars: a preference of your account.
919 ("list_starred", Scope::AccountRead),
920 ("check_starred", Scope::AccountRead),
921 ("star_repo", Scope::AccountWrite),
922 ("unstar_repo", Scope::AccountWrite),
API: pinned projects over REST and MCP923 ("unpin_project", Scope::AccountWrite),
924 ("reorder_pinned_projects", Scope::AccountWrite),
API: notifications over REST and MCP, with notifications scopes925 // Your inbox: notifications, subscriptions and watching.
926 ("list_notifications", Scope::NotificationsRead),
927 ("get_notification_thread", Scope::NotificationsRead),
928 ("get_thread_subscription", Scope::NotificationsRead),
929 ("get_repo_subscription", Scope::NotificationsRead),
930 ("list_watched_repos", Scope::NotificationsRead),
931 ("mark_notifications_read", Scope::NotificationsWrite),
932 ("mark_thread_read", Scope::NotificationsWrite),
933 ("mark_thread_done", Scope::NotificationsWrite),
934 ("save_thread", Scope::NotificationsWrite),
935 ("snooze_thread", Scope::NotificationsWrite),
936 ("set_thread_subscription", Scope::NotificationsWrite),
937 ("delete_thread_subscription", Scope::NotificationsWrite),
938 ("set_repo_subscription", Scope::NotificationsWrite),
939 ("delete_repo_subscription", Scope::NotificationsWrite),
Mission control counts people's direct pushes to the default branch940 // Workspaces, their invites and integrations.
941 ("create_workspace", Scope::WorkspaceAdmin),
942 ("delete_workspace", Scope::WorkspaceAdmin),
Merge branch 'worktree-agent-ad7c6d88d93adc817'943 ("get_workspace", Scope::WorkspaceRead),
Mission control counts people's direct pushes to the default branch944 ("update_workspace", Scope::WorkspaceAdmin),
Merge main (membership, two-factor, GitHub repo roles) into tokens945 // Its members, and who owns it.
946 ("list_members", Scope::WorkspaceRead),
947 ("update_member", Scope::WorkspaceAdmin),
948 ("remove_member", Scope::WorkspaceAdmin),
949 ("transfer_ownership", Scope::WorkspaceAdmin),
950 ("leave_workspace", Scope::AccountWrite),
Mission control counts people's direct pushes to the default branch951 ("list_workspace_invites", Scope::WorkspaceRead),
952 ("invite_member", Scope::WorkspaceAdmin),
953 ("revoke_workspace_invite", Scope::WorkspaceAdmin),
954 ("list_integrations", Scope::WorkspaceRead),
955 ("connect_integration", Scope::WorkspaceAdmin),
AI Gateway: OpenAI's format, open models, and your own providers956 ("update_integration", Scope::WorkspaceAdmin),
Mission control counts people's direct pushes to the default branch957 ("disconnect_integration", Scope::WorkspaceAdmin),
958 ("test_integration", Scope::WorkspaceAdmin),
Teams and CODEOWNERS, labels and milestones, dependency updates, the security suite, and a clearer top bar959 // Teams: reading them, and managing them. A team's role on a
960 // repository is who has access.
961 ("list_teams", Scope::WorkspaceRead),
962 ("get_team", Scope::WorkspaceRead),
963 ("list_team_members", Scope::WorkspaceRead),
964 ("list_child_teams", Scope::WorkspaceRead),
965 ("list_team_repos", Scope::WorkspaceRead),
966 ("list_user_teams", Scope::WorkspaceRead),
967 ("create_team", Scope::WorkspaceAdmin),
Merge rulesets: branch and tag rules, agent-first, enforced on push and merge968 ("list_workspace_rulesets", Scope::WorkspaceRead),
969 ("get_workspace_ruleset", Scope::WorkspaceRead),
970 ("list_workspace_rule_evaluations", Scope::WorkspaceRead),
971 ("create_workspace_ruleset", Scope::WorkspaceAdmin),
972 ("update_workspace_ruleset", Scope::WorkspaceAdmin),
973 ("delete_workspace_ruleset", Scope::WorkspaceAdmin),
Teams and CODEOWNERS, labels and milestones, dependency updates, the security suite, and a clearer top bar974 ("update_team", Scope::WorkspaceAdmin),
975 ("delete_team", Scope::WorkspaceAdmin),
976 ("set_team_member", Scope::WorkspaceAdmin),
977 ("remove_team_member", Scope::WorkspaceAdmin),
978 ("set_team_review_assignment", Scope::WorkspaceAdmin),
The contracts no longer describe g1t's own agents, and workspaces can keep their AI providers. Every consumer had already stopped using them, so the TypeScript and Rust contracts drop the workspace-agent, ability, look, skill-library, context, runner-agent and mention modules, the chat and docs RPCs agents posted and read through, the folio agent methods, the agent_waiting notification, agent.asked and memory.changed events, AI credit, token and gateway billing types, model routes and sessions, team agents, agent tokens, plan, review, message and confidence types, command rules, cost caps and confidence rules. The agents:run and models:* scopes are no longer offered by any preset, OAuth default or permission form, but a stored token or grant that names them still reads; and the removed operations are gone from the scope table, so the API's check that every operation has exactly one scope is strict again. What stored data needs in order to parse (old run and credential kinds, an agent team lead, retired rules and webhook events, old guardrail and integration settings) still parses, and a run's token is still PrincipalKind::Agent, which now means a run's token and the @g1t rows written before. The customize, marketplace, skills and claude-plugin contracts stay only until the mobile app drops its Customize screens.979 // A workspace's billing: usage, budget and invoices.
Usage, Billing settings and prepaid AI credit; fixes from the UX audit980 ("get_usage", Scope::BillingRead),
981 ("get_budget", Scope::BillingRead),
982 ("list_invoices", Scope::BillingRead),
983 ("get_billing_details", Scope::BillingRead),
984 ("set_budget", Scope::BillingWrite),
Mission control counts people's direct pushes to the default branch985 // Repositories.
986 ("list_repos", Scope::RepoRead),
987 ("get_repo", Scope::RepoRead),
Merge GitHub pull request #8 (claude/cool-newton-7nm8r9): Docker deployments on g1t.page behind a switch that stays off until Cloudflare's container APIs are checked live, workflows a workspace manages in its repositories, tarball and zipball downloads, refs/pull/* kept to g1t alone, framework detection for g1t.page builds, and a workflow's event payload matching GitHub's.988 // A repository's files, as clone and fetch need.
989 ("download_tarball_archive", Scope::CodeRead),
990 ("download_zipball_archive", Scope::CodeRead),
Merge branch 'main' into worktree-agent-a69aeabc4b0deeb97991 // Projects follow their repositories.
992 ("list_projects", Scope::RepoRead),
993 ("get_project", Scope::RepoRead),
Mission control counts people's direct pushes to the default branch994 ("search", Scope::RepoRead),
995 ("list_events", Scope::RepoRead),
Merge branch 'main' into worktree-agent-a69aeabc4b0deeb97996 // What the default branch says about a repository, who starred it, and
997 // its releases.
998 ("get_languages", Scope::RepoRead),
999 ("list_contributors", Scope::RepoRead),
1000 ("get_license", Scope::RepoRead),
1001 ("list_stargazers", Scope::RepoRead),
1002 ("list_releases", Scope::RepoRead),
1003 ("get_latest_release", Scope::RepoRead),
1004 ("get_release_by_tag", Scope::RepoRead),
1005 ("get_release", Scope::RepoRead),
1006 ("create_release", Scope::RepoWrite),
1007 ("update_release", Scope::RepoWrite),
1008 ("delete_release", Scope::RepoWrite),
Mission control counts people's direct pushes to the default branch1009 ("list_labels", Scope::RepoRead),
Teams and CODEOWNERS, labels and milestones, dependency updates, the security suite, and a clearer top bar1010 ("list_milestones", Scope::RepoRead),
1011 ("get_milestone", Scope::RepoRead),
1012 ("create_label", Scope::IssuesWrite),
1013 ("update_label", Scope::IssuesWrite),
1014 ("delete_label", Scope::IssuesWrite),
1015 ("add_default_labels", Scope::IssuesWrite),
1016 ("create_milestone", Scope::IssuesWrite),
1017 ("update_milestone", Scope::IssuesWrite),
1018 ("delete_milestone", Scope::IssuesWrite),
Mission control counts people's direct pushes to the default branch1019 ("get_repo_settings", Scope::RepoRead),
1020 ("list_check_names", Scope::RepoRead),
1021 ("list_deleted_repos", Scope::RepoRead),
1022 ("list_security_alerts", Scope::RepoRead),
Teams and CODEOWNERS, labels and milestones, dependency updates, the security suite, and a clearer top bar1023 ("get_codeowners_errors", Scope::RepoRead),
Mission control counts people's direct pushes to the default branch1024 ("create_repo", Scope::RepoWrite),
1025 ("update_repo", Scope::RepoWrite),
Merge branch 'main' into worktree-agent-a69aeabc4b0deeb971026 ("update_project", Scope::RepoWrite),
Mission control counts people's direct pushes to the default branch1027 ("update_repo_settings", Scope::RepoWrite),
Merge rulesets: branch and tag rules, agent-first, enforced on push and merge1028 // Rulesets: reading them is reading the repository; changing them
1029 // changes what everyone, agents included, may do, so it is admin.
1030 ("list_repo_rulesets", Scope::RepoRead),
1031 ("get_repo_ruleset", Scope::RepoRead),
1032 ("get_branch_rules", Scope::RepoRead),
1033 ("list_rule_evaluations", Scope::RepoRead),
1034 ("create_repo_ruleset", Scope::RepoAdmin),
1035 ("update_repo_ruleset", Scope::RepoAdmin),
1036 ("delete_repo_ruleset", Scope::RepoAdmin),
Mission control counts people's direct pushes to the default branch1037 ("rename_branch", Scope::RepoWrite),
The Branches page does things to branches now. It has tabs (Overview, Yours, Active, Stale, All, kept in the address as ?tab=) and search; Overview shows the default branch, then the first five of your branches, the active ones and the stale ones, each linking to the rest. Each branch is a row with its name in a code chip with a copy button, who made its latest commit and when, that commit's checks, behind and ahead counts with bars drawn against the largest shown, and its pull request (the open one, else the newest merged or closed) with its state; on a phone the columns fold under the name. Yours is branches whose latest commit is the viewer's; stale is no commit in 90 days.1038 ("create_branch", Scope::RepoWrite),
1039 ("delete_branch", Scope::RepoWrite),
Mission control counts people's direct pushes to the default branch1040 ("rename_repo", Scope::RepoAdmin),
1041 ("transfer_repo", Scope::RepoAdmin),
1042 ("archive_repo", Scope::RepoAdmin),
1043 ("unarchive_repo", Scope::RepoAdmin),
1044 ("set_repo_visibility", Scope::RepoAdmin),
1045 ("delete_repo", Scope::RepoAdmin),
1046 ("restore_repo", Scope::RepoAdmin),
1047 ("purge_repo", Scope::RepoAdmin),
1048 // A dismissed secret is let through push protection.
1049 ("dismiss_security_alert", Scope::RepoAdmin),
1050 ("reopen_security_alert", Scope::RepoAdmin),
Teams and CODEOWNERS, labels and milestones, dependency updates, the security suite, and a clearer top bar1051 // The security suite: alerts, push protection, patterns, code
1052 // scanning, the supply chain and settings.
1053 ("list_secret_scanning_alerts", Scope::SecurityRead),
1054 ("get_secret_scanning_alert", Scope::SecurityRead),
1055 ("list_secret_scanning_locations", Scope::SecurityRead),
1056 ("list_bypass_requests", Scope::SecurityRead),
1057 ("list_custom_patterns", Scope::SecurityRead),
1058 ("list_code_scanning_alerts", Scope::SecurityRead),
1059 ("get_code_scanning_alert", Scope::SecurityRead),
1060 ("list_code_scanning_analyses", Scope::SecurityRead),
1061 ("get_sarif_upload", Scope::SecurityRead),
1062 ("list_vulnerability_alerts", Scope::SecurityRead),
1063 ("get_vulnerability_alert", Scope::SecurityRead),
1064 ("get_dependency_graph", Scope::SecurityRead),
1065 ("get_sbom", Scope::SecurityRead),
1066 ("compare_dependencies", Scope::SecurityRead),
1067 ("get_security_settings", Scope::SecurityRead),
1068 ("get_workspace_security_settings", Scope::SecurityRead),
1069 ("get_security_overview", Scope::SecurityRead),
Merge remote-tracking branch 'origin/claude/cool-newton-7nm8r9' into claude/cool-newton-7nm8r91070 ("list_security_advisories", Scope::SecurityRead),
1071 ("get_security_advisory", Scope::SecurityRead),
1072 ("list_vulnerability_reports", Scope::SecurityRead),
Teams and CODEOWNERS, labels and milestones, dependency updates, the security suite, and a clearer top bar1073 ("update_secret_scanning_alert", Scope::SecurityWrite),
1074 ("bypass_push_protection", Scope::SecurityWrite),
1075 ("check_secret_validity", Scope::SecurityWrite),
1076 ("review_bypass_request", Scope::SecurityWrite),
1077 ("create_custom_pattern", Scope::SecurityWrite),
1078 ("update_custom_pattern", Scope::SecurityWrite),
1079 ("delete_custom_pattern", Scope::SecurityWrite),
1080 ("dry_run_custom_pattern", Scope::SecurityWrite),
1081 ("update_code_scanning_alert", Scope::SecurityWrite),
1082 ("upload_sarif", Scope::SecurityWrite),
1083 ("update_vulnerability_alert", Scope::SecurityWrite),
1084 ("update_security_settings", Scope::SecurityWrite),
1085 ("update_workspace_security_settings", Scope::SecurityWrite),
Merge remote-tracking branch 'origin/claude/cool-newton-7nm8r9' into claude/cool-newton-7nm8r91086 ("create_security_advisory", Scope::SecurityWrite),
1087 ("update_security_advisory", Scope::SecurityWrite),
1088 ("set_security_advisory_state", Scope::SecurityWrite),
1089 ("report_vulnerability", Scope::SecurityWrite),
1090 ("review_vulnerability_report", Scope::SecurityWrite),
The contracts no longer describe g1t's own agents, and workspaces can keep their AI providers. Every consumer had already stopped using them, so the TypeScript and Rust contracts drop the workspace-agent, ability, look, skill-library, context, runner-agent and mention modules, the chat and docs RPCs agents posted and read through, the folio agent methods, the agent_waiting notification, agent.asked and memory.changed events, AI credit, token and gateway billing types, model routes and sessions, team agents, agent tokens, plan, review, message and confidence types, command rules, cost caps and confidence rules. The agents:run and models:* scopes are no longer offered by any preset, OAuth default or permission form, but a stored token or grant that names them still reads; and the removed operations are gone from the scope table, so the API's check that every operation has exactly one scope is strict again. What stored data needs in order to parse (old run and credential kinds, an agent team lead, retired rules and webhook events, old guardrail and integration settings) still parses, and a run's token is still PrincipalKind::Agent, which now means a run's token and the @g1t rows written before. The customize, marketplace, skills and claude-plugin contracts stay only until the mobile app drops its Customize screens.1091 // Issues.
Mission control counts people's direct pushes to the default branch1092 ("list_issues", Scope::IssuesRead),
1093 ("get_issue", Scope::IssuesRead),
1094 ("create_issue", Scope::IssuesWrite),
1095 ("update_issue", Scope::IssuesWrite),
Teams and CODEOWNERS, labels and milestones, dependency updates, the security suite, and a clearer top bar1096 ("list_issue_labels", Scope::IssuesRead),
1097 ("add_issue_labels", Scope::IssuesWrite),
1098 ("set_issue_labels", Scope::IssuesWrite),
1099 ("remove_issue_labels", Scope::IssuesWrite),
Mission control counts people's direct pushes to the default branch1100 ("close_issue", Scope::IssuesWrite),
1101 ("reopen_issue", Scope::IssuesWrite),
1102 ("add_comment", Scope::IssuesWrite),
Merge Actions: cross-repo workflows and actions, release and deployment triggers, step timeouts1103 ("edit_comment", Scope::IssuesWrite),
1104 ("delete_comment", Scope::IssuesWrite),
Mission control counts people's direct pushes to the default branch1105 ("import_issue", Scope::IssuesWrite),
1106 // Pull requests.
1107 ("list_pull_requests", Scope::PullRequestsRead),
1108 ("get_pull_request", Scope::PullRequestsRead),
1109 ("get_pull_request_changes", Scope::PullRequestsRead),
1110 ("read_session", Scope::PullRequestsRead),
1111 ("get_merge_queue", Scope::PullRequestsRead),
1112 ("create_pull_request", Scope::PullRequestsWrite),
Teams and CODEOWNERS, labels and milestones, dependency updates, the security suite, and a clearer top bar1113 ("update_pull_request", Scope::PullRequestsWrite),
Mission control counts people's direct pushes to the default branch1114 ("record_session", Scope::PullRequestsWrite),
1115 ("mark_pull_request_ready", Scope::PullRequestsWrite),
1116 ("close_pull_request", Scope::PullRequestsWrite),
Merge Actions: cross-repo workflows and actions, release and deployment triggers, step timeouts1117 ("reopen_pull_request", Scope::PullRequestsWrite),
1118 ("convert_pull_request_to_draft", Scope::PullRequestsWrite),
Mission control counts people's direct pushes to the default branch1119 ("review_pull_request", Scope::PullRequestsWrite),
1120 ("merge_pull_request", Scope::PullRequestsWrite),
Teams and CODEOWNERS, labels and milestones, dependency updates, the security suite, and a clearer top bar1121 ("request_reviewers", Scope::PullRequestsWrite),
1122 ("remove_requested_reviewers", Scope::PullRequestsWrite),
Mission control counts people's direct pushes to the default branch1123 // Workflows.
1124 ("list_workflows", Scope::WorkflowsRead),
1125 ("list_workflow_runs", Scope::WorkflowsRead),
1126 ("get_workflow_run", Scope::WorkflowsRead),
1127 ("get_job_logs", Scope::WorkflowsRead),
1128 ("dispatch_workflow", Scope::WorkflowsWrite),
1129 ("cancel_workflow_run", Scope::WorkflowsWrite),
1130 ("rerun_workflow_run", Scope::WorkflowsWrite),
1131 ("update_workflow", Scope::WorkflowsWrite),
Actions: OIDC tokens, the toolkit's cache and artifact services, and artifacts in R21132 ("list_artifacts", Scope::WorkflowsRead),
1133 ("list_workflow_run_artifacts", Scope::WorkflowsRead),
1134 ("get_artifact", Scope::WorkflowsRead),
1135 ("download_artifact", Scope::WorkflowsRead),
1136 ("get_artifact_retention", Scope::WorkflowsRead),
1137 ("delete_artifact", Scope::WorkflowsWrite),
1138 ("set_artifact_retention", Scope::WorkflowsWrite),
Merge checks: statuses and check runs on every commit1139 // Checks: statuses, check runs and check suites on commits.
1140 ("list_commit_statuses", Scope::ChecksRead),
1141 ("get_combined_status", Scope::ChecksRead),
1142 ("list_check_runs_for_ref", Scope::ChecksRead),
1143 ("get_check_run", Scope::ChecksRead),
1144 ("list_check_run_annotations", Scope::ChecksRead),
1145 ("list_check_suites_for_ref", Scope::ChecksRead),
1146 ("get_check_suite", Scope::ChecksRead),
1147 ("create_commit_status", Scope::ChecksWrite),
1148 ("create_check_run", Scope::ChecksWrite),
1149 ("update_check_run", Scope::ChecksWrite),
1150 ("rerequest_check_run", Scope::ChecksWrite),
1151 ("rerequest_check_suite", Scope::ChecksWrite),
Merge branch 'main' into worktree-agent-a69aeabc4b0deeb971152 // Deployments, wherever they run: reading them, and reporting them.
1153 ("list_deployments", Scope::DeploymentsRead),
1154 ("get_deployment", Scope::DeploymentsRead),
1155 ("list_deployment_statuses", Scope::DeploymentsRead),
1156 ("list_environments", Scope::DeploymentsRead),
1157 ("get_environment", Scope::DeploymentsRead),
1158 ("create_deployment", Scope::DeploymentsWrite),
1159 ("create_deployment_status", Scope::DeploymentsWrite),
Merge branch 'worktree-agent-a4d35ee70c50683d0' into claude/cool-newton-7nm8r91160 ("start_deployment_build", Scope::DeploymentsWrite),
Projects have Observability: their requests, logs, traces, metrics and errors, from apps on g1t.page with nothing to set up, and from software anywhere else over OpenTelemetry.1161 // Observability: what a project's software did, and how it is collected.
1162 ("get_observability_overview", Scope::ObservabilityRead),
1163 ("list_requests", Scope::ObservabilityRead),
1164 ("get_request", Scope::ObservabilityRead),
1165 ("list_logs", Scope::ObservabilityRead),
1166 ("list_traces", Scope::ObservabilityRead),
1167 ("get_trace", Scope::ObservabilityRead),
1168 ("list_errors", Scope::ObservabilityRead),
1169 ("list_metrics", Scope::ObservabilityRead),
1170 ("get_metric", Scope::ObservabilityRead),
1171 ("get_observability_settings", Scope::ObservabilityRead),
1172 ("list_ingest_tokens", Scope::ObservabilityRead),
1173 ("list_telemetry_exports", Scope::ObservabilityRead),
1174 ("get_observability_usage", Scope::ObservabilityRead),
1175 ("update_error", Scope::ObservabilityWrite),
1176 ("update_observability_settings", Scope::ObservabilityWrite),
1177 ("create_ingest_token", Scope::ObservabilityWrite),
1178 ("delete_ingest_token", Scope::ObservabilityWrite),
1179 ("create_telemetry_export", Scope::ObservabilityWrite),
1180 ("update_telemetry_export", Scope::ObservabilityWrite),
1181 ("delete_telemetry_export", Scope::ObservabilityWrite),
Merge branch 'worktree-agent-a3abfcce648e87dca'1182 // What keeps runs safe: the runs environments hold and reviewing them,
1183 // approving a pull request's run, and a repository's own rules for
1184 // its environments and tokens, which are an admin's.
1185 ("get_pending_deployments", Scope::WorkflowsRead),
1186 ("review_pending_deployments", Scope::WorkflowsWrite),
1187 ("approve_workflow_run", Scope::WorkflowsWrite),
1188 ("get_workflow_permissions", Scope::RepoRead),
1189 ("get_fork_pr_approval", Scope::RepoRead),
Merge Actions: cross-repo workflows and actions, release and deployment triggers, step timeouts1190 ("get_actions_access", Scope::RepoRead),
Merge branch 'worktree-agent-a3abfcce648e87dca'1191 ("update_environment", Scope::RepoAdmin),
1192 ("delete_environment", Scope::RepoAdmin),
1193 ("set_workflow_permissions", Scope::RepoAdmin),
1194 ("set_fork_pr_approval", Scope::RepoAdmin),
Merge Actions: cross-repo workflows and actions, release and deployment triggers, step timeouts1195 ("set_actions_access", Scope::RepoAdmin),
Merge branch 'worktree-agent-a3abfcce648e87dca'1196 // Starting workflows from outside, as a push would.
1197 ("create_repository_dispatch", Scope::CodeWrite),
1198 // A workspace's policy for its repositories' tokens.
1199 ("get_workspace_workflow_permissions", Scope::WorkspaceRead),
1200 ("set_workspace_workflow_permissions", Scope::WorkspaceAdmin),
Merge GitHub pull request #8 (claude/cool-newton-7nm8r9): Docker deployments on g1t.page behind a switch that stays off until Cloudflare's container APIs are checked live, workflows a workspace manages in its repositories, tarball and zipball downloads, refs/pull/* kept to g1t alone, framework detection for g1t.page builds, and a workflow's event payload matching GitHub's.1201 // The workflows a workspace runs in its repositories: its owners'.
1202 ("list_workspace_managed_workflows", Scope::WorkspaceRead),
1203 ("create_workspace_managed_workflow", Scope::WorkspaceAdmin),
1204 ("update_workspace_managed_workflow", Scope::WorkspaceAdmin),
1205 ("delete_workspace_managed_workflow", Scope::WorkspaceAdmin),
API and MCP for a workspace's personal access token rules, members' tokens and approvals1206 // A workspace's rules for personal access tokens, and the members'
1207 // tokens that reach it: who has access.
1208 ("get_token_policy", Scope::WorkspaceRead),
1209 ("set_token_policy", Scope::WorkspaceAdmin),
1210 ("list_member_tokens", Scope::AccessRead),
1211 ("list_token_requests", Scope::AccessRead),
1212 ("review_token_request", Scope::AccessAdmin),
1213 ("revoke_member_token", Scope::AccessAdmin),
The contracts no longer describe g1t's own agents, and workspaces can keep their AI providers. Every consumer had already stopped using them, so the TypeScript and Rust contracts drop the workspace-agent, ability, look, skill-library, context, runner-agent and mention modules, the chat and docs RPCs agents posted and read through, the folio agent methods, the agent_waiting notification, agent.asked and memory.changed events, AI credit, token and gateway billing types, model routes and sessions, team agents, agent tokens, plan, review, message and confidence types, command rules, cost caps and confidence rules. The agents:run and models:* scopes are no longer offered by any preset, OAuth default or permission form, but a stored token or grant that names them still reads; and the removed operations are gone from the scope table, so the API's check that every operation has exactly one scope is strict again. What stored data needs in order to parse (old run and credential kinds, an agent team lead, retired rules and webhook events, old guardrail and integration settings) still parses, and a run's token is still PrincipalKind::Agent, which now means a run's token and the @g1t rows written before. The customize, marketplace, skills and claude-plugin contracts stay only until the mobile app drops its Customize screens.1214 // Memory.
Mission control counts people's direct pushes to the default branch1215 ("recall", Scope::MemoryRead),
1216 ("get_context", Scope::MemoryRead),
1217 ("remember", Scope::MemoryWrite),
1218 // Who has access.
1219 ("list_collaborators", Scope::AccessRead),
1220 ("get_collaborator_permission", Scope::AccessRead),
1221 ("list_repo_invitations", Scope::AccessRead),
1222 ("list_outside_collaborators", Scope::AccessRead),
1223 ("add_collaborator", Scope::AccessAdmin),
1224 ("update_collaborator", Scope::AccessAdmin),
1225 ("remove_collaborator", Scope::AccessAdmin),
1226 ("revoke_repo_invitation", Scope::AccessAdmin),
1227 ("set_base_permission", Scope::AccessAdmin),
Teams and CODEOWNERS, labels and milestones, dependency updates, the security suite, and a clearer top bar1228 ("set_team_repo", Scope::AccessAdmin),
1229 ("remove_team_repo", Scope::AccessAdmin),
Merge branch 'worktree-agent-a5a5de74d8863d554' into worktree-agent-a16631325aecf58ca1230 // Deploy keys: each lets a machine reach one repository, so they
1231 // are part of who has access.
1232 ("list_deploy_keys", Scope::AccessRead),
1233 ("get_deploy_key", Scope::AccessRead),
1234 ("create_deploy_key", Scope::AccessAdmin),
1235 ("delete_deploy_key", Scope::AccessAdmin),
Mission control counts people's direct pushes to the default branch1236 // Webhooks.
1237 ("list_webhooks", Scope::WebhooksRead),
1238 ("list_webhook_deliveries", Scope::WebhooksRead),
1239 ("create_webhook", Scope::WebhooksAdmin),
1240 ("update_webhook", Scope::WebhooksAdmin),
1241 ("delete_webhook", Scope::WebhooksAdmin),
1242 ("ping_webhook", Scope::WebhooksAdmin),
1243 ("redeliver_webhook", Scope::WebhooksAdmin),
1244 // Secrets and variables.
1245 ("list_actions_secrets", Scope::SecretsRead),
1246 ("list_actions_variables", Scope::SecretsRead),
1247 ("set_actions_secret", Scope::SecretsAdmin),
1248 ("delete_actions_secret", Scope::SecretsAdmin),
1249 ("set_actions_variable", Scope::SecretsAdmin),
1250 ("delete_actions_variable", Scope::SecretsAdmin),
1251 // Self-hosted runners.
1252 ("list_runners", Scope::RunnersRead),
1253 ("list_runner_groups", Scope::RunnersRead),
1254 ("get_runner_settings", Scope::RunnersRead),
1255 ("create_runner_registration_token", Scope::RunnersAdmin),
1256 ("remove_runner", Scope::RunnersAdmin),
1257 ("create_runner_group", Scope::RunnersAdmin),
1258 ("update_runner_group", Scope::RunnersAdmin),
1259 ("delete_runner_group", Scope::RunnersAdmin),
1260 ("update_runner_settings", Scope::RunnersAdmin),
Merge packages: roles, Actions access, source label, soft delete, API1261 // Packages: reading them, their versions and who may use them needs
1262 // `packages:read`; changing their settings, access and Manage Actions
1263 // access `packages:write` (and the Admin role on the package, which the
1264 // packages service checks); deleting and restoring packages and
1265 // versions `packages:delete`, as the registries' own deletes do.
1266 ("list_packages", Scope::PackagesRead),
1267 ("get_package", Scope::PackagesRead),
1268 ("list_package_versions", Scope::PackagesRead),
1269 ("get_package_version", Scope::PackagesRead),
1270 ("list_package_access", Scope::PackagesRead),
1271 ("list_package_actions_access", Scope::PackagesRead),
1272 ("update_package", Scope::PackagesWrite),
1273 ("link_package", Scope::PackagesWrite),
1274 ("unlink_package", Scope::PackagesWrite),
1275 ("set_package_access", Scope::PackagesWrite),
1276 ("remove_package_access", Scope::PackagesWrite),
1277 ("set_package_actions_access", Scope::PackagesWrite),
1278 ("remove_package_actions_access", Scope::PackagesWrite),
1279 ("delete_package", Scope::PackagesDelete),
1280 ("restore_package", Scope::PackagesDelete),
1281 ("delete_package_version", Scope::PackagesDelete),
1282 ("restore_package_version", Scope::PackagesDelete),
Merge main into Artifacts Phase 21283 // Artifacts mode's docs, slides, designs and dashboards (the `artifact`
1284 // MCP tool). Reading takes artifacts:read, making and changing them
1285 // artifacts:write, and sharing them or deleting them for good
The artifacts service is services/artifacts, the Worker g1t-artifacts, bound as ARTIFACTS by the API, the site and the agents; its live rooms move to it with a Durable Object transfer from g1t-docs-service, and its database, bucket, indexes and queue keep their names. The git store's binding and settings are GITSTORE, its ops scripts gitstore-*, and workflow run artifacts keep their compatible API under run_artifacts modules. The deploy tool puts a Worker that has never deployed before the Workers in its stage that bind to it, and the deploy guide gives the cutover runbook.1286 // artifacts:admin. The artifacts service then checks the person's own role
Merge main into Artifacts Phase 21287 // on each one.
1288 ("list_workspace_artifacts", Scope::ArtifactsRead),
1289 ("search_workspace_artifacts", Scope::ArtifactsRead),
1290 ("get_workspace_artifact", Scope::ArtifactsRead),
1291 ("get_workspace_artifact_content", Scope::ArtifactsRead),
1292 ("list_workspace_artifact_versions", Scope::ArtifactsRead),
1293 ("get_workspace_artifact_access", Scope::ArtifactsRead),
1294 ("list_workspace_artifact_templates", Scope::ArtifactsRead),
1295 ("list_workspace_artifact_spaces", Scope::ArtifactsRead),
1296 ("query_workspace_dataset", Scope::ArtifactsRead),
1297 ("create_workspace_artifact", Scope::ArtifactsWrite),
1298 ("update_workspace_artifact", Scope::ArtifactsWrite),
1299 ("edit_workspace_artifact", Scope::ArtifactsWrite),
1300 ("trash_workspace_artifact", Scope::ArtifactsWrite),
1301 ("restore_workspace_artifact", Scope::ArtifactsWrite),
1302 ("restore_workspace_artifact_version", Scope::ArtifactsWrite),
1303 ("set_workspace_artifact_access", Scope::ArtifactsAdmin),
1304 ("purge_workspace_artifact", Scope::ArtifactsAdmin),
Mission control counts people's direct pushes to the default branch1305];
1306
1307/// Operations any token may use: saying who it is.
1308pub const NO_SCOPE: &[&str] = &["whoami"];
1309
1310/// The scope `operation` needs. `None` for one in [`NO_SCOPE`]; an
1311/// operation in neither list needs full access.
1312pub fn scope_for(operation: &str) -> Option<Scope> {
1313 OPERATIONS
1314 .iter()
1315 .find(|(name, _)| *name == operation)
1316 .map(|(_, scope)| *scope)
1317}
1318
1319/// What a token needs for `operation` with this input beyond its own
The contracts no longer describe g1t's own agents, and workspaces can keep their AI providers. Every consumer had already stopped using them, so the TypeScript and Rust contracts drop the workspace-agent, ability, look, skill-library, context, runner-agent and mention modules, the chat and docs RPCs agents posted and read through, the folio agent methods, the agent_waiting notification, agent.asked and memory.changed events, AI credit, token and gateway billing types, model routes and sessions, team agents, agent tokens, plan, review, message and confidence types, command rules, cost caps and confidence rules. The agents:run and models:* scopes are no longer offered by any preset, OAuth default or permission form, but a stored token or grant that names them still reads; and the removed operations are gone from the scope table, so the API's check that every operation has exactly one scope is strict again. What stored data needs in order to parse (old run and credential kinds, an agent team lead, retired rules and webhook events, old guardrail and integration settings) still parses, and a run's token is still PrincipalKind::Agent, which now means a run's token and the @g1t rows written before. The customize, marketplace, skills and claude-plugin contracts stay only until the mobile app drops its Customize screens.1320/// scope: changing who has access, rerunning a workflow, and making a
Mission control counts people's direct pushes to the default branch1321/// repository public or private.
1322pub fn extra_scopes(operation: &str, input: &serde_json::Value) -> Vec<Scope> {
1323 let mut extra = Vec::new();
1324 // A workspace's base permission is who has access.
1325 if operation == "update_workspace" && input.get("base_permission").is_some_and(|v| !v.is_null()) {
1326 extra.push(Scope::AccessAdmin);
1327 }
Merge checks: statuses and check runs on every commit1328 // Asking a g1t Actions job or run to run again reruns its workflow.
1329 if matches!(operation, "rerequest_check_run" | "rerequest_check_suite")
1330 && input["id"].as_str().is_some_and(|id| id.starts_with("job_") || id.starts_with("run_"))
1331 {
1332 extra.push(Scope::WorkflowsWrite);
1333 }
Mission control counts people's direct pushes to the default branch1334 if operation == "update_repo" && (input.get("private").is_some_and(|v| !v.is_null()) || input.get("default_branch").is_some_and(|v| !v.is_null())) {
1335 extra.push(Scope::RepoAdmin);
1336 }
1337 extra
1338}
1339
1340/// The scopes a call needs, its own first.
1341pub fn needed(operation: &str, input: &serde_json::Value) -> Vec<Scope> {
1342 scope_for(operation)
1343 .into_iter()
1344 .chain(extra_scopes(operation, input))
1345 .collect()
1346}
1347
1348/// Whether `access` may use `operation` with `input`. The person's (or
1349/// workspace's) role is checked after this, by the service that owns what
1350/// was asked about.
1351pub fn decide(access: &TokenAccess, operation: &str, input: &serde_json::Value) -> Decision {
1352 let rule = if access.legacy { "token:legacy" } else { "token:scope" };
Merge branch 'worktree-agent-a3abfcce648e87dca'1353 // A workflow job may open or approve pull requests only where its
1354 // repository and workspace let it, as on GitHub.
1355 if let Some(job) = &access.job
1356 && !job.pull_requests
1357 && (operation == "create_pull_request" || (operation == "review_pull_request" && input["verdict"].as_str() == Some("approve")))
1358 {
1359 return Decision::deny(
1360 "token:pull-requests",
1361 "A workflow job cannot open or approve pull requests here: an admin can allow it under Settings, Actions.",
1362 );
1363 }
1364 if let Some(only) = access.repo.as_deref()
1365 && !NO_SCOPE.contains(&operation)
1366 {
1367 match input["repo"].as_str() {
1368 Some(repo) if access.reaches(repo) => {}
1369 Some(repo) => {
1370 return Decision::deny("token:repository", format!("This token is a workflow job's in {only}: it cannot reach {repo}."));
1371 }
1372 None => {
1373 return Decision::deny("token:repository", format!("This token is a workflow job's: it reaches only {only}, and {operation} is not about one repository."));
1374 }
1375 }
1376 }
One kind of access token; presence and status; usernames keep their case; the tour is a miniature of the real app; icons for password managers1377 // A token made for one workspace (or none) only reads outside it:
1378 // public repositories, as anyone may. Inside it, its repository
1379 // selection is checked with its owner's role (`access::granted`).
1380 if let Some(reach) = &access.reach
Token reach: workflow_files scope, fine-grained reach, workspace token cap1381 && let Some(repo) = input["repo"].as_str()
1382 && !NO_SCOPE.contains(&operation)
1383 {
1384 let namespace = repo.split('/').next().unwrap_or_default();
1385 let changes = needed(operation, input).iter().any(|scope| scope.level() != Level::Read);
1386 if changes && !reach.owned_by(namespace) {
One kind of access token; presence and status; usernames keep their case; the tour is a miniature of the real app; icons for password managers1387 let made_for = reach.workspace.as_deref().map_or_else(|| "your account only".to_owned(), |workspace| format!("the workspace {workspace}"));
Token reach: workflow_files scope, fine-grained reach, workspace token cap1388 return Decision::deny(
1389 "token:resource-owner",
One kind of access token; presence and status; usernames keep their case; the tour is a miniature of the real app; icons for password managers1390 format!("This access token is made for {made_for}: elsewhere it can only read public repositories, and {repo} is not in its reach."),
Token reach: workflow_files scope, fine-grained reach, workspace token cap1391 );
1392 }
1393 }
Mission control counts people's direct pushes to the default branch1394 if access.scopes.is_some() {
1395 let known = NO_SCOPE.contains(&operation) || scope_for(operation).is_some();
1396 if !known {
1397 return Decision::deny("token:scope", format!("This access token cannot use {operation}: it needs full access."));
1398 }
1399 if let Some(missing) = needed(operation, input).into_iter().find(|scope| !access.allows(*scope)) {
1400 return Decision::deny(
1401 "token:scope",
1402 format!("This access token needs the {} scope to use {operation}.", missing.as_str()),
1403 );
1404 }
1405 }
1406 Decision::allow(rule)
1407}
1408
Merge branch 'worktree-agent-a3abfcce648e87dca'1409/// Whether a token may use the repository `owner/name` at all: a refusal
Merge branch 'worktree-agent-a5a5de74d8863d554' into worktree-agent-a16631325aecf58ca1410/// for a workflow job's token or a deploy key in another repository,
1411/// else `None`. Git and
Merge branch 'worktree-agent-a3abfcce648e87dca'1412/// the package registries ask this before [`decide_git`] and
1413/// [`decide_packages`].
1414pub fn decide_repo(access: &TokenAccess, repo: &str) -> Option<Decision> {
1415 let only = access.repo.as_deref()?;
Merge branch 'worktree-agent-a5a5de74d8863d554' into worktree-agent-a16631325aecf58ca1416 let why = if access.deploy_key.is_some() {
1417 format!("This deploy key is for {only}: it cannot reach {repo}.")
1418 } else {
1419 format!("This token is a workflow job's in {only}: it cannot reach {repo}.")
1420 };
1421 (!access.reaches(repo)).then(|| Decision::deny("token:repository", why))
Merge branch 'worktree-agent-a3abfcce648e87dca'1422}
1423
Mission control counts people's direct pushes to the default branch1424/// Whether a token may clone or fetch (`write` false), or push to (`write`
1425/// true), a repository with git. `public` is whether anyone may read it,
1426/// which needs no scope.
1427pub fn decide_git(access: &TokenAccess, write: bool, public: bool) -> Decision {
1428 let needed = if write { Scope::CodeWrite } else { Scope::CodeRead };
1429 if !access.allows(needed) && (write || !public) {
Merge branch 'worktree-agent-a5a5de74d8863d554' into worktree-agent-a16631325aecf58ca1430 if access.deploy_key.is_some() {
1431 return Decision::deny(
1432 "token:scope",
1433 "This deploy key is read-only. An admin of the repository can add it again with write access to push with it.",
1434 );
1435 }
Mission control counts people's direct pushes to the default branch1436 return Decision::deny(
1437 "token:scope",
1438 format!("This access token needs the {} scope to {} with git.", needed.as_str(), if write { "push" } else { "clone or fetch a private repository" }),
1439 );
1440 }
1441 Decision::allow(if access.legacy { "token:legacy" } else { "token:scope" })
1442}
1443
1444/// Whether a token may pull (`Level::Read`), push or publish
1445/// (`Level::Write`), or delete (`Level::Delete`) packages. `public` is
1446/// whether anyone may pull the package, which needs no scope.
1447pub fn decide_packages(access: &TokenAccess, level: Level, public: bool) -> Decision {
1448 let (needed, doing) = match level {
1449 Level::Read => (Scope::PackagesRead, "pull a private package"),
1450 Level::Delete | Level::Admin => (Scope::PackagesDelete, "delete packages"),
1451 Level::Write | Level::Run => (Scope::PackagesWrite, "push or publish packages"),
1452 };
1453 if !access.allows(needed) && !(level == Level::Read && public) {
1454 return Decision::deny(
1455 "token:scope",
1456 format!("This access token needs the {} scope to {doing}.", needed.as_str()),
1457 );
1458 }
1459 Decision::allow(if access.legacy { "token:legacy" } else { "token:scope" })
1460}
1461
1462#[cfg(test)]
1463mod tests {
1464 use super::*;
1465 use serde_json::json;
1466
1467 fn token(scopes: &[Scope]) -> TokenAccess {
1468 TokenAccess {
1469 token_id: "tok_1".to_owned(),
1470 scopes: Some(scopes.iter().map(|scope| scope.as_str().to_owned()).collect()),
1471 legacy: false,
Merge the AI Gateway: Anthropic's Messages API on a workspace's tokens1472 name: None,
Merge branch 'worktree-agent-a3abfcce648e87dca'1473 ..TokenAccess::default()
Mission control counts people's direct pushes to the default branch1474 }
1475 }
1476
1477 #[test]
1478 fn every_scope_reads_back_and_belongs_to_a_resource() {
1479 for scope in Scope::ALL {
1480 assert_eq!(Scope::parse(scope.as_str()), Some(scope));
1481 assert!(scope.as_str().starts_with(scope.resource().as_str()));
1482 assert!(scope.includes(scope));
1483 }
1484 assert_eq!(Scope::parse(" Issues:Write "), Some(Scope::IssuesWrite));
1485 assert_eq!(Scope::parse("issues"), None);
1486 }
1487
1488 #[test]
1489 fn a_higher_level_includes_the_lower_ones_of_its_resource_only() {
1490 assert!(Scope::RepoAdmin.includes(Scope::RepoRead));
1491 assert!(Scope::RepoAdmin.includes(Scope::RepoWrite));
1492 assert!(Scope::IssuesWrite.includes(Scope::IssuesRead));
1493 assert!(!Scope::IssuesRead.includes(Scope::IssuesWrite));
1494 assert!(!Scope::RepoAdmin.includes(Scope::CodeWrite));
1495 assert!(!Scope::PullRequestsWrite.includes(Scope::IssuesWrite));
1496 }
1497
1498 #[test]
1499 fn operations_are_listed_once_and_never_also_free() {
1500 let mut seen = std::collections::HashSet::new();
1501 for (name, _) in OPERATIONS {
1502 assert!(seen.insert(*name), "{name} twice");
1503 assert!(!NO_SCOPE.contains(name), "{name}");
1504 }
1505 }
1506
1507 #[test]
1508 fn scopes_are_parsed_from_oauth_text_leaving_out_unknown_ones() {
1509 assert_eq!(
1510 parse_scopes("issues:write repo:read,bogus:thing issues:write"),
1511 vec![Scope::RepoRead, Scope::IssuesWrite]
1512 );
1513 assert_eq!(scopes_text(&[Scope::RepoRead, Scope::IssuesWrite]), "repo:read issues:write");
1514 }
1515
1516 #[test]
1517 fn the_oauth_default_is_the_agent_preset_and_never_admin() {
1518 let scopes = oauth_default();
1519 assert!(scopes.contains(&Scope::IssuesWrite));
1520 assert!(scopes.contains(&Scope::PullRequestsWrite));
The contracts no longer describe g1t's own agents, and workspaces can keep their AI providers. Every consumer had already stopped using them, so the TypeScript and Rust contracts drop the workspace-agent, ability, look, skill-library, context, runner-agent and mention modules, the chat and docs RPCs agents posted and read through, the folio agent methods, the agent_waiting notification, agent.asked and memory.changed events, AI credit, token and gateway billing types, model routes and sessions, team agents, agent tokens, plan, review, message and confidence types, command rules, cost caps and confidence rules. The agents:run and models:* scopes are no longer offered by any preset, OAuth default or permission form, but a stored token or grant that names them still reads; and the removed operations are gone from the scope table, so the API's check that every operation has exactly one scope is strict again. What stored data needs in order to parse (old run and credential kinds, an agent team lead, retired rules and webhook events, old guardrail and integration settings) still parses, and a run's token is still PrincipalKind::Agent, which now means a run's token and the @g1t rows written before. The customize, marketplace, skills and claude-plugin contracts stay only until the mobile app drops its Customize screens.1521 assert!(!scopes.contains(&Scope::AgentsRun));
Mission control counts people's direct pushes to the default branch1522 assert!(scopes.iter().all(|scope| !scope.dangerous()), "{scopes:?}");
Artifacts contracts: folios, their four kinds, dashboard datasets, folio events and the artifacts scopes are typed and validated the same in TypeScript and Rust, with nothing using them yet1523 for read in Scope::ALL.into_iter().filter(|scope| scope.level() == Level::Read && scope.offered()) {
The phone app: Chat in full with phone notifications, plus Code and Customize (#4)1524 // Every read offered but the machines work runs on, and chat.
1525 assert_eq!(scopes.contains(&read), read != Scope::RunnersRead && read != Scope::ChatRead, "{read:?}");
Mission control counts people's direct pushes to the default branch1526 }
1527 assert!(Preset::ReadOnly.scopes().unwrap().iter().all(|scope| scope.level() == Level::Read));
1528 assert_eq!(Preset::Full.scopes(), None);
1529 }
1530
1531 #[test]
The contracts no longer describe g1t's own agents, and workspaces can keep their AI providers. Every consumer had already stopped using them, so the TypeScript and Rust contracts drop the workspace-agent, ability, look, skill-library, context, runner-agent and mention modules, the chat and docs RPCs agents posted and read through, the folio agent methods, the agent_waiting notification, agent.asked and memory.changed events, AI credit, token and gateway billing types, model routes and sessions, team agents, agent tokens, plan, review, message and confidence types, command rules, cost caps and confidence rules. The agents:run and models:* scopes are no longer offered by any preset, OAuth default or permission form, but a stored token or grant that names them still reads; and the removed operations are gone from the scope table, so the API's check that every operation has exactly one scope is strict again. What stored data needs in order to parse (old run and credential kinds, an agent team lead, retired rules and webhook events, old guardrail and integration settings) still parses, and a run's token is still PrincipalKind::Agent, which now means a run's token and the @g1t rows written before. The customize, marketplace, skills and claude-plugin contracts stay only until the mobile app drops its Customize screens.1532 fn retired_scopes_parse_but_are_never_granted() {
1533 // Stored tokens and OAuth grants that hold them still read.
1534 for text in ["agents:run", "models:read", "models:write"] {
1535 let scope = Scope::parse(text).unwrap();
1536 assert!(scope.resource().retired() && !scope.offered(), "{text}");
1537 let back: Scope = serde_json::from_value(json!(text)).unwrap();
1538 assert_eq!(back, scope);
1539 }
1540 // But nothing hands them out, and asking for them gets the rest.
1541 assert_eq!(parse_scopes("agents:run issues:read models:write"), vec![Scope::IssuesRead]);
1542 assert!(!offered_scopes().iter().any(|scope| scope.resource().retired()));
1543 assert!(!everything().iter().any(|scope| scope.resource().retired()));
1544 for preset in Preset::ALL {
1545 let scopes = preset.scopes().unwrap_or_default();
1546 assert!(!scopes.iter().any(|scope| scope.resource().retired()), "{}", preset.as_str());
1547 }
1548 // And no operation needs them.
1549 assert!(!OPERATIONS.iter().any(|(_, scope)| scope.resource().retired()));
1550 }
1551
1552 #[test]
Usage, Billing settings and prepaid AI credit; fixes from the UX audit1553 fn billing_is_read_by_presets_and_changed_by_none_but_full_access() {
1554 assert!(Preset::ReadOnly.scopes().unwrap().contains(&Scope::BillingRead));
1555 for preset in [Preset::ReadOnly, Preset::Agent, Preset::Ci] {
1556 assert!(!preset.scopes().unwrap().contains(&Scope::BillingWrite), "{}", preset.as_str());
1557 }
1558 assert_eq!(scope_for("set_budget"), Some(Scope::BillingWrite));
1559 assert_eq!(scope_for("get_usage"), Some(Scope::BillingRead));
1560 let reader = token(&[Scope::BillingRead]);
1561 assert!(decide(&reader, "list_invoices", &json!({})).allowed);
1562 assert!(decide(&reader, "set_budget", &json!({})).reason.unwrap().contains("billing:write"));
1563 }
1564
1565 #[test]
Merge main into Artifacts Phase 21566 fn artifacts_are_offered_read_by_presets_and_shared_only_with_admin() {
Artifacts contracts: folios, their four kinds, dashboard datasets, folio events and the artifacts scopes are typed and validated the same in TypeScript and Rust, with nothing using them yet1567 for scope in [Scope::ArtifactsRead, Scope::ArtifactsWrite, Scope::ArtifactsAdmin] {
1568 assert_eq!(scope.resource(), Resource::Artifacts);
Merge main into Artifacts Phase 21569 assert!(scope.offered());
1570 assert!(offered_scopes().contains(&scope));
1571 assert_eq!(parse_scopes(scope.as_str()), vec![scope]);
1572 assert!(OPERATIONS.iter().any(|(_, needed)| *needed == scope), "{scope:?} gates nothing");
1573 }
1574 // Reading them is a read like any other; changing them is chosen.
1575 for preset in [Preset::ReadOnly, Preset::Agent] {
1576 let scopes = preset.scopes().unwrap();
1577 assert!(scopes.contains(&Scope::ArtifactsRead), "{}", preset.as_str());
1578 assert!(!scopes.contains(&Scope::ArtifactsWrite) && !scopes.contains(&Scope::ArtifactsAdmin), "{}", preset.as_str());
Artifacts contracts: folios, their four kinds, dashboard datasets, folio events and the artifacts scopes are typed and validated the same in TypeScript and Rust, with nothing using them yet1579 }
Merge main into Artifacts Phase 21580 assert!(!Preset::Ci.scopes().unwrap().contains(&Scope::ArtifactsRead));
1581 assert!(everything().contains(&Scope::ArtifactsAdmin));
Artifacts contracts: folios, their four kinds, dashboard datasets, folio events and the artifacts scopes are typed and validated the same in TypeScript and Rust, with nothing using them yet1582 assert!(Scope::ArtifactsAdmin.includes(Scope::ArtifactsWrite));
1583 assert!(Scope::ArtifactsAdmin.dangerous());
Merge main into Artifacts Phase 21584 assert!(!Scope::ArtifactsWrite.dangerous());
Artifacts contracts: folios, their four kinds, dashboard datasets, folio events and the artifacts scopes are typed and validated the same in TypeScript and Rust, with nothing using them yet1585 assert_eq!(Resource::Artifacts.group(), ResourceGroup::Workspace);
Merge main into Artifacts Phase 21586 let asked = std::collections::BTreeMap::from([("artifacts".to_owned(), "write".to_owned())]);
1587 assert_eq!(resolve_permissions(&asked, true), Ok(vec![Scope::ArtifactsWrite]));
The contracts no longer describe g1t's own agents, and workspaces can keep their AI providers. Every consumer had already stopped using them, so the TypeScript and Rust contracts drop the workspace-agent, ability, look, skill-library, context, runner-agent and mention modules, the chat and docs RPCs agents posted and read through, the folio agent methods, the agent_waiting notification, agent.asked and memory.changed events, AI credit, token and gateway billing types, model routes and sessions, team agents, agent tokens, plan, review, message and confidence types, command rules, cost caps and confidence rules. The agents:run and models:* scopes are no longer offered by any preset, OAuth default or permission form, but a stored token or grant that names them still reads; and the removed operations are gone from the scope table, so the API's check that every operation has exactly one scope is strict again. What stored data needs in order to parse (old run and credential kinds, an agent team lead, retired rules and webhook events, old guardrail and integration settings) still parses, and a run's token is still PrincipalKind::Agent, which now means a run's token and the @g1t rows written before. The customize, marketplace, skills and claude-plugin contracts stay only until the mobile app drops its Customize screens.1588 assert!(offered_scopes().contains(&Scope::ArtifactsAdmin));
Merge main into Artifacts Phase 21589 // Sharing and deleting for good need admin; editing needs write.
1590 assert_eq!(scope_for("set_workspace_artifact_access"), Some(Scope::ArtifactsAdmin));
1591 assert_eq!(scope_for("purge_workspace_artifact"), Some(Scope::ArtifactsAdmin));
1592 assert_eq!(scope_for("edit_workspace_artifact"), Some(Scope::ArtifactsWrite));
1593 assert_eq!(scope_for("get_workspace_artifact_content"), Some(Scope::ArtifactsRead));
1594 let writer = token(&[Scope::ArtifactsWrite]);
1595 assert!(decide(&writer, "edit_workspace_artifact", &json!({})).allowed);
1596 assert!(decide(&writer, "list_workspace_artifacts", &json!({})).allowed, "write includes read");
1597 assert!(decide(&writer, "set_workspace_artifact_access", &json!({})).reason.unwrap().contains("artifacts:admin"));
1598 // Workflow runs' artifacts are another thing, with their own scope.
1599 let reader = token(&[Scope::ArtifactsRead]);
1600 assert!(!decide(&reader, "list_artifacts", &json!({ "repo": "acme/web" })).allowed);
1601 assert!(!decide(&token(&[Scope::WorkflowsRead]), "list_workspace_artifacts", &json!({})).allowed);
Artifacts contracts: folios, their four kinds, dashboard datasets, folio events and the artifacts scopes are typed and validated the same in TypeScript and Rust, with nothing using them yet1602 }
1603
1604 #[test]
The phone app: Chat in full with phone notifications, plus Code and Customize (#4)1605 fn chat_is_a_persons_own_and_given_only_when_asked_for() {
1606 for scope in [Scope::ChatRead, Scope::ChatWrite] {
1607 assert_eq!(scope.resource(), Resource::Chat);
1608 assert!(!scope.dangerous());
1609 assert_eq!(Scope::parse(scope.as_str()), Some(scope));
1610 }
1611 assert_eq!(Resource::Chat.label(), "Chat");
1612 assert_eq!(Resource::Chat.group(), ResourceGroup::Account);
1613 assert!(Scope::ChatWrite.includes(Scope::ChatRead));
1614 assert!(!Scope::ChatRead.includes(Scope::ChatWrite));
1615 // No preset, and so no OAuth default, gives it.
1616 for preset in Preset::ALL {
1617 let scopes = preset.scopes().unwrap_or_default();
1618 assert!(!scopes.iter().any(|scope| scope.resource() == Resource::Chat), "{}", preset.as_str());
1619 }
1620 assert!(!oauth_default().iter().any(|scope| scope.resource() == Resource::Chat));
1621 // An application that asks for it by name gets it; full access holds it.
1622 assert_eq!(parse_scopes("chat:read chat:write"), vec![Scope::ChatRead, Scope::ChatWrite]);
1623 assert!(offered_scopes().contains(&Scope::ChatWrite));
1624 assert!(everything().contains(&Scope::ChatWrite));
1625 assert!(TokenAccess::full().allows(Scope::ChatWrite));
1626 // Only a person's token may hold it.
1627 let asked = std::collections::BTreeMap::from([("chat".to_owned(), "write".to_owned())]);
1628 assert_eq!(resolve_permissions(&asked, true), Ok(vec![Scope::ChatWrite]));
1629 assert!(resolve_permissions(&asked, false).is_err());
1630 }
1631
1632 #[test]
Merge checks: statuses and check runs on every commit1633 fn checks_are_reported_with_checks_write_which_ci_gets() {
1634 assert_eq!(scope_for("create_check_run"), Some(Scope::ChecksWrite));
1635 assert_eq!(scope_for("create_commit_status"), Some(Scope::ChecksWrite));
1636 assert_eq!(scope_for("list_check_runs_for_ref"), Some(Scope::ChecksRead));
1637 let ci = Preset::Ci.scopes().unwrap();
1638 assert!(ci.contains(&Scope::ChecksWrite));
1639 assert!(!Preset::Agent.scopes().unwrap().contains(&Scope::ChecksWrite));
1640 let reporter = token(&[Scope::ChecksWrite]);
1641 assert!(decide(&reporter, "update_check_run", &json!({ "id": "cr_1" })).allowed);
1642 assert!(decide(&reporter, "rerequest_check_run", &json!({ "id": "cr_1" })).allowed);
1643 // A g1t Actions job runs again as its workflow does.
1644 let refused = decide(&reporter, "rerequest_check_run", &json!({ "id": "job_1" }));
1645 assert!(refused.reason.unwrap().contains("workflows:write"));
1646 }
1647
1648 #[test]
Merge branch 'worktree-agent-a3abfcce648e87dca'1649 fn a_job_token_reaches_its_repository_only() {
1650 let job = TokenAccess {
1651 repo: Some("acme/web".into()),
1652 job: Some(JobToken { run_id: "run_1".into(), job_id: "job_1".into(), pull_requests: false }),
1653 ..token(&[Scope::RepoRead, Scope::IssuesWrite, Scope::IssuesRead, Scope::PullRequestsWrite])
1654 };
1655 assert!(decide(&job, "create_issue", &json!({ "repo": "acme/web" })).allowed);
1656 assert!(decide(&job, "create_issue", &json!({ "repo": "Acme/Web" })).allowed, "names compare without case");
1657 let elsewhere = decide(&job, "create_issue", &json!({ "repo": "acme/api" }));
1658 assert!(!elsewhere.allowed);
1659 assert_eq!(elsewhere.rule, "token:repository");
1660 // Nothing beyond the one repository, a workspace's listing included.
1661 assert!(!decide(&job, "list_repos", &json!({})).allowed);
1662 assert!(decide(&job, "whoami", &json!({})).allowed);
1663 // Its scopes still hold inside it.
1664 assert!(!decide(&job, "create_pull_request", &json!({ "repo": "acme/web" })).allowed);
1665 assert!(decide_repo(&job, "acme/web").is_none());
1666 assert!(!decide_repo(&job, "acme/api").unwrap().allowed);
1667 assert!(decide_repo(&token(&[Scope::CodeRead]), "acme/api").is_none(), "other tokens reach what their owner can");
1668 // Opening and approving pull requests is off unless allowed.
1669 assert_eq!(decide(&job, "create_pull_request", &json!({ "repo": "acme/web" })).rule, "token:pull-requests");
1670 assert!(!decide(&job, "review_pull_request", &json!({ "repo": "acme/web", "verdict": "approve" })).allowed);
1671 assert!(decide(&job, "review_pull_request", &json!({ "repo": "acme/web", "verdict": "request_changes" })).allowed);
1672 let allowed = TokenAccess { job: Some(JobToken { pull_requests: true, ..job.job.clone().unwrap() }), ..job.clone() };
1673 assert!(decide(&allowed, "create_pull_request", &json!({ "repo": "acme/web" })).allowed);
1674 }
1675
1676 #[test]
Workflow files need workflow_files:write from a token; fine-grained permission table1677 fn workflow_files_need_their_own_scope() {
1678 for path in [".g1t/workflows/ci.yml", ".github/workflows/deploy.yaml", "/.github/workflows/x.yml", ".GitHub/Workflows/ci.yml", ".github/workflows"] {
1679 assert!(is_workflow_file(path), "{path}");
1680 }
1681 for path in ["README.md", ".github/CODEOWNERS", ".github/workflowsx/ci.yml", "docs/.github/workflows/ci.yml", ".g1t/actions/ci.yml"] {
1682 assert!(!is_workflow_file(path), "{path}");
1683 }
1684 let code = token(&[Scope::CodeWrite]);
1685 let refused = decide_workflow_files(Some(&code), ["README.md", ".github/workflows/ci.yml"]).unwrap();
1686 assert_eq!(refused.rule, "token:workflows");
1687 assert!(refused.reason.as_deref().unwrap().contains(".github/workflows/ci.yml"));
1688 assert!(refused.reason.as_deref().unwrap().contains("workflow_files:write"));
1689 assert!(decide_workflow_files(Some(&code), ["README.md"]).is_none());
1690 assert!(decide_workflow_files(Some(&token(&[Scope::CodeWrite, Scope::WorkflowFilesWrite])), [".g1t/workflows/ci.yml"]).is_none());
1691 assert!(decide_workflow_files(Some(&TokenAccess::full()), [".g1t/workflows/ci.yml"]).is_none(), "full access");
1692 assert!(decide_workflow_files(None, [".g1t/workflows/ci.yml"]).is_none(), "a signed-in person");
1693 // A job's token never may, as GITHUB_TOKEN never may.
1694 let job = TokenAccess { job: Some(JobToken::default()), ..TokenAccess::full() };
1695 assert!(decide_workflow_files(Some(&job), [".g1t/workflows/ci.yml"]).unwrap().reason.unwrap().contains("job"));
1696 // Nothing in a preset changes workflow files but full access.
1697 for preset in [Preset::ReadOnly, Preset::Agent, Preset::Ci] {
1698 assert!(!preset.scopes().unwrap().contains(&Scope::WorkflowFilesWrite), "{}", preset.as_str());
1699 }
1700 assert!(!Scope::WorkflowFilesWrite.includes(Scope::WorkflowsWrite) && !Scope::WorkflowsWrite.includes(Scope::WorkflowFilesWrite));
1701 }
1702
1703 #[test]
One kind of access token; presence and status; usernames keep their case; the tour is a miniature of the real app; icons for password managers1704 fn a_narrowed_token_only_reads_outside_its_workspace() {
1705 let reach = TokenReach { workspace: Some("acme".into()), repositories: RepositorySelection::All, repo_ids: Vec::new() };
1706 let fine = TokenAccess { reach: Some(reach), ..token(&[Scope::RepoRead, Scope::IssuesRead, Scope::IssuesWrite]) };
Workflow files need workflow_files:write from a token; fine-grained permission table1707 assert!(decide(&fine, "create_issue", &json!({ "repo": "acme/web" })).allowed);
1708 assert!(decide(&fine, "create_issue", &json!({ "repo": "Acme/web" })).allowed);
1709 let elsewhere = decide(&fine, "create_issue", &json!({ "repo": "globex/site" }));
1710 assert_eq!(elsewhere.rule, "token:resource-owner");
1711 assert!(elsewhere.reason.unwrap().contains("acme"));
1712 assert!(decide(&fine, "get_issue", &json!({ "repo": "globex/site" })).allowed, "public repositories elsewhere read");
1713 assert!(!decide(&fine, "create_pull_request", &json!({ "repo": "acme/web" })).allowed, "its scopes still hold");
One kind of access token; presence and status; usernames keep their case; the tour is a miniature of the real app; icons for password managers1714 let mine = TokenAccess { reach: Some(TokenReach::default()), ..token(&[Scope::IssuesWrite]) };
Workflow files need workflow_files:write from a token; fine-grained permission table1715 assert!(decide(&mine, "create_issue", &json!({ "repo": "acme/web" })).reason.unwrap().contains("your account"));
1716 assert!(fine.covers_repo("rep_1", "acme") && !fine.covers_repo("rep_1", "globex"));
One kind of access token; presence and status; usernames keep their case; the tour is a miniature of the real app; icons for password managers1717 let selected = TokenReach { workspace: Some("acme".into()), repositories: RepositorySelection::Selected, repo_ids: vec!["rep_1".into()] };
Workflow files need workflow_files:write from a token; fine-grained permission table1718 assert!(selected.covers("rep_1", "ACME") && !selected.covers("rep_2", "acme"));
One kind of access token; presence and status; usernames keep their case; the tour is a miniature of the real app; icons for password managers1719 let public = TokenReach { repositories: RepositorySelection::Public, ..selected.clone() };
Workflow files need workflow_files:write from a token; fine-grained permission table1720 assert!(!public.covers("rep_1", "acme") && public.owned_by("acme"));
One kind of access token; presence and status; usernames keep their case; the tour is a miniature of the real app; icons for password managers1721 assert!(token(&[]).covers_repo("rep_1", "anything"), "a token for every workspace reaches what its owner can");
Workflow files need workflow_files:write from a token; fine-grained permission table1722 assert_eq!(RepositorySelection::parse("public_only"), Some(RepositorySelection::Public));
1723 }
1724
1725 #[test]
One kind of access token; presence and status; usernames keep their case; the tour is a miniature of the real app; icons for password managers1726 fn permissions_are_scopes_read_per_resource() {
1727 let asked: std::collections::BTreeMap<String, String> =
1728 [("issues", "write"), ("repo", "read"), ("code", "none"), ("packages", "delete")].iter().map(|(a, b)| ((*a).to_owned(), (*b).to_owned())).collect();
1729 let scopes = resolve_permissions(&asked, true).unwrap();
1730 assert_eq!(scopes, vec![Scope::RepoRead, Scope::PackagesDelete, Scope::IssuesWrite]);
1731 let back = permissions_of(&scopes);
1732 assert_eq!(back.get("issues").map(String::as_str), Some("write"));
1733 assert_eq!(back.get("packages").map(String::as_str), Some("delete"));
1734 assert!(!back.contains_key("code"));
1735 // Lower levels held beside a higher one say nothing more.
1736 assert_eq!(top_scopes(&[Scope::RepoRead, Scope::RepoAdmin, Scope::RepoWrite]), vec![Scope::RepoAdmin]);
Artifacts contracts: folios, their four kinds, dashboard datasets, folio events and the artifacts scopes are typed and validated the same in TypeScript and Rust, with nothing using them yet1737 // Every offered resource's top, and nothing a level can lose.
One kind of access token; presence and status; usernames keep their case; the tour is a miniature of the real app; icons for password managers1738 let all = everything();
Artifacts contracts: folios, their four kinds, dashboard datasets, folio events and the artifacts scopes are typed and validated the same in TypeScript and Rust, with nothing using them yet1739 assert_eq!(all.len(), Resource::ALL.into_iter().filter(|resource| resource.offered()).count());
1740 for scope in offered_scopes() {
One kind of access token; presence and status; usernames keep their case; the tour is a miniature of the real app; icons for password managers1741 assert!(all.iter().any(|held| held.includes(scope)), "{scope:?}");
1742 }
1743 }
1744
1745 #[test]
1746 fn permissions_are_checked_by_name_level_and_owner() {
1747 let one = |name: &str, level: &str| -> std::collections::BTreeMap<String, String> { [(name.to_owned(), level.to_owned())].into() };
1748 assert!(resolve_permissions(&one("wiki", "read"), true).unwrap_err().contains("wiki"));
1749 assert!(resolve_permissions(&one("issues", "admin"), true).unwrap_err().contains("read, write"));
1750 assert!(resolve_permissions(&one("workflow_files", "read"), true).is_err(), "workflow files are written only");
1751 assert!(resolve_permissions(&one("notifications", "read"), false).unwrap_err().contains("account"));
1752 assert_eq!(resolve_permissions(&one("notifications", "read"), true).unwrap(), vec![Scope::NotificationsRead]);
The contracts no longer describe g1t's own agents, and workspaces can keep their AI providers. Every consumer had already stopped using them, so the TypeScript and Rust contracts drop the workspace-agent, ability, look, skill-library, context, runner-agent and mention modules, the chat and docs RPCs agents posted and read through, the folio agent methods, the agent_waiting notification, agent.asked and memory.changed events, AI credit, token and gateway billing types, model routes and sessions, team agents, agent tokens, plan, review, message and confidence types, command rules, cost caps and confidence rules. The agents:run and models:* scopes are no longer offered by any preset, OAuth default or permission form, but a stored token or grant that names them still reads; and the removed operations are gone from the scope table, so the API's check that every operation has exactly one scope is strict again. What stored data needs in order to parse (old run and credential kinds, an agent team lead, retired rules and webhook events, old guardrail and integration settings) still parses, and a run's token is still PrincipalKind::Agent, which now means a run's token and the @g1t rows written before. The customize, marketplace, skills and claude-plugin contracts stay only until the mobile app drops its Customize screens.1753 assert!(resolve_permissions(&one("agents", "run"), false).unwrap_err().contains("agents"), "retired");
1754 assert!(resolve_permissions(&one("models", "read"), false).is_err(), "retired");
One kind of access token; presence and status; usernames keep their case; the tour is a miniature of the real app; icons for password managers1755 for resource in Resource::ALL {
1756 assert_eq!(Resource::parse(resource.as_str()), Some(resource));
1757 assert!(!resource.scopes().is_empty());
1758 }
1759 }
1760
1761 #[test]
Mission control counts people's direct pushes to the default branch1762 fn a_legacy_token_can_do_everything() {
1763 let legacy = TokenAccess { legacy: true, ..TokenAccess::full() };
1764 for (operation, _) in OPERATIONS {
1765 assert!(decide(&legacy, operation, &json!({})).allowed, "{operation}");
1766 }
1767 assert_eq!(decide(&legacy, "delete_repo", &json!({})).rule, "token:legacy");
1768 }
1769
1770 #[test]
1771 fn a_missing_scope_is_named() {
1772 let read = token(&[Scope::IssuesRead]);
1773 assert!(decide(&read, "get_issue", &json!({})).allowed);
1774 assert!(decide(&read, "whoami", &json!({})).allowed);
1775 let refused = decide(&read, "create_issue", &json!({}));
1776 assert!(!refused.allowed);
1777 assert_eq!(refused.reason.as_deref(), Some("This access token needs the issues:write scope to use create_issue."));
1778 // An operation the table does not know needs full access.
1779 assert!(!decide(&read, "something_new", &json!({})).allowed);
1780 }
1781
1782 #[test]
The contracts no longer describe g1t's own agents, and workspaces can keep their AI providers. Every consumer had already stopped using them, so the TypeScript and Rust contracts drop the workspace-agent, ability, look, skill-library, context, runner-agent and mention modules, the chat and docs RPCs agents posted and read through, the folio agent methods, the agent_waiting notification, agent.asked and memory.changed events, AI credit, token and gateway billing types, model routes and sessions, team agents, agent tokens, plan, review, message and confidence types, command rules, cost caps and confidence rules. The agents:run and models:* scopes are no longer offered by any preset, OAuth default or permission form, but a stored token or grant that names them still reads; and the removed operations are gone from the scope table, so the API's check that every operation has exactly one scope is strict again. What stored data needs in order to parse (old run and credential kinds, an agent team lead, retired rules and webhook events, old guardrail and integration settings) still parses, and a run's token is still PrincipalKind::Agent, which now means a run's token and the @g1t rows written before. The customize, marketplace, skills and claude-plugin contracts stay only until the mobile app drops its Customize screens.1783 fn making_a_repository_public_or_private_needs_repo_admin() {
Mission control counts people's direct pushes to the default branch1784 let maintainer = token(&[Scope::RepoWrite]);
1785 assert!(decide(&maintainer, "update_repo", &json!({ "description": "x" })).allowed);
1786 assert!(!decide(&maintainer, "update_repo", &json!({ "private": true })).allowed);
1787 }
1788
1789 #[test]
1790 fn a_workspaces_base_permission_needs_access_admin_too() {
1791 let admin = token(&[Scope::WorkspaceAdmin]);
1792 assert!(decide(&admin, "update_workspace", &json!({ "name": "Acme" })).allowed);
1793 let refused = decide(&admin, "update_workspace", &json!({ "name": "Acme", "base_permission": "read" }));
1794 assert!(refused.reason.unwrap().contains("access:admin"));
1795 let both = token(&[Scope::WorkspaceAdmin, Scope::AccessAdmin]);
1796 assert!(decide(&both, "update_workspace", &json!({ "base_permission": "read" })).allowed);
1797 assert!(!decide(&token(&[Scope::WorkspaceRead]), "update_workspace", &json!({ "name": "Acme" })).allowed);
1798 }
1799
1800 #[test]
1801 fn git_push_needs_code_write_and_private_reads_need_code_read() {
1802 let reader = token(&[Scope::CodeRead]);
1803 assert!(decide_git(&reader, false, false).allowed);
1804 let refused = decide_git(&reader, true, false);
1805 assert!(!refused.allowed);
1806 assert!(refused.reason.unwrap().contains("code:write"));
1807 let issues = token(&[Scope::IssuesWrite]);
1808 assert!(!decide_git(&issues, false, false).allowed);
1809 assert!(decide_git(&issues, false, true).allowed, "public code needs no scope");
1810 assert!(!decide_git(&issues, true, true).allowed, "pushing to public code still needs code:write");
1811 let writer = token(&[Scope::CodeWrite]);
1812 assert!(decide_git(&writer, true, false).allowed);
1813 assert!(decide_git(&writer, false, false).allowed, "code:write includes code:read");
1814 assert!(decide_git(&TokenAccess::full(), true, false).allowed);
1815 }
1816
1817 #[test]
1818 fn packages_need_their_own_scopes_and_public_pulls_none() {
1819 let reader = token(&[Scope::PackagesRead]);
1820 assert!(decide_packages(&reader, Level::Read, false).allowed);
1821 assert!(!decide_packages(&reader, Level::Write, false).allowed);
1822 let code = token(&[Scope::CodeWrite]);
1823 assert!(!decide_packages(&code, Level::Read, false).allowed, "code scopes are not package scopes");
1824 assert!(decide_packages(&code, Level::Read, true).allowed, "public packages pull with any token");
1825 let writer = token(&[Scope::PackagesWrite]);
1826 assert!(decide_packages(&writer, Level::Write, false).allowed);
1827 assert!(decide_packages(&writer, Level::Read, false).allowed, "packages:write includes packages:read");
1828 let refused = decide_packages(&writer, Level::Delete, false);
1829 assert!(refused.reason.unwrap().contains("packages:delete"));
1830 assert!(decide_packages(&token(&[Scope::PackagesDelete]), Level::Write, false).allowed);
1831 assert!(Scope::PackagesDelete.dangerous());
1832 // Tokens made before these scopes, and full-access ones, keep working.
1833 let legacy = TokenAccess { legacy: true, ..TokenAccess::full() };
1834 assert!(decide_packages(&legacy, Level::Delete, false).allowed);
1835 assert!(decide_packages(&TokenAccess::full(), Level::Write, false).allowed);
1836 }
1837
1838 #[test]
1839 fn token_access_travels_as_json() {
1840 let access = token(&[Scope::IssuesRead]);
1841 let wire = serde_json::to_value(&access).unwrap();
1842 assert_eq!(wire["scopes"], json!(["issues:read"]));
1843 assert!(wire.get("resources").is_none());
1844 let back: TokenAccess = serde_json::from_value(wire).unwrap();
1845 assert_eq!(back, access);
1846 let full: TokenAccess = serde_json::from_value(json!({})).unwrap();
1847 assert!(full.is_full());
1848 // A reach written by an older version is ignored: a token reaches
1849 // whatever its owner can.
1850 let older: TokenAccess = serde_json::from_value(json!({
1851 "token_id": "tok_1",
1852 "scopes": ["issues:read"],
1853 "resources": { "kind": "repositories", "repositories": ["acme/rocket"] },
1854 }))
1855 .unwrap();
1856 assert_eq!(older, access);
Merge main into Artifacts Phase 21857 // Using the website is off unless set, and said only when on.
1858 assert!(!access.website);
1859 assert!(wire_of(&access).get("website").is_none());
1860 let website = TokenAccess { website: true, ..access };
1861 assert_eq!(wire_of(&website)["website"], json!(true));
1862 // Never part of full access.
1863 assert!(!TokenAccess::full().website);
Mission control counts people's direct pushes to the default branch1864 }
1865
Merge main into Artifacts Phase 21866 fn wire_of(access: &TokenAccess) -> serde_json::Value {
1867 serde_json::to_value(access).unwrap()
1868 }
1869
Mission control counts people's direct pushes to the default branch1870 /// The site's copy of the table, `packages/contracts/src/scopes.ts`,
1871 /// lists the same scopes in the same order, the same operations with
1872 /// the same scopes, and the same presets.
1873 #[test]
1874 fn the_typescript_mirror_has_the_same_table() {
1875 let ts = include_str!("../../../packages/contracts/src/scopes.ts");
1876 let section = |start: &str| {
1877 ts.split_once(start)
1878 .and_then(|(_, rest)| rest.split_once("] as const"))
1879 .map(|(table, _)| table)
1880 .unwrap_or_else(|| panic!("{start} in scopes.ts"))
1881 };
Artifacts contracts: folios, their four kinds, dashboard datasets, folio events and the artifacts scopes are typed and validated the same in TypeScript and Rust, with nothing using them yet1882 let names = |table: &str| -> Vec<String> {
1883 section(table)
1884 .lines()
1885 .filter_map(|line| line.split_once("scope: \"").and_then(|(_, rest)| rest.split_once('"')).map(|(scope, _)| scope.to_owned()))
1886 .collect()
1887 };
The contracts no longer describe g1t's own agents, and workspaces can keep their AI providers. Every consumer had already stopped using them, so the TypeScript and Rust contracts drop the workspace-agent, ability, look, skill-library, context, runner-agent and mention modules, the chat and docs RPCs agents posted and read through, the folio agent methods, the agent_waiting notification, agent.asked and memory.changed events, AI credit, token and gateway billing types, model routes and sessions, team agents, agent tokens, plan, review, message and confidence types, command rules, cost caps and confidence rules. The agents:run and models:* scopes are no longer offered by any preset, OAuth default or permission form, but a stored token or grant that names them still reads; and the removed operations are gone from the scope table, so the API's check that every operation has exactly one scope is strict again. What stored data needs in order to parse (old run and credential kinds, an agent team lead, retired rules and webhook events, old guardrail and integration settings) still parses, and a run's token is still PrincipalKind::Agent, which now means a run's token and the @g1t rows written before. The customize, marketplace, skills and claude-plugin contracts stay only until the mobile app drops its Customize screens.1888 // Offered scopes in `SCOPES`, retired ones in `RETIRED_SCOPES`, the
1889 // rest in `UPCOMING_SCOPES`.
1890 let listed = |keep: fn(&Scope) -> bool| -> Vec<String> { Scope::ALL.iter().filter(|scope| keep(scope)).map(|scope| scope.as_str().to_owned()).collect() };
1891 assert_eq!(names("export const SCOPES = ["), listed(|scope| scope.offered()));
1892 assert_eq!(names("export const UPCOMING_SCOPES"), listed(|scope| !scope.offered() && !scope.resource().retired()));
1893 assert_eq!(names("export const RETIRED_SCOPES"), listed(|scope| scope.resource().retired()));
Mission control counts people's direct pushes to the default branch1894 let operations: Vec<(String, String)> = section("export const OPERATION_SCOPES = [")
1895 .lines()
1896 .filter_map(|line| {
1897 let mut quoted = line.split('"').skip(1).step_by(2);
1898 Some((quoted.next()?.to_owned(), quoted.next()?.to_owned()))
1899 })
1900 .collect();
1901 let expected: Vec<(String, String)> = OPERATIONS
1902 .iter()
1903 .map(|(name, scope)| ((*name).to_owned(), scope.as_str().to_owned()))
1904 .collect();
1905 assert_eq!(operations, expected);
1906 for preset in Preset::ALL {
1907 let list = section(&format!("{}: [", preset.as_str()));
1908 let mirrored: Vec<&str> = list
1909 .split(',')
1910 .map(|item| item.trim().trim_matches('"'))
1911 .filter(|item| !item.is_empty())
1912 .collect();
1913 let expected: Vec<&str> = preset
1914 .scopes()
1915 .map(|scopes| scopes.iter().map(|scope| scope.as_str()).collect())
1916 .unwrap_or_else(|| vec!["*"]);
1917 assert_eq!(mirrored, expected, "{}", preset.as_str());
1918 }
Artifacts contracts: folios, their four kinds, dashboard datasets, folio events and the artifacts scopes are typed and validated the same in TypeScript and Rust, with nothing using them yet1919 // Each resource with its group, in the same order: offered ones in
The contracts no longer describe g1t's own agents, and workspaces can keep their AI providers. Every consumer had already stopped using them, so the TypeScript and Rust contracts drop the workspace-agent, ability, look, skill-library, context, runner-agent and mention modules, the chat and docs RPCs agents posted and read through, the folio agent methods, the agent_waiting notification, agent.asked and memory.changed events, AI credit, token and gateway billing types, model routes and sessions, team agents, agent tokens, plan, review, message and confidence types, command rules, cost caps and confidence rules. The agents:run and models:* scopes are no longer offered by any preset, OAuth default or permission form, but a stored token or grant that names them still reads; and the removed operations are gone from the scope table, so the API's check that every operation has exactly one scope is strict again. What stored data needs in order to parse (old run and credential kinds, an agent team lead, retired rules and webhook events, old guardrail and integration settings) still parses, and a run's token is still PrincipalKind::Agent, which now means a run's token and the @g1t rows written before. The customize, marketplace, skills and claude-plugin contracts stay only until the mobile app drops its Customize screens.1920 // `SCOPE_RESOURCES`, retired ones in `RETIRED_RESOURCES`, the rest in
1921 // `UPCOMING_RESOURCES`.
1922 let tables: [(&str, fn(Resource) -> bool); 3] = [
1923 ("export const SCOPE_RESOURCES", |resource| resource.offered()),
1924 ("export const UPCOMING_RESOURCES", |resource| !resource.offered() && !resource.retired()),
1925 ("export const RETIRED_RESOURCES", |resource| resource.retired()),
1926 ];
1927 for (table, keep) in tables {
Artifacts contracts: folios, their four kinds, dashboard datasets, folio events and the artifacts scopes are typed and validated the same in TypeScript and Rust, with nothing using them yet1928 let resources = ts
1929 .split_once(table)
1930 .and_then(|(_, rest)| rest.split_once("
One kind of access token; presence and status; usernames keep their case; the tour is a miniature of the real app; icons for password managers1931];"))
Artifacts contracts: folios, their four kinds, dashboard datasets, folio events and the artifacts scopes are typed and validated the same in TypeScript and Rust, with nothing using them yet1932 .map(|(table, _)| table)
1933 .unwrap_or_else(|| panic!("{table} in scopes.ts"));
1934 let rows: Vec<&str> = resources.lines().filter(|line| line.trim_start().starts_with("{ resource:")).collect();
The contracts no longer describe g1t's own agents, and workspaces can keep their AI providers. Every consumer had already stopped using them, so the TypeScript and Rust contracts drop the workspace-agent, ability, look, skill-library, context, runner-agent and mention modules, the chat and docs RPCs agents posted and read through, the folio agent methods, the agent_waiting notification, agent.asked and memory.changed events, AI credit, token and gateway billing types, model routes and sessions, team agents, agent tokens, plan, review, message and confidence types, command rules, cost caps and confidence rules. The agents:run and models:* scopes are no longer offered by any preset, OAuth default or permission form, but a stored token or grant that names them still reads; and the removed operations are gone from the scope table, so the API's check that every operation has exactly one scope is strict again. What stored data needs in order to parse (old run and credential kinds, an agent team lead, retired rules and webhook events, old guardrail and integration settings) still parses, and a run's token is still PrincipalKind::Agent, which now means a run's token and the @g1t rows written before. The customize, marketplace, skills and claude-plugin contracts stay only until the mobile app drops its Customize screens.1935 let expected: Vec<Resource> = Resource::ALL.into_iter().filter(|resource| keep(*resource)).collect();
Artifacts contracts: folios, their four kinds, dashboard datasets, folio events and the artifacts scopes are typed and validated the same in TypeScript and Rust, with nothing using them yet1936 assert_eq!(rows.len(), expected.len(), "{table}");
1937 for (row, resource) in rows.iter().zip(expected) {
1938 assert!(row.contains(&format!("resource: \"{}\"", resource.as_str())), "{row}");
1939 assert!(row.contains(&format!("group: \"{}\"", resource.group().as_str())), "{row}");
1940 }
One kind of access token; presence and status; usernames keep their case; the tour is a miniature of the real app; icons for password managers1941 }
Mission control counts people's direct pushes to the default branch1942 }
1943}

This file's history is long; its oldest lines are credited to the oldest commit read.