GitLabgitlab-org
cli
main
1package fork
3import (
4 "context"
5 "fmt"
6 "net/http"
7 "net/url"
8 "strings"
9 "time"
11 "github.com/MakeNowJust/heredoc/v2"
12 "github.com/spf13/cobra"
14 gitlab "gitlab.com/gitlab-org/api/client-go/v3"
16 "gitlab.com/gitlab-org/cli/internal/api"
17 "gitlab.com/gitlab-org/cli/internal/cmdutils"
18 "gitlab.com/gitlab-org/cli/internal/config"
19 "gitlab.com/gitlab-org/cli/internal/git"
20 "gitlab.com/gitlab-org/cli/internal/glinstance"
21 "gitlab.com/gitlab-org/cli/internal/glrepo"
22 "gitlab.com/gitlab-org/cli/internal/iostreams"
23 "gitlab.com/gitlab-org/cli/internal/mcpannotations"
24 "gitlab.com/gitlab-org/cli/internal/run"
25)
27type options struct {
28 clone bool
29 addRemote bool
30 repo string
31 name string
32 path string
34 cloneSet bool
35 addRemoteSet bool
36 isTerminal bool
38 // whether the user specified the repo to clone
39 // if false current git repo will be cloned
40 currentDirIsParent bool
42 repoToFork glrepo.Interface
43 io *iostreams.IOStreams
44 baseRepo func() (glrepo.Interface, error)
45 remotes func() (glrepo.Remotes, error)
46 config func() config.Config
47 apiClient func(repoHost string) (*api.Client, error)
48 defaultHostname string
50 // waitFor, when set, replaces waiting for a duration, for tests.
51 waitFor func(ctx context.Context, d time.Duration) error
52}
54const (
55 forkImportPollInterval = time.Second
56 forkImportMaxPollInterval = 5 * time.Second
57 forkImportTimeout = 10 * time.Minute
58)
60func (o *options) wait(ctx context.Context, d time.Duration) error {
61 if o.waitFor != nil {
62 return o.waitFor(ctx, d)
63 }
64 select {
65 case <-ctx.Done():
66 return ctx.Err()
67 case <-time.After(d):
68 return nil
69 }
70}
72func NewCmdFork(f cmdutils.Factory) *cobra.Command {
73 opts := &options{
74 io: f.IO(),
75 baseRepo: f.BaseRepo,
76 remotes: f.Remotes,
77 config: f.Config,
78 apiClient: f.ApiClient,
79 defaultHostname: f.DefaultHostname(),
80 currentDirIsParent: true,
81 }
82 forkCmd := &cobra.Command{
83 Use: "fork [<repo>]",
84 Short: "Fork a GitLab repository.",
85 Long: heredoc.Docf(`
86 Defaults to the current repository if no repository is specified.
87 Use %[1]s--clone%[1]s and %[1]s--remote%[1]s to skip the interactive prompts.
88 `, "`"),
89 Example: heredoc.Doc(`
90 glab repo fork
91 glab repo fork namespace/repo
92 glab repo fork namespace/repo --clone`),
93 Args: cobra.MaximumNArgs(1),
94 Annotations: map[string]string{
95 mcpannotations.Destructive: "true",
96 },
97 RunE: func(cmd *cobra.Command, args []string) error {
98 opts.complete(cmd, args)
100 return opts.run(cmd.Context())
101 },
102 }
104 forkCmd.Flags().
105 StringVarP(&opts.name, "name", "n", "", "The name assigned to the new project after forking.")
106 forkCmd.Flags().
107 StringVarP(&opts.path, "path", "p", "", "The path assigned to the new project after forking.")
108 forkCmd.Flags().
109 BoolVarP(&opts.clone, "clone", "c", false, "Clone the fork. Options: true, false.")
110 forkCmd.Flags().
111 BoolVar(&opts.addRemote, "remote", false, "Add a remote for the fork. Options: true, false.")
113 return forkCmd
114}
116func (o *options) complete(cmd *cobra.Command, args []string) {
117 if len(args) > 0 {
118 o.repo = args[0]
119 o.currentDirIsParent = false
120 }
122 o.cloneSet = cmd.Flags().Changed("clone")
123 o.addRemoteSet = cmd.Flags().Changed("remote")
124 o.isTerminal = o.io.IsaTTY && o.io.IsErrTTY && o.io.IsInTTY
125}
127func (o *options) run(ctx context.Context) error {
128 var err error
130 c := o.io.Color()
131 if o.repo != "" {
132 if git.IsValidURL(o.repo) {
133 u, err := url.Parse(o.repo)
134 if err != nil {
135 return fmt.Errorf("invalid argument: %w", err)
136 }
137 o.repoToFork, err = glrepo.FromURL(u, o.defaultHostname, o.config())
138 if err != nil {
139 return fmt.Errorf("invalid argument: %w", err)
140 }
141 } else {
142 o.repoToFork, err = glrepo.FromFullName(o.repo, o.defaultHostname, o.config())
143 if err != nil {
144 return fmt.Errorf("argument error: %w", err)
145 }
146 }
147 } else {
148 o.repoToFork, err = o.baseRepo()
149 if err != nil {
150 return fmt.Errorf("unable to determine source repository: %w", err)
151 }
152 }
154 apiClient, err := o.apiClient(o.repoToFork.RepoHost())
155 if err != nil {
156 return err
157 }
158 labClient := apiClient.Lab()
160 if o.isTerminal {
161 o.io.LogErrorf("- Forking %s\n", c.Bold(o.repoToFork.FullName()))
162 }
164 forkOpts := &gitlab.ForkProjectOptions{}
165 if o.name != "" {
166 forkOpts.Name = new(o.name)
167 }
168 if o.path != "" {
169 forkOpts.Path = new(o.path)
170 }
172 forkedProject, _, err := labClient.Projects.ForkProject(o.repoToFork.FullName(), forkOpts)
173 usingExisting := false
174 if err != nil {
175 if gitlab.HasStatusCode(err, http.StatusConflict) ||
176 strings.Contains(err.Error(), "Project namespace name has already been taken") ||
177 strings.Contains(err.Error(), "Name has already been taken") {
179 o.io.LogError(c.Yellow("! Repository already exists in your namespace"))
181 namespace := o.path
182 currentUser, err := api.UserByName(labClient, "@me")
183 if err != nil {
184 return err
185 }
187 if namespace == "" && currentUser != nil {
188 namespace = currentUser.Username
189 }
191 remoteDesired := o.addRemote
193 if o.isTerminal {
194 if !o.addRemoteSet {
195 remoteDesired = true // set the default value
196 err := o.io.Confirm(
197 ctx,
198 &remoteDesired,
199 "Would you like to add this repository as a remote instead?",
200 )
201 if err != nil {
202 return err
203 }
204 }
206 switch {
207 case remoteDesired:
208 // First search for the project name (user-namespace only)
209 forkedProject, searchErr := searchProject(o, labClient)
211 if searchErr != nil {
212 return fmt.Errorf("error searching for existing project: %w", searchErr)
213 }
215 // Safety check - make sure we have a valid project
216 if forkedProject == nil {
217 return fmt.Errorf(
218 "could not find matching project for %s",
219 o.repoToFork.RepoName(),
220 )
221 }
223 o.io.LogErrorf(
224 "%s Using existing repository %s.\n",
225 c.GreenCheck(),
226 c.Bold(forkedProject.PathWithNamespace),
227 )
228 remoteName := "origin"
230 protocol, err := o.config().Get(o.repoToFork.RepoHost(), "git_protocol")
231 if err != nil {
232 o.io.LogErrorf(
233 "%s: %q. Falling back to default protocol.",
234 c.Yellow("Warning"),
235 err.Error(),
236 )
237 // Use a reasonable default if we can't get the configured protocol
238 protocol = glinstance.DefaultProtocol
239 }
241 forkedRepoCloneURL, err := glrepo.RemoteURL(forkedProject, protocol)
242 if err != nil {
243 return err
244 }
245 if err := o.addOrReplaceRemote(remoteName, "upstream", forkedRepoCloneURL); err != nil {
246 return err
247 }
248 // Return early since we've successfully handled the existing repository case
249 return nil
250 case !o.currentDirIsParent:
251 o.io.LogErrorf("- You can clone the existing repository with:")
252 o.io.LogErrorf(" %s\n", c.Gray(fmt.Sprintf("glab repo clone %s/%s", namespace, o.repoToFork.RepoName())))
253 return nil
254 default:
255 return nil
256 }
257 }
258 } else {
259 return err
260 }
261 }
262 // The forking operation for a project is asynchronous and is completed in a background job.
263 // The request returns immediately. To determine whether the fork of the project has completed,
264 // we query the import_status for the new project.
265 importStatus := ""
266 maximumRetries := 3
267 retries := 0
268 skipFirstCheck := true
269 interval := forkImportPollInterval
270 var waited time.Duration
272 if !usingExisting && (forkedProject == nil || forkedProject.ImportStatus != "") {
273 loop:
274 for {
275 // Add a defensive check to prevent nil pointer dereference when accessing forkedProject.ID
276 if !skipFirstCheck {
277 // Safety check - make sure forkedProject is not nil before accessing its ID field
278 if forkedProject == nil {
279 o.io.LogErrorf("Error: Lost track of forked project during status check")
280 break loop
281 }
283 if waited >= forkImportTimeout {
284 return fmt.Errorf(
285 "timed out after %s waiting for fork %s to finish importing. Check its import_status later with: glab repo view %s --output json",
286 forkImportTimeout, forkedProject.PathWithNamespace, forkedProject.WebURL,
287 )
288 }
289 if err := o.wait(ctx, interval); err != nil {
290 return err
291 }
292 waited += interval
293 interval = min(interval*2, forkImportMaxPollInterval)
295 // Now it's safe to access forkedProject.ID
296 p, err := api.GetProject(labClient, forkedProject.ID)
297 if err != nil {
298 if retries == maximumRetries {
299 return fmt.Errorf(
300 "checking import status of fork %s: %w. Check its import_status later with: glab repo view %s --output json",
301 forkedProject.PathWithNamespace, err, forkedProject.WebURL,
302 )
303 }
304 o.io.LogErrorf("error checking fork status: %q", err.Error())
305 o.io.LogError("- Retrying...")
306 retries++
307 continue
308 }
309 retries = 0
310 forkedProject = p
311 }
312 skipFirstCheck = false
314 // check import status of Fork
315 // Import status should be one of {none, failed, scheduled, started, finished}
316 // https://docs.gitlab.com/api/project_import_export/#retrieve-the-status-of-a-project-import
317 if forkedProject == nil {
318 o.io.LogErrorf("Error: Lost track of forked project during status check")
319 break loop
320 }
322 // Now it's safe to access forkedProject.ImportStatus
323 switch forkedProject.ImportStatus {
324 case "none": // no import initiated
325 break loop
326 case importStatus:
327 continue
328 case "scheduled", "started": // import scheduled or started
329 if importStatus != forkedProject.ImportStatus { // avoid printing the same message again
330 o.io.LogError("- " + forkedProject.ImportStatus)
331 importStatus = forkedProject.ImportStatus
332 }
333 case "finished": // import completed
334 o.io.LogError("- " + forkedProject.ImportStatus)
335 break loop
336 case "failed": // import failed
337 return fmt.Errorf("fork %s failed to import: %s", forkedProject.PathWithNamespace, forkedProject.ImportError)
338 default:
339 break loop
340 }
341 }
342 }
344 // Only print one message about the fork creation
345 if forkedProject != nil {
346 o.io.LogErrorf(
347 "%s Created fork %s.\n",
348 c.GreenCheck(),
349 forkedProject.PathWithNamespace,
350 )
351 } else {
352 o.io.LogErrorf("\n%s Created fork but couldn't retrieve details.\n", c.GreenCheck())
353 // Early return since we can't proceed with a nil forkedProject
354 return nil
355 }
357 if (!o.isTerminal && o.currentDirIsParent && (!o.addRemote && o.addRemoteSet)) ||
358 (!o.currentDirIsParent && (!o.clone && o.addRemoteSet)) {
359 return nil
360 }
362 cfg := o.config()
363 protocol, err := cfg.Get(o.repoToFork.RepoHost(), "git_protocol")
364 if err != nil {
365 return err
366 }
368 if o.currentDirIsParent {
369 // Safety check for Remotes method
370 if o.remotes == nil {
371 o.io.LogErrorf("%s: Unable to access git remotes", c.Red("Error"))
372 return fmt.Errorf("remotes method is nil")
373 }
375 remotes, err := o.remotes()
376 if err != nil {
377 return err
378 }
380 if remote, err := remotes.FindByRepo(o.repoToFork.RepoOwner(), o.repoToFork.RepoName()); err == nil {
381 scheme := ""
382 if remote.FetchURL != nil {
383 scheme = remote.FetchURL.Scheme
384 }
385 if remote.PushURL != nil {
386 scheme = remote.PushURL.Scheme
387 }
388 if scheme != "" {
389 protocol = scheme
390 }
391 }
393 // Defensive check for forkedProject's Namespace
394 if forkedProject.Namespace != nil {
395 if remote, err := remotes.FindByRepo(forkedProject.Namespace.FullPath, forkedProject.Path); err == nil {
396 if o.isTerminal {
397 o.io.LogErrorf(
398 "%s Using existing remote %s.\n",
399 c.GreenCheck(),
400 c.Bold(remote.Name),
401 )
402 }
403 return nil
404 }
405 }
407 remoteDesired := o.addRemote
408 if !o.addRemoteSet {
409 remoteDesired = true // set the default value
410 err = o.io.Confirm(
411 ctx,
412 &remoteDesired,
413 "Would you like to add a remote for the fork?",
414 )
415 if err != nil {
416 return fmt.Errorf("failed to prompt: %w", err)
417 }
418 }
419 if remoteDesired {
420 remoteName := "origin"
421 forkedRepoCloneURL, err := glrepo.RemoteURL(forkedProject, protocol)
422 if err != nil {
423 return err
424 }
425 if err := o.addOrReplaceRemote(remoteName, "upstream", forkedRepoCloneURL); err != nil {
426 return err
427 }
428 }
429 } else {
430 cloneDesired := o.clone
431 if !cloneDesired {
432 // If clone is explicitly set to false exit
433 if o.cloneSet {
434 return nil
435 }
436 cloneDesired = true // set the default value
437 err = o.io.Confirm(ctx, &cloneDesired, "Would you like to clone the fork?")
438 if err != nil {
439 return fmt.Errorf("failed to prompt: %w", err)
440 }
441 }
442 if cloneDesired {
443 repoToFork, err := api.GetProject(labClient, o.repoToFork.FullName())
444 if err != nil {
445 return err
446 }
447 forkedRepoURL, err := glrepo.RemoteURL(forkedProject, protocol)
448 if err != nil {
449 return err
450 }
451 cloneDir, err := git.RunClone(forkedRepoURL, "", []string{})
452 if err != nil {
453 return fmt.Errorf("failed to clone fork: %w", err)
454 }
455 upstreamURL, err := glrepo.RemoteURL(repoToFork, protocol)
456 if err != nil {
457 return err
458 }
459 err = git.AddUpstreamRemote(upstreamURL, cloneDir)
460 if err != nil {
461 return err
462 }
464 if o.isTerminal {
465 o.io.LogErrorf("%s Cloned fork.\n", c.GreenCheck())
466 }
467 }
468 }
469 return nil
470}
472func searchProject(o *options, client *gitlab.Client) (*gitlab.Project, error) {
473 projects, _, err := client.Projects.ListProjects(&gitlab.ListProjectsOptions{
474 Search: new(o.repoToFork.RepoName()),
475 })
476 if err != nil {
477 o.io.LogErrorf("ERROR: Cannot list projects: %v\n", err)
478 return nil, err
479 }
481 currentUser, err := api.UserByName(client, "@me")
482 if err != nil {
483 o.io.LogErrorf("ERROR: Cannot get current user: %v\n", err)
484 return nil, err
485 }
487 // Attempt to find the project in the current user's namespace (which must match the username)
488 for _, project := range projects {
489 if project != nil && project.Namespace != nil && currentUser != nil {
490 if project.Namespace.Path == currentUser.Username {
491 return project, nil
492 }
493 }
494 }
496 // No matching project found; output error about unsupported namespaces
497 c := o.io.Color()
498 o.io.LogError(
499 c.Red(
500 "Error: Only user namespaces that are equal to your username are currently supported.",
501 ),
502 )
503 return nil, fmt.Errorf("no project found for user namespace %s", currentUser.Username)
504}
506// addOrReplaceRemote handles adding a new remote, renaming existing remotes if needed.
507// If a remote with remoteName already exists, it will be renamed to fallbackName.
508func (o *options) addOrReplaceRemote(remoteName, fallbackName, remoteURL string) error {
509 // Safety check for Remotes method
510 if o.remotes == nil {
511 return fmt.Errorf("remotes method is nil")
512 }
514 remotes, err := o.remotes()
515 if err != nil {
516 return err
517 }
519 c := o.io.Color()
521 // If remote exists, rename it to fallback name
522 if _, err := remotes.FindByName(remoteName); err == nil {
523 renameCmd := git.GitCommand("remote", "rename", remoteName, fallbackName)
524 err = run.PrepareCmd(renameCmd).Run()
525 if err != nil {
526 return err
527 }
528 if o.isTerminal {
529 o.io.LogErrorf("%s Renamed %s remote to %s\n",
530 c.GreenCheck(),
531 c.Bold(remoteName),
532 c.Bold(fallbackName))
533 }
534 }
536 // Add the new remote
537 _, err = git.AddRemote(remoteName, remoteURL)
538 if err != nil {
539 return fmt.Errorf("failed to add remote: %w", err)
540 }
542 if o.isTerminal {
543 o.io.LogErrorf("%s Added remote %s.\n",
544 c.GreenCheck(),
545 c.Bold(remoteName))
546 }
548 return nil
549}
Diagnostics8 git calls · 274 ms
CallStatusSizeTime0274 ms
discover200185 B3 ms
git.upload-pack discover http.response.status_code=200 git.upstream.cf_ray=- git.upstream.phase=ls-refs git.upstream.dur_ms=3 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 · hit3 ms
git.upload-pack ls-refs http.response.status_code=200 git.upstream.cf_ray=- git.upstream.phase=ls-refs git.upstream.dur_ms=3 git.response.bytes=59849 git.response.cache=HIT git.response.duration_ms=3 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
fetchcombine:blob:none+tree:2 · deepen 12004.2 KiB · hit2 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=2 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=2 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 · 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=1857 git.response.cache=HIT git.response.duration_ms=2 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:0200614 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=614 git.response.cache=HIT git.response.duration_ms=3 git.fetch.filter=tree:0 git.fetch.wants=3a89d0cfc8e81880c982180388e42e561a0b7eee 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=614 git.pkt.payload.max=587 git.sideband.band1.bytes=587 git.sideband.band2.bytes=0 git.sideband.band3.bytes=0 git.pack.objects=1 git.pack.bytes=587 git.pack.trailer=eb8250f8e8340ff2fafc22c5aba90db34fd906a9Open pack map
fetchtree:0200135 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=135 git.response.cache=HIT git.response.duration_ms=3 git.fetch.filter=tree:0 git.fetch.wants=61242e1c99581959d53d127c44fe3b7a850ec910 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=135 git.pkt.payload.max=108 git.sideband.band1.bytes=108 git.sideband.band2.bytes=0 git.sideband.band3.bytes=0 git.pack.objects=1 git.pack.bytes=108 git.pack.trailer=fb4b28ee8cfd7eb1dbbed1f8d8abfc22770a9415Open pack map
fetch2004.5 KiB261 ms
git.upload-pack fetch http.response.status_code=200 git.upstream.cf_ray=- git.upstream.phase=fetch git.upstream.dur_ms=261 git.response.bytes=4603 git.response.cache=MISS git.response.duration_ms=261 git.fetch.wants=df4c8af6a0675b2d205c217d4df05b0ac2de7d82 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=4603 git.pkt.payload.max=4576 git.sideband.band1.bytes=4576 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
- a5ea56571b2a7089
- Request
- 98411386…
- 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