GitLabgitlab-org
cli
main
1package clear
3import (
4 "context"
5 "encoding/base64"
6 "encoding/json"
7 "errors"
8 "fmt"
9 "io"
10 "os"
11 "path/filepath"
12 "time"
14 "github.com/MakeNowJust/heredoc/v2"
15 "github.com/spf13/cobra"
16 "github.com/zalando/go-keyring"
18 gitlab "gitlab.com/gitlab-org/api/client-go/v3"
20 "gitlab.com/gitlab-org/cli/internal/cmdutils"
21 agentutils "gitlab.com/gitlab-org/cli/internal/commands/cluster/agent/agentutils"
22 "gitlab.com/gitlab-org/cli/internal/iostreams"
23 "gitlab.com/gitlab-org/cli/internal/mcpannotations"
24)
26const keyringService = "glab"
28type options struct {
29 gitlabClient func() (*gitlab.Client, error)
30 io *iostreams.IOStreams
32 filesystem bool
33 keyring bool
34 revoke bool
35 agents []int64
36 repo string
37}
39type cachedToken = agentutils.CachedToken
41func NewCmd(f cmdutils.Factory) *cobra.Command {
42 opts := options{
43 io: f.IO(),
44 gitlabClient: f.GitLabClient,
45 }
47 cmd := &cobra.Command{
48 Use: "clear [flags]",
49 Short: "Clear cached GitLab Agent tokens.",
50 Long: heredoc.Docf(`
51 By default, clears tokens from both keyring and filesystem cache
52 and revokes them on the GitLab server. Use %[1]s--revoke=false%[1]s to skip revocation.
53 `, "`"),
54 Example: heredoc.Doc(`
55 # Clear all cached agent tokens
56 glab cluster agent token-cache clear
58 # Clear tokens without revoking them on GitLab
59 glab cluster agent token-cache clear --revoke=false
61 # Clear tokens for a specific agent
62 glab cluster agent token-cache clear --agent 123`),
63 Args: cobra.NoArgs,
64 ValidArgsFunction: cobra.NoFileCompletions,
65 Annotations: map[string]string{
66 mcpannotations.Destructive: "true",
67 },
68 RunE: func(cmd *cobra.Command, args []string) error {
69 if err := opts.validate(); err != nil {
70 return err
71 }
72 return opts.run(cmd.Context())
73 },
74 }
76 fl := cmd.Flags()
77 fl.BoolVar(&opts.filesystem, "filesystem", true, "Clear tokens from filesystem cache.")
78 fl.BoolVar(&opts.keyring, "keyring", true, "Clear tokens from keyring cache.")
79 fl.BoolVar(&opts.revoke, "revoke", true, "Revoke tokens on GitLab server before clearing cache.")
80 fl.Int64SliceVar(&opts.agents, "agent", nil, "Clear tokens for specific agent IDs only.")
81 fl.StringVarP(&opts.repo, "repo", "R", "", "Select another repository using the OWNER/REPO format.")
83 cmdutils.EnableRepoOverride(cmd, f)
85 return cmd
86}
88func (o *options) run(ctx context.Context) error {
89 var tokens []cachedToken
90 var errors []error
92 if o.keyring {
93 keyringTokens, err := o.getKeyringTokens()
94 if err != nil {
95 errors = append(errors, fmt.Errorf("failed to read keyring tokens: %w", err))
96 } else {
97 tokens = append(tokens, keyringTokens...)
98 }
99 }
101 if o.filesystem {
102 fsTokens, err := o.getFilesystemTokens()
103 if err != nil {
104 errors = append(errors, fmt.Errorf("failed to read filesystem tokens: %w", err))
105 } else {
106 tokens = append(tokens, fsTokens...)
107 }
108 }
110 // Filter by agent IDs if specified
111 tokens = agentutils.FilterByAgents(tokens, o.agents)
113 if len(tokens) == 0 {
114 o.io.LogInfo("No cached tokens found to clear.")
115 for _, err := range errors {
116 o.io.LogErrorf("Warning: %v\n", err)
117 }
118 return nil
119 }
121 for _, err := range errors {
122 o.io.LogErrorf("Warning: %v\n", err)
123 }
125 o.io.LogInfof("Found %d cached token(s) to clear.\n", len(tokens))
127 // Revoke tokens if requested
128 if o.revoke {
129 o.io.LogInfo("Revoking tokens on GitLab server...")
130 revokeErrors := o.revokeTokens(ctx, tokens)
131 for _, err := range revokeErrors {
132 o.io.LogErrorf("Warning: %v\n", err)
133 }
134 }
136 o.io.LogInfo("Clearing tokens from cache...")
137 clearErrors := o.clearTokens(tokens)
138 for _, err := range clearErrors {
139 o.io.LogErrorf("Error: %v\n", err)
140 }
142 o.io.LogInfof("Successfully cleared %d token(s) from cache.\n", len(tokens))
143 return nil
144}
146func (o *options) validate() error {
147 if !o.keyring && !o.filesystem {
148 return fmt.Errorf("at least one cache source must be enabled (--keyring or --filesystem)")
149 }
150 return nil
151}
153func (o *options) getKeyringTokens() ([]cachedToken, error) {
154 // The keyring library can't enumerate keys, so cache keys must be
155 // constructed from the agent IDs passed with --agent.
156 if len(o.agents) == 0 {
157 return nil, fmt.Errorf("keyring token clearing requires --agent flag to specify agent IDs")
158 }
160 client, err := o.gitlabClient()
161 if err != nil {
162 return nil, fmt.Errorf("failed to create GitLab client: %w", err)
163 }
165 gitlabInstance := base64.StdEncoding.EncodeToString([]byte(client.BaseURL().String()))
167 var tokens []cachedToken
168 for _, agentID := range o.agents {
169 cacheID := fmt.Sprintf("%s-%d", gitlabInstance, agentID)
171 data, err := keyring.Get(keyringService, cacheID)
172 if err != nil {
173 if errors.Is(err, keyring.ErrNotFound) {
174 continue // Token not found in keyring, skip
175 }
176 return nil, fmt.Errorf("failed to get token from keyring for agent %d: %w", agentID, err)
177 }
179 var pat gitlab.PersonalAccessToken
180 if err := json.Unmarshal([]byte(data), &pat); err != nil {
181 return nil, fmt.Errorf("failed to unmarshal token for agent %d: %w", agentID, err)
182 }
184 token := cachedToken{
185 ID: cacheID,
186 AgentID: agentID,
187 GitLabURL: client.BaseURL().String(),
188 Token: &pat,
189 Source: "keyring",
190 }
192 tokens = append(tokens, token)
193 }
195 return tokens, nil
196}
198func (o *options) getFilesystemTokens() ([]cachedToken, error) {
199 var tokens []cachedToken
201 cacheDir, err := os.UserCacheDir()
202 if err != nil {
203 return nil, err
204 }
206 gitlabCacheDir := filepath.Join(cacheDir, "gitlab")
208 // Open the cache directory with os.OpenRoot for traversal-safe access
209 root, err := os.OpenRoot(gitlabCacheDir)
210 if err != nil {
211 if os.IsNotExist(err) {
212 return nil, nil // No cache directory exists
213 }
214 return nil, err
215 }
216 defer func() {
217 if cerr := root.Close(); err == nil {
218 err = cerr
219 }
220 }()
222 dir, err := root.Open(".")
223 if err != nil {
224 return nil, err
225 }
226 defer func() {
227 if cerr := dir.Close(); err == nil {
228 err = cerr
229 }
230 }()
232 entries, err := dir.ReadDir(-1)
233 if err != nil {
234 return nil, err
235 }
237 for _, entry := range entries {
238 if entry.IsDir() {
239 continue
240 }
242 token, err := o.readTokenFromFile(root, entry.Name())
243 if err != nil {
244 o.io.LogErrorf("Warning: Failed to read token from %s: %v\n", entry.Name(), err)
245 continue
246 }
247 tokens = append(tokens, *token)
248 }
250 return tokens, nil
251}
253func (o *options) readTokenFromFile(root *os.Root, filename string) (*cachedToken, error) {
254 file, err := root.Open(filename)
255 if err != nil {
256 return nil, err
257 }
258 defer func() {
259 if cerr := file.Close(); err == nil {
260 err = cerr
261 }
262 }()
264 data, err := io.ReadAll(file)
265 if err != nil {
266 return nil, err
267 }
269 var pat gitlab.PersonalAccessToken
270 if err := json.Unmarshal(data, &pat); err != nil {
271 return nil, err
272 }
274 // Parse cache ID (filename) to extract GitLab URL and agent ID
275 gitlabURL, agentID, err := agentutils.ParseCacheID(filename)
276 if err != nil {
277 return nil, err
278 }
280 // Get the absolute path for FilePath field (needed for deletion)
281 cacheDir, err := os.UserCacheDir()
282 if err != nil {
283 return nil, err
284 }
285 absPath := filepath.Join(cacheDir, "gitlab", filename)
287 token := &cachedToken{
288 ID: filename,
289 AgentID: agentID,
290 GitLabURL: gitlabURL,
291 Token: &pat,
292 Source: "filesystem",
293 FilePath: absPath,
294 }
296 return token, nil
297}
299func (o *options) revokeTokens(ctx context.Context, tokens []cachedToken) []error {
300 client, err := o.gitlabClient()
301 if err != nil {
302 return []error{fmt.Errorf("failed to create GitLab client: %w", err)}
303 }
305 var errors []error
306 for _, token := range tokens {
307 // Skip already revoked tokens
308 if token.Token.Revoked {
309 o.io.LogInfof("Token for agent %d is already revoked, skipping.\n", token.AgentID)
310 continue
311 }
313 // Skip expired tokens (they're effectively revoked)
314 if token.Token.ExpiresAt != nil && time.Time(*token.Token.ExpiresAt).Before(time.Now().UTC()) {
315 o.io.LogInfof("Token for agent %d is expired, skipping revocation.\n", token.AgentID)
316 continue
317 }
319 o.io.LogInfof("Revoking token for agent %d...\n", token.AgentID)
321 _, err := client.PersonalAccessTokens.RevokePersonalAccessTokenByID(token.Token.ID, gitlab.WithContext(ctx))
322 if err != nil {
323 errors = append(errors, fmt.Errorf("failed to revoke token for agent %d: %w", token.AgentID, err))
324 continue
325 }
327 o.io.LogInfof("Successfully revoked token for agent %d.\n", token.AgentID)
328 }
330 return errors
331}
333func (o *options) clearTokens(tokens []cachedToken) []error {
334 var errs []error
336 // Group filesystem tokens to use a single os.OpenRoot
337 var fsTokens []cachedToken
338 for _, token := range tokens {
339 if token.Source != "filesystem" {
340 continue
341 }
342 fsTokens = append(fsTokens, token)
343 }
345 // Clear filesystem tokens with os.OpenRoot
346 if len(fsTokens) > 0 {
347 cacheDir, err := os.UserCacheDir()
348 if err != nil {
349 errs = append(errs, fmt.Errorf("failed to get cache directory: %w", err))
350 } else {
351 gitlabCacheDir := filepath.Join(cacheDir, "gitlab")
352 root, err := os.OpenRoot(gitlabCacheDir)
353 if err != nil {
354 errs = append(errs, fmt.Errorf("failed to open cache directory: %w", err))
355 } else {
356 defer func() {
357 if cerr := root.Close(); cerr != nil {
358 errs = append(errs, fmt.Errorf("failed to close cache directory: %w", cerr))
359 }
360 }()
362 for _, token := range fsTokens {
363 err := root.Remove(token.ID)
364 if err != nil && !os.IsNotExist(err) {
365 errs = append(errs, fmt.Errorf("failed to delete token file for agent %d: %w", token.AgentID, err))
366 continue
367 }
368 o.io.LogInfof("Cleared token for agent %d from filesystem.\n", token.AgentID)
369 }
370 }
371 }
372 }
374 // Clear keyring tokens
375 for _, token := range tokens {
376 if token.Source != "keyring" {
377 continue
378 }
379 err := keyring.Delete(keyringService, token.ID)
380 if err != nil && !errors.Is(err, keyring.ErrNotFound) {
381 errs = append(errs, fmt.Errorf("failed to delete token from keyring for agent %d: %w", token.AgentID, err))
382 continue
383 }
384 o.io.LogInfof("Cleared token for agent %d from keyring.\n", token.AgentID)
385 }
387 return errs
388}
Diagnostics11 git calls · 234 ms
CallStatusSizeTime0234 ms
discover200185 B4 ms
git.upload-pack discover http.response.status_code=200 git.upstream.cf_ray=- git.upstream.phase=ls-refs git.upstream.dur_ms=4 git.response.bytes=185 git.server.agent=git/2.56.g1891de4-Linux git.server.object_format=sha1 git.server.caps=agent ls-refs fetch server-option object-format git.server.fetch=shallow wait-for-done filter git.protocol.version=2 git.pkt.frames=9 git.pkt.data=7 git.pkt.flush=2 git.pkt.delim=0 git.pkt.bytes=185 git.pkt.payload.max=35
ls-refs20058 KiB · hit4 ms
git.upload-pack ls-refs http.response.status_code=200 git.upstream.cf_ray=- git.upstream.phase=ls-refs git.upstream.dur_ms=4 git.response.bytes=59849 git.response.cache=HIT git.response.duration_ms=4 git.protocol.version=2 git.pkt.frames=731 git.pkt.data=730 git.pkt.flush=1 git.pkt.delim=0 git.pkt.bytes=59849 git.pkt.payload.max=143 git.ls_refs.count=730 git.ls_refs.head=refs/heads/main
fetchtree:0 · deepen 1200706 B · hit3 ms
git.upload-pack fetch http.response.status_code=200 git.upstream.cf_ray=- git.upstream.phase=fetch git.upstream.dur_ms=3 git.response.bytes=706 git.response.cache=HIT git.response.duration_ms=3 git.fetch.filter=tree:0 git.fetch.wants=0dd7574dce9e385c5c30540e6c15657adc6bdce9 git.fetch.haves.count=0 git.fetch.deepen=1 git.fetch.thin_pack=false git.fetch.ofs_delta=true git.protocol.version=2 git.pkt.frames=7 git.pkt.data=5 git.pkt.flush=1 git.pkt.delim=1 git.pkt.bytes=706 git.pkt.payload.max=606 git.sideband.band1.bytes=606 git.sideband.band2.bytes=0 git.sideband.band3.bytes=0 git.pack.objects=1 git.pack.bytes=606 git.pack.trailer=5b8940d8a309b9f86f08953120610ba63124325eOpen pack map
fetchcombine:blob:none+tree:2 · deepen 12004.2 KiB · hit3 ms
git.upload-pack fetch http.response.status_code=200 git.upstream.cf_ray=- git.upstream.phase=fetch git.upstream.dur_ms=3 git.response.bytes=4273 git.response.cache=HIT git.response.duration_ms=3 git.fetch.filter=combine:blob:none+tree:2 git.fetch.wants=0dd7574dce9e385c5c30540e6c15657adc6bdce9 git.fetch.haves.count=0 git.fetch.deepen=1 git.fetch.thin_pack=false git.fetch.ofs_delta=true git.protocol.version=2 git.pkt.frames=7 git.pkt.data=5 git.pkt.flush=1 git.pkt.delim=1 git.pkt.bytes=4273 git.pkt.payload.max=4173 git.sideband.band1.bytes=4173 git.sideband.band2.bytes=0 git.sideband.band3.bytes=0 git.pack.objects=11 git.pack.bytes=4173 git.fetch.wide.objects=11 git.fetch.wide.extra_bytes=3930 git.fetch.wide.blobs=0
fetchtree:0 · deepen 1020032 KiB · hit3 ms
git.upload-pack fetch http.response.status_code=200 git.upstream.cf_ray=- git.upstream.phase=fetch git.upstream.dur_ms=3 git.response.bytes=32926 git.response.cache=HIT git.response.duration_ms=3 git.fetch.filter=tree:0 git.fetch.wants=0dd7574dce9e385c5c30540e6c15657adc6bdce9 git.fetch.haves.count=0 git.fetch.deepen=10 git.fetch.thin_pack=false git.fetch.ofs_delta=true git.protocol.version=2 git.pkt.frames=22 git.pkt.data=20 git.pkt.flush=1 git.pkt.delim=1 git.pkt.bytes=32926 git.pkt.payload.max=32046 git.sideband.band1.bytes=32046 git.sideband.band2.bytes=0 git.sideband.band3.bytes=0 git.pack.objects=80 git.pack.bytes=32046 git.pack.ofs_delta=36 git.pack.ref_delta=0 git.pack.chain.max=2 git.pack.trailer=cb0bad5d7ffc514895d8b21c4dd470327f90bc91 git.pack.full=44Open pack map
fetchtree:02001.8 KiB · hit5 ms
git.upload-pack fetch http.response.status_code=200 git.upstream.cf_ray=- git.upstream.phase=fetch git.upstream.dur_ms=5 git.response.bytes=1857 git.response.cache=HIT git.response.duration_ms=5 git.fetch.filter=tree:0 git.fetch.wants=dce174ff8c632a19d17eea99c8a9b7c37fb2b592 git.fetch.haves.count=0 git.fetch.deepen=0 git.fetch.thin_pack=false git.fetch.ofs_delta=true git.protocol.version=2 git.pkt.frames=4 git.pkt.data=3 git.pkt.flush=1 git.pkt.delim=0 git.pkt.bytes=1857 git.pkt.payload.max=1830 git.sideband.band1.bytes=1830 git.sideband.band2.bytes=0 git.sideband.band3.bytes=0 git.pack.objects=1 git.pack.bytes=1830 git.pack.trailer=fb03183b7909876778f740d196d7516811003517Open pack map
fetchtree:0200200 B · hit2 ms
git.upload-pack fetch http.response.status_code=200 git.upstream.cf_ray=- git.upstream.phase=fetch git.upstream.dur_ms=2 git.response.bytes=200 git.response.cache=HIT git.response.duration_ms=2 git.fetch.filter=tree:0 git.fetch.wants=9988d47506dcbe3004b8b72cbdb9d66d6d75cda4 git.fetch.haves.count=0 git.fetch.deepen=0 git.fetch.thin_pack=false git.fetch.ofs_delta=true git.protocol.version=2 git.pkt.frames=4 git.pkt.data=3 git.pkt.flush=1 git.pkt.delim=0 git.pkt.bytes=200 git.pkt.payload.max=173 git.sideband.band1.bytes=173 git.sideband.band2.bytes=0 git.sideband.band3.bytes=0 git.pack.objects=1 git.pack.bytes=173 git.pack.trailer=948ee807a1ee817af67f2df94421a202e82325f9Open pack map
fetchtree:0200405 B · hit15 ms
git.upload-pack fetch http.response.status_code=200 git.upstream.cf_ray=- git.upstream.phase=fetch git.upstream.dur_ms=3 git.response.bytes=405 git.response.cache=HIT git.response.duration_ms=15 git.fetch.filter=tree:0 git.fetch.wants=d271680e941992259de0ff84d4a04bcbba55f531 git.fetch.haves.count=0 git.fetch.deepen=0 git.fetch.thin_pack=false git.fetch.ofs_delta=true git.protocol.version=2 git.pkt.frames=4 git.pkt.data=3 git.pkt.flush=1 git.pkt.delim=0 git.pkt.bytes=405 git.pkt.payload.max=378 git.sideband.band1.bytes=378 git.sideband.band2.bytes=0 git.sideband.band3.bytes=0 git.pack.objects=1 git.pack.bytes=378 git.pack.trailer=adfacba5ff1f4fcf28dcaac12e2874f6d48a7934Open pack map
fetchtree:0200175 B · hit1 ms
git.upload-pack fetch http.response.status_code=200 git.upstream.cf_ray=- git.upstream.phase=fetch git.upstream.dur_ms=1 git.response.bytes=175 git.response.cache=HIT git.response.duration_ms=1 git.fetch.filter=tree:0 git.fetch.wants=b2f8b8171cc11242e253b76b9b852197f2ebc178 git.fetch.haves.count=0 git.fetch.deepen=0 git.fetch.thin_pack=false git.fetch.ofs_delta=true git.protocol.version=2 git.pkt.frames=4 git.pkt.data=3 git.pkt.flush=1 git.pkt.delim=0 git.pkt.bytes=175 git.pkt.payload.max=148 git.sideband.band1.bytes=148 git.sideband.band2.bytes=0 git.sideband.band3.bytes=0 git.pack.objects=1 git.pack.bytes=148 git.pack.trailer=e894e38a7c0abf202dc4cff099138af128997f53Open pack map
fetchtree:0200171 B · hit2 ms
git.upload-pack fetch http.response.status_code=200 git.upstream.cf_ray=- git.upstream.phase=fetch git.upstream.dur_ms=2 git.response.bytes=171 git.response.cache=HIT git.response.duration_ms=2 git.fetch.filter=tree:0 git.fetch.wants=d36ff29c8cad8e5deac20b4b4585e3fcf9d32106 git.fetch.haves.count=0 git.fetch.deepen=0 git.fetch.thin_pack=false git.fetch.ofs_delta=true git.protocol.version=2 git.pkt.frames=4 git.pkt.data=3 git.pkt.flush=1 git.pkt.delim=0 git.pkt.bytes=171 git.pkt.payload.max=144 git.sideband.band1.bytes=144 git.sideband.band2.bytes=0 git.sideband.band3.bytes=0 git.pack.objects=1 git.pack.bytes=144 git.pack.trailer=8136ef1922cc3608c27aec688cf8596c3b07d46bOpen pack map
fetch2002.9 KiB202 ms
git.upload-pack fetch http.response.status_code=200 git.upstream.cf_ray=- git.upstream.phase=fetch git.upstream.dur_ms=201 git.response.bytes=2988 git.response.cache=MISS git.response.duration_ms=202 git.fetch.wants=7e204f394ec5ddf04027a6dc829cee9202b964e9 git.fetch.haves.count=0 git.fetch.deepen=0 git.fetch.thin_pack=false git.fetch.ofs_delta=true git.protocol.version=2 git.pkt.frames=4 git.pkt.data=3 git.pkt.flush=1 git.pkt.delim=0 git.pkt.bytes=2988 git.pkt.payload.max=2961 git.sideband.band1.bytes=2961 git.sideband.band2.bytes=0 git.sideband.band3.bytes=0
Each row is one HTTP round trip ply made to the git server for this page, on one timeline. discover asks what the server speaks, ls-refs lists branch tips, fetch brings objects by id. A hit was served by Workers Cache. Tap a row for its wire details.
- Remote
- https://gitlab.com/gitlab-org/cli
- Ref
- refs/heads/main
- Commit
- 0dd7574dce9e385c5c30540e6c15657adc6bdce9
- cf-ray
- a5eb14a44c07cf75
- Request
- 0ada7b51…
- Protocol
- v2 · sha1
- Agent
- git/2.56.g1891de4-Linux
- Filter
- advertised
- Fetch
- shallow wait-for-done filter
- Capabilities
- agent ls-refs fetch server-option object-format