GitLabgitlab-org
cli
main
1//go:build !integration
3package fallbacksync
5import (
6 "encoding/json"
7 "errors"
8 "os"
9 "os/exec"
10 "path/filepath"
11 "strings"
12 "testing"
13 "time"
15 "github.com/stretchr/testify/assert"
16 "github.com/stretchr/testify/require"
17 "go.uber.org/mock/gomock"
19 "gitlab.com/gitlab-org/cli/internal/commands/govern/internal/claudehooks"
20 "gitlab.com/gitlab-org/cli/internal/commands/govern/internal/opencodeplugin"
21 "gitlab.com/gitlab-org/cli/internal/testing/cmdtest"
22)
24func TestUnits_Darwin(t *testing.T) {
25 t.Parallel()
27 units, err := Units("darwin", "/home/me", Job{GlabPath: "/opt/homebrew/bin/glab", ConfigDir: "/home/me/.config/glab-cli"})
28 require.NoError(t, err)
29 require.Len(t, units, 1)
31 assert.Equal(t, "/home/me/Library/LaunchAgents/com.gitlab.glab-govern-audit-sync.plist", units[0].Path)
32 assert.Equal(t, `<?xml version="1.0" encoding="UTF-8"?>
33<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
34<plist version="1.0">
35<dict>
36 <key>Label</key>
37 <string>com.gitlab.glab-govern-audit-sync</string>
38 <key>ProgramArguments</key>
39 <array>
40 <string>/opt/homebrew/bin/glab</string>
41 <string>minder</string>
42 <string>audit</string>
43 <string>sync</string>
44 <string>--all</string>
45 <string>--silent</string>
46 </array>
47 <key>EnvironmentVariables</key>
48 <dict>
49 <key>GLAB_CONFIG_DIR</key>
50 <string>/home/me/.config/glab-cli</string>
51 </dict>
52 <key>StartInterval</key>
53 <integer>1800</integer>
54 <key>RunAtLoad</key>
55 <false/>
56</dict>
57</plist>
58`, units[0].Content)
59}
61func TestUnits_Linux(t *testing.T) {
62 t.Parallel()
64 units, err := Units("linux", "/home/me", Job{GlabPath: "/home/me/.local/share/mise/shims/glab", ConfigDir: "/home/me/.config/glab-cli"})
65 require.NoError(t, err)
66 require.Len(t, units, 2)
68 assert.Equal(t, "/home/me/.config/systemd/user/glab-govern-audit-sync.service", units[0].Path)
69 assert.Equal(t, `[Unit]
70Description=GitLab AI agent governance fallback sync
72[Service]
73Type=oneshot
74Environment="GLAB_CONFIG_DIR=/home/me/.config/glab-cli"
75ExecStart="/home/me/.local/share/mise/shims/glab" minder audit sync --all --silent
76`, units[0].Content)
78 assert.Equal(t, "/home/me/.config/systemd/user/glab-govern-audit-sync.timer", units[1].Path)
79 assert.Equal(t, `[Unit]
80Description=GitLab AI agent governance fallback sync timer
82[Timer]
83OnBootSec=5min
84OnUnitActiveSec=30min
86[Install]
87WantedBy=timers.target
88`, units[1].Content)
89}
91func TestUnits_Unsupported(t *testing.T) {
92 t.Parallel()
94 _, err := Units("windows", `C:\Users\me`, Job{GlabPath: `C:\glab.exe`})
95 require.ErrorIs(t, err, ErrUnsupportedOS)
96}
98func TestInstalledBinary_RoundTrip(t *testing.T) {
99 t.Parallel()
101 for _, goos := range []string{"darwin", "linux"} {
102 t.Run(goos, func(t *testing.T) {
103 t.Parallel()
104 home := t.TempDir()
105 glab := `/odd path/100%/a&b/"q"\x/glab`
107 units, err := Units(goos, home, Job{GlabPath: glab, ConfigDir: `/cfg/50%/"x"`})
108 require.NoError(t, err)
109 for _, u := range units {
110 require.NoError(t, os.MkdirAll(filepath.Dir(u.Path), 0o755))
111 require.NoError(t, os.WriteFile(u.Path, []byte(u.Content), 0o644))
112 }
114 got, err := InstalledBinary(goos, home)
115 require.NoError(t, err)
116 assert.Equal(t, glab, got)
117 })
118 }
119}
121func TestInstalledBinary_NotInstalled(t *testing.T) {
122 t.Parallel()
124 _, err := InstalledBinary("linux", t.TempDir())
125 require.ErrorIs(t, err, ErrNotInstalled)
126}
128func TestInstallUninstall_Darwin(t *testing.T) {
129 t.Parallel()
131 home := t.TempDir()
132 plist := filepath.Join(home, "Library", "LaunchAgents", "com.gitlab.glab-govern-audit-sync.plist")
133 mExec := cmdtest.NewMockExecutor(gomock.NewController(t))
135 gomock.InOrder(
136 mExec.EXPECT().
137 ExecWithCombinedOutput(gomock.Any(), "launchctl", []string{"bootout", "gui/501/com.gitlab.glab-govern-audit-sync"}, nil).
138 Return([]byte("not loaded"), errors.New("exit status 3")),
139 mExec.EXPECT().
140 ExecWithCombinedOutput(gomock.Any(), "launchctl", []string{"bootstrap", "gui/501", plist}, nil).
141 Return(nil, nil),
142 mExec.EXPECT().
143 ExecWithCombinedOutput(gomock.Any(), "launchctl", []string{"bootout", "gui/501/com.gitlab.glab-govern-audit-sync"}, nil).
144 Return(nil, nil),
145 )
147 require.NoError(t, Install(t.Context(), mExec, "darwin", home, Job{GlabPath: "/usr/local/bin/glab"}, 501))
148 assert.FileExists(t, plist)
150 removed, err := Uninstall(t.Context(), mExec, "darwin", home, 501)
151 require.NoError(t, err)
152 assert.True(t, removed)
153 assert.NoFileExists(t, plist)
154}
156func TestInstallUninstall_Linux(t *testing.T) {
157 t.Parallel()
159 home := t.TempDir()
160 dir := filepath.Join(home, ".config", "systemd", "user")
161 mExec := cmdtest.NewMockExecutor(gomock.NewController(t))
163 gomock.InOrder(
164 mExec.EXPECT().
165 ExecWithCombinedOutput(gomock.Any(), "systemctl", []string{"--user", "daemon-reload"}, nil).
166 Return(nil, nil),
167 mExec.EXPECT().
168 ExecWithCombinedOutput(gomock.Any(), "systemctl", []string{"--user", "enable", "--now", "glab-govern-audit-sync.timer"}, nil).
169 Return(nil, nil),
170 mExec.EXPECT().
171 ExecWithCombinedOutput(gomock.Any(), "systemctl", []string{"--user", "disable", "--now", "glab-govern-audit-sync.timer"}, nil).
172 Return(nil, nil),
173 mExec.EXPECT().
174 ExecWithCombinedOutput(gomock.Any(), "systemctl", []string{"--user", "daemon-reload"}, nil).
175 Return(nil, nil),
176 )
178 require.NoError(t, Install(t.Context(), mExec, "linux", home, Job{GlabPath: "/usr/bin/glab"}, 1000))
179 assert.FileExists(t, filepath.Join(dir, "glab-govern-audit-sync.service"))
180 assert.FileExists(t, filepath.Join(dir, "glab-govern-audit-sync.timer"))
182 removed, err := Uninstall(t.Context(), mExec, "linux", home, 1000)
183 require.NoError(t, err)
184 assert.True(t, removed)
185 assert.NoFileExists(t, filepath.Join(dir, "glab-govern-audit-sync.service"))
186 assert.NoFileExists(t, filepath.Join(dir, "glab-govern-audit-sync.timer"))
187}
189func TestInstall_LoadFailure(t *testing.T) {
190 t.Parallel()
192 mExec := cmdtest.NewMockExecutor(gomock.NewController(t))
193 mExec.EXPECT().
194 ExecWithCombinedOutput(gomock.Any(), "systemctl", []string{"--user", "daemon-reload"}, nil).
195 Return([]byte("Failed to connect to bus"), errors.New("exit status 1"))
197 home := t.TempDir()
198 err := Install(t.Context(), mExec, "linux", home, Job{GlabPath: "/usr/bin/glab"}, 1000)
199 require.Error(t, err)
200 assert.Contains(t, err.Error(), "Failed to connect to bus")
202 _, err = InstalledBinary("linux", home)
203 require.ErrorIs(t, err, ErrNotInstalled, "a job that could not be loaded is not left installed")
204}
206func TestUninstall_NothingInstalled(t *testing.T) {
207 t.Parallel()
209 mExec := cmdtest.NewMockExecutor(gomock.NewController(t))
210 mExec.EXPECT().
211 ExecWithCombinedOutput(gomock.Any(), "systemctl", []string{"--user", "disable", "--now", "glab-govern-audit-sync.timer"}, nil).
212 Return(nil, errors.New("unit not found"))
214 removed, err := Uninstall(t.Context(), mExec, "linux", t.TempDir(), 1000)
215 require.NoError(t, err)
216 assert.False(t, removed)
217}
219func TestStatus_RoundTrip(t *testing.T) {
220 t.Setenv("GLAB_CONFIG_DIR", t.TempDir())
222 _, err := ReadStatus()
223 require.ErrorIs(t, err, ErrNoStatus)
225 want := Status{
226 StartedAt: time.Date(2026, 10, 8, 1, 0, 0, 0, time.UTC),
227 FinishedAt: time.Date(2026, 10, 8, 1, 0, 2, 0, time.UTC),
228 SessionsSynced: 2,
229 EventsPosted: 5,
230 Errors: []string{"session a: boom"},
231 }
232 require.NoError(t, WriteStatus(want))
234 got, err := ReadStatus()
235 require.NoError(t, err)
236 assert.Equal(t, want, *got)
237}
239func TestState_Darwin(t *testing.T) {
240 t.Parallel()
242 launchctlPrint := func(t *testing.T, out string, err error) JobState {
243 t.Helper()
244 mExec := cmdtest.NewMockExecutor(gomock.NewController(t))
245 mExec.EXPECT().
246 ExecWithCombinedOutput(gomock.Any(), "launchctl", []string{"print", "gui/501/com.gitlab.glab-govern-audit-sync"}, nil).
247 Return([]byte(out), err)
248 state, stateErr := State(t.Context(), mExec, "darwin", 501)
249 require.NoError(t, stateErr)
250 return state
251 }
253 t.Run("failed run", func(t *testing.T) {
254 t.Parallel()
255 state := launchctlPrint(t, "gui/501/com.gitlab.glab-govern-audit-sync = {\n\texit timeout = 5\n\truns = 1\n\tlast exit code = 1\n}\n", nil)
256 assert.Equal(t, JobState{Loaded: true, Ran: true, ExitCode: 1}, state)
257 })
259 t.Run("never run", func(t *testing.T) {
260 t.Parallel()
261 state := launchctlPrint(t, "gui/501/com.gitlab.glab-govern-audit-sync = {\n\truns = 0\n\tlast exit code = (never exited)\n}\n", nil)
262 assert.Equal(t, JobState{Loaded: true}, state)
263 })
265 t.Run("not loaded", func(t *testing.T) {
266 t.Parallel()
267 state := launchctlPrint(t, "Could not find service \"com.gitlab.glab-govern-audit-sync\" in domain for user gui: 501\n", &exec.ExitError{})
268 assert.Equal(t, JobState{}, state)
269 })
271 t.Run("launchctl does not run", func(t *testing.T) {
272 t.Parallel()
273 mExec := cmdtest.NewMockExecutor(gomock.NewController(t))
274 mExec.EXPECT().ExecWithCombinedOutput(gomock.Any(), "launchctl", gomock.Any(), nil).Return(nil, exec.ErrNotFound)
275 _, err := State(t.Context(), mExec, "darwin", 501)
276 require.ErrorIs(t, err, exec.ErrNotFound)
277 })
278}
280func TestState_Linux(t *testing.T) {
281 t.Parallel()
283 mExec := cmdtest.NewMockExecutor(gomock.NewController(t))
284 gomock.InOrder(
285 mExec.EXPECT().
286 ExecWithCombinedOutput(gomock.Any(), "systemctl", []string{"--user", "is-active", "--quiet", "glab-govern-audit-sync.timer"}, nil).
287 Return(nil, nil),
288 mExec.EXPECT().
289 ExecWithCombinedOutput(gomock.Any(), "systemctl", []string{"--user", "show", "glab-govern-audit-sync.service", "--property=ExecMainStartTimestampMonotonic,ExecMainStatus"}, nil).
290 Return([]byte("ExecMainStartTimestampMonotonic=0\nExecMainStatus=0\n"), nil),
291 )
293 state, err := State(t.Context(), mExec, "linux", 1000)
294 require.NoError(t, err)
295 assert.Equal(t, JobState{Loaded: true}, state, "a start timestamp of 0 means the service has not run since boot")
296}
298func TestDiscoveredAgents_RoundTrip(t *testing.T) {
299 t.Setenv("GLAB_CONFIG_DIR", t.TempDir())
301 agents, err := DiscoveredAgents()
302 require.NoError(t, err)
303 assert.Empty(t, agents, "no agents are discovered until setup enables them")
305 require.NoError(t, SetDiscoveredAgents([]string{"codex"}))
306 agents, err = DiscoveredAgents()
307 require.NoError(t, err)
308 assert.Equal(t, []string{"codex"}, agents)
309}
311func TestHookAgents(t *testing.T) {
312 t.Setenv("GLAB_CONFIG_DIR", t.TempDir())
314 _, recorded, err := RecordedHookAgents()
315 require.NoError(t, err)
316 assert.False(t, recorded, "nothing is recorded before setup chooses")
318 require.NoError(t, SetHookAgents([]string{}))
319 agents, recorded, err := RecordedHookAgents()
320 require.NoError(t, err)
321 assert.True(t, recorded, "choosing no hook agents is a choice")
322 assert.Empty(t, agents)
324 require.NoError(t, SetHookAgents([]string{"opencode"}))
325 agents, _, err = RecordedHookAgents()
326 require.NoError(t, err)
327 assert.Equal(t, []string{"opencode"}, agents)
329 require.NoError(t, ForgetHookAgents())
330 _, recorded, err = RecordedHookAgents()
331 require.NoError(t, err)
332 assert.False(t, recorded)
333 require.NoError(t, ForgetHookAgents(), "forgetting twice is fine")
334}
336func TestAgentSetups_RoundTrip(t *testing.T) {
337 t.Setenv("GLAB_CONFIG_DIR", t.TempDir())
339 setups, err := ReadAgentSetups()
340 require.NoError(t, err)
341 assert.Empty(t, setups, "nothing is recorded before setup")
343 at := time.Date(2026, 11, 20, 10, 0, 0, 0, time.UTC)
344 want := AgentSetups{"claude-code": {SetUpAt: at}, "codex": {SetUpAt: at, History: true}}
345 require.NoError(t, SetAgentSetups(want))
346 setups, err = ReadAgentSetups()
347 require.NoError(t, err)
348 assert.Equal(t, want, setups)
349}
351func TestAgentSetups_Unreadable(t *testing.T) {
352 dir := t.TempDir()
353 t.Setenv("GLAB_CONFIG_DIR", dir)
354 path := filepath.Join(dir, "gaig", "agent-setups.json")
355 require.NoError(t, os.MkdirAll(filepath.Dir(path), 0o755))
356 require.NoError(t, os.WriteFile(path, []byte("{not json"), 0o600))
358 _, err := ReadAgentSetups()
359 require.ErrorContains(t, err, "could not parse "+path)
360 assert.Contains(t, AgentsReadFix(err), "--uninstall", "uninstalling removes the file")
361}
363func TestAgentSetups_UploadsFrom(t *testing.T) {
364 t.Parallel()
366 at := time.Date(2026, 11, 20, 10, 0, 0, 0, time.UTC)
367 setups := AgentSetups{"claude-code": {SetUpAt: at}, "codex": {SetUpAt: at, History: true}}
369 tests := map[string]struct {
370 setups AgentSetups
371 agent string
372 want time.Time
373 }{
374 "set up": {setups: setups, agent: "claude-code", want: at},
375 "opted in to history": {setups: setups, agent: "codex"},
376 "set up before setups were kept": {setups: setups, agent: "cursor"},
377 "nothing recorded": {agent: "claude-code"},
378 }
379 for name, tc := range tests {
380 t.Run(name, func(t *testing.T) {
381 t.Parallel()
382 assert.Equal(t, tc.want, tc.setups.UploadsFrom(tc.agent))
383 })
384 }
385}
387func TestResolvedHookAgents(t *testing.T) {
388 setup := func(t *testing.T) string {
389 t.Helper()
390 home := t.TempDir()
391 t.Setenv("HOME", home)
392 t.Setenv("XDG_CONFIG_HOME", "")
393 t.Setenv("GLAB_CONFIG_DIR", t.TempDir())
394 return filepath.Join(home, ".claude", "settings.json")
395 }
396 installHooks := func(t *testing.T, path string) {
397 t.Helper()
398 hooks := map[string][]claudehooks.HookGroup{}
399 claudehooks.AddHook(hooks, "Stop", claudehooks.StopHookCommand)
400 hooksJSON, err := claudehooks.MarshalHooks(hooks)
401 require.NoError(t, err)
402 require.NoError(t, claudehooks.WriteSettings(path, map[string]json.RawMessage{"hooks": hooksJSON}))
403 }
405 t.Run("nothing set up", func(t *testing.T) {
406 settings := setup(t)
407 agents, err := ResolvedHookAgents(settings)
408 require.NoError(t, err)
409 assert.Empty(t, agents)
410 })
412 t.Run("recorded choice", func(t *testing.T) {
413 settings := setup(t)
414 installHooks(t, settings)
415 require.NoError(t, SetHookAgents([]string{"opencode"}))
416 agents, err := ResolvedHookAgents(settings)
417 require.NoError(t, err)
418 assert.Equal(t, []string{"opencode"}, agents, "the recorded choice wins over what is installed")
419 })
421 t.Run("older glab: installed hooks and plugin", func(t *testing.T) {
422 settings := setup(t)
423 installHooks(t, settings)
424 plugin, err := opencodeplugin.Path()
425 require.NoError(t, err)
426 _, err = opencodeplugin.Install(plugin)
427 require.NoError(t, err)
428 agents, err := ResolvedHookAgents(settings)
429 require.NoError(t, err)
430 assert.Equal(t, []string{"claude-code", "opencode"}, agents)
431 })
433 t.Run("unreadable settings file", func(t *testing.T) {
434 settings := setup(t)
435 require.NoError(t, os.MkdirAll(filepath.Dir(settings), 0o755))
436 require.NoError(t, os.WriteFile(settings, []byte("{not json"), 0o644))
437 _, err := ResolvedHookAgents(settings)
438 require.Error(t, err, "an unknown answer must not be recorded as no Claude Code")
439 })
440}
442func TestDefaultHookAgents(t *testing.T) {
443 t.Parallel()
445 assert.Equal(t, []string{"claude-code"}, DefaultHookAgents(nil, nil), "a first setup syncs Claude Code")
446 assert.Empty(t, DefaultHookAgents(nil, []string{"codex"}), "Claude Code is not added for someone who only set up Codex")
447 assert.Equal(t, []string{"opencode"}, DefaultHookAgents([]string{"opencode"}, nil))
448}
450func TestReadInstalled_Legacy(t *testing.T) {
451 t.Parallel()
453 for _, goos := range []string{"darwin", "linux"} {
454 t.Run(goos, func(t *testing.T) {
455 t.Parallel()
456 home := t.TempDir()
458 units, err := Units(goos, home, Job{GlabPath: "/usr/local/bin/glab", ConfigDir: "/home/me/.config/glab-cli"})
459 require.NoError(t, err)
460 require.NoError(t, os.MkdirAll(filepath.Dir(units[0].Path), 0o755))
461 require.NoError(t, os.WriteFile(units[0].Path, []byte(units[0].Content), 0o644))
463 job, err := ReadInstalled(goos, home)
464 require.NoError(t, err)
465 assert.Equal(t, Installed{GlabPath: "/usr/local/bin/glab"}, job)
467 old := strings.NewReplacer("<string>minder</string>", "<string>govern</string>", `" minder audit sync `, `" govern audit sync `).
468 Replace(units[0].Content)
469 require.NotEqual(t, units[0].Content, old)
470 require.NoError(t, os.WriteFile(units[0].Path, []byte(old), 0o644))
472 job, err = ReadInstalled(goos, home)
473 require.NoError(t, err)
474 assert.Equal(t, Installed{GlabPath: "/usr/local/bin/glab", Legacy: true}, job, "a job from before the rename to glab minder runs glab govern")
475 })
476 }
477}
Diagnostics9 git calls · 247 ms
CallStatusSizeTime0247 ms
discover200185 B3 ms
git.upload-pack discover http.response.status_code=200 git.upstream.cf_ray=- git.upstream.phase=fetch 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 KiB2 ms
git.upload-pack ls-refs http.response.status_code=200 git.upstream.cf_ray=- git.upstream.phase=ls-refs git.upstream.dur_ms=2 git.response.bytes=59849 git.response.cache=UPDATING git.response.duration_ms=2 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 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=4 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
fetchcombine:blob:none+tree:2 · deepen 12004.2 KiB · hit4 ms
git.upload-pack fetch http.response.status_code=200 git.upstream.cf_ray=- git.upstream.phase=fetch git.upstream.dur_ms=4 git.response.bytes=4273 git.response.cache=HIT git.response.duration_ms=4 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:02001.8 KiB · hit4 ms
git.upload-pack fetch http.response.status_code=200 git.upstream.cf_ray=- git.upstream.phase=fetch git.upstream.dur_ms=4 git.response.bytes=1857 git.response.cache=HIT git.response.duration_ms=4 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:0200261 B · hit4 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=261 git.response.cache=HIT git.response.duration_ms=4 git.fetch.filter=tree:0 git.fetch.wants=3bb9946301aa8c0dc8d202b83bc9f84bf0400f6d 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=261 git.pkt.payload.max=234 git.sideband.band1.bytes=234 git.sideband.band2.bytes=0 git.sideband.band3.bytes=0 git.pack.objects=1 git.pack.bytes=234 git.pack.trailer=e0a52f164f79506da6b0dcc275ed62911f5383bfOpen pack map
fetchtree:0200273 B · 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=273 git.response.cache=HIT git.response.duration_ms=2 git.fetch.filter=tree:0 git.fetch.wants=5fa160737ad30857ff606d64de1d596bb211ac3d 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=273 git.pkt.payload.max=246 git.sideband.band1.bytes=246 git.sideband.band2.bytes=0 git.sideband.band3.bytes=0 git.pack.objects=1 git.pack.bytes=246 git.pack.trailer=06dd39b7545811625e04a7645a0a64c9a62c99c6Open pack map
fetchtree:0200174 B · hit3 ms
git.upload-pack fetch http.response.status_code=200 git.upstream.cf_ray=- git.upstream.phase=fetch git.upstream.dur_ms=226 git.response.bytes=174 git.response.cache=HIT git.response.duration_ms=3 git.fetch.filter=tree:0 git.fetch.wants=c923ad47aec29523ab261d078f56fb7bf05eff40 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=174 git.pkt.payload.max=147 git.sideband.band1.bytes=147 git.sideband.band2.bytes=0 git.sideband.band3.bytes=0 git.pack.objects=1 git.pack.bytes=147 git.pack.trailer=b1dcafdbc0347263de9030f8edc56e6165089115Open pack map
fetch2003.7 KiB227 ms
git.upload-pack fetch http.response.status_code=200 git.response.bytes=3824 git.response.cache=MISS git.response.duration_ms=227 git.fetch.wants=a3563a944f9bda7793c615179d9bdfc2241033a1 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=3824 git.pkt.payload.max=3797 git.sideband.band1.bytes=3797 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
- a5e2868be8b64af4
- Request
- e2a0410c…
- 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