GitLabgitlab-org

cli

main
ply9 git calls345 ms111 KiB7 cachedprotocol v2
1854 lines65 KiBRaw
1//go:build !integration
3package sync
5import (
6 "bytes"
7 "cmp"
8 "context"
9 "encoding/json"
10 "errors"
11 "fmt"
12 "io"
13 "net/http"
14 "net/http/httptest"
15 "net/url"
16 "os"
17 osexec "os/exec"
18 "path/filepath"
19 "runtime"
20 "slices"
21 "strings"
22 gosync "sync"
23 "testing"
24 "time"
26 "github.com/stretchr/testify/assert"
27 "github.com/stretchr/testify/require"
28 "go.uber.org/mock/gomock"
30 gitlab "gitlab.com/gitlab-org/api/client-go/v3"
31 gitlabtesting "gitlab.com/gitlab-org/api/client-go/v3/testing"
33 "gitlab.com/gitlab-org/cli/internal/api"
34 "gitlab.com/gitlab-org/cli/internal/cmdutils"
35 "gitlab.com/gitlab-org/cli/internal/commands/govern/internal/claudehooks"
36 "gitlab.com/gitlab-org/cli/internal/commands/govern/internal/fallbacksync"
37 "gitlab.com/gitlab-org/cli/internal/commands/govern/internal/opencodeplugin"
38 "gitlab.com/gitlab-org/cli/internal/commands/govern/internal/syncstate"
39 "gitlab.com/gitlab-org/cli/internal/config"
40 "gitlab.com/gitlab-org/cli/internal/glrepo"
41 "gitlab.com/gitlab-org/cli/internal/testing/cmdtest"
44const testHost = "gitlab.example.com"
46// fakeGitLab serves the project lookups and AI agent governance endpoints.
47// It is an HTTP server rather than a client-go mock because the governance
48// endpoints are raw requests that client-go has no service for.
49type fakeGitLab struct {
50 mu gosync.Mutex
51 projects map[string]int64
52 projectLookups map[string]int
53 sessionsCreated []string
54 sessionRequests []sessionRequest
55 agentTypes []string
56 syncTypes []string
57 identityRequests int
58 eventBatches []int
59 events []auditEventRequest
60 eventsPosted int
61 completed int
62 // noSessionID makes session creation succeed without returning an ID.
63 noSessionID bool
64 // identityStatus and sessionStatus, when set, answer those endpoints with
65 // that HTTP status. GitLab answers 404 while AI agent governance is off
66 // for the project.
67 identityStatus int
68 sessionStatus int
69 // projectStatus, when set, answers lookups of unknown projects with that
70 // HTTP status instead of 404.
71 projectStatus int
72 // identityBody, when set, is the body sent with identityStatus.
73 identityBody string
74 // maxElements, when set, replaces the 5,000 JSON elements GitLab accepts
75 // in an audit events request.
76 maxElements int
77 // auditStatus, when set, answers audit event requests with that status.
78 auditStatus int
79 // tooLargeToolCall, when set, makes any audit events request with an event
80 // for that tool call exceed GitLab's JSON limits.
81 tooLargeToolCall string
82 auditRequests int
83 // rateLimited is how many audit event requests GitLab answers with 429
84 // before it accepts them.
85 rateLimited int
86 // retryAfter is the Retry-After GitLab sends with a 429, "0" if unset.
87 retryAfter string
88 // auditRejections counts the audit event requests over GitLab's limits.
89 auditRejections int
90 // badGateway is how many 502s each write endpoint ("session", "audit",
91 // "complete") answers with before it accepts requests.
92 badGateway map[string]int
95// failWithBadGateway answers with a 502 if endpoint has one left to send.
96func (f *fakeGitLab) failWithBadGateway(w http.ResponseWriter, endpoint string) bool {
97 if f.badGateway[endpoint] == 0 {
98 return false
99 }
100 f.badGateway[endpoint]--
101 writeStatus(w, http.StatusBadGateway)
102 return true
105func (f *fakeGitLab) ServeHTTP(w http.ResponseWriter, r *http.Request) {
106 f.mu.Lock()
107 defer f.mu.Unlock()
109 w.Header().Set("Content-Type", "application/json")
110 path := r.URL.Path
111 project, isProjectLookup := strings.CutPrefix(r.URL.EscapedPath(), "/api/v4/projects/")
112 isProjectLookup = isProjectLookup && r.Method == http.MethodGet && !strings.Contains(project, "/")
113 switch {
114 case isProjectLookup:
115 name, _ := url.PathUnescape(project)
116 f.projectLookups[name]++
117 id, ok := f.projects[name]
118 if !ok && f.projectStatus != 0 {
119 writeStatus(w, f.projectStatus)
120 return
121 }
122 if !ok {
123 w.WriteHeader(http.StatusNotFound)
124 _, _ = io.WriteString(w, `{"message":"404 Project Not Found"}`)
125 return
126 }
127 _ = json.NewEncoder(w).Encode(map[string]any{"id": id, "path_with_namespace": name})
128 case r.Method == http.MethodPost && strings.HasSuffix(path, "/ai_agent/identities"):
129 f.identityRequests++
130 if f.identityStatus != 0 {
131 if f.identityBody != "" {
132 w.WriteHeader(f.identityStatus)
133 _, _ = io.WriteString(w, f.identityBody)
134 return
135 }
136 writeStatus(w, f.identityStatus)
137 return
138 }
139 _, _ = io.WriteString(w, `{"id": 7}`)
140 case r.Method == http.MethodPost && strings.HasSuffix(path, "/ai_agent/sessions"):
141 if f.failWithBadGateway(w, "session") {
142 return
143 }
144 if f.sessionStatus != 0 {
145 writeStatus(w, f.sessionStatus)
146 return
147 }
148 var body sessionRequest
149 _ = json.NewDecoder(r.Body).Decode(&body)
150 f.sessionsCreated = append(f.sessionsCreated, body.IdempotencyKey)
151 f.sessionRequests = append(f.sessionRequests, body)
152 f.agentTypes = append(f.agentTypes, body.AgentType)
153 f.syncTypes = append(f.syncTypes, body.SyncType)
154 if f.noSessionID {
155 _, _ = io.WriteString(w, `{}`)
156 return
157 }
158 _, _ = io.WriteString(w, `{"id": 99}`)
159 case r.Method == http.MethodPost && strings.HasSuffix(path, "/ai_agent/audit_events"):
160 f.auditRequests++
161 if f.failWithBadGateway(w, "audit") {
162 return
163 }
164 if f.auditRequests <= f.rateLimited {
165 // A Ratelimit-Reset in the past keeps the API client's own retries short.
166 w.Header().Set("Ratelimit-Reset", "1")
167 w.Header().Set("Retry-After", cmp.Or(f.retryAfter, "0"))
168 writeStatus(w, http.StatusTooManyRequests)
169 return
170 }
171 if f.auditStatus != 0 {
172 writeStatus(w, f.auditStatus)
173 return
174 }
175 raw, _ := io.ReadAll(r.Body)
176 var body auditEventsRequest
177 _ = json.Unmarshal(raw, &body)
178 if limit := f.exceededJSONLimit(raw, body); limit != "" {
179 f.auditRejections++
180 w.WriteHeader(http.StatusBadRequest)
181 _, _ = fmt.Fprintf(w, `{"error":%q}`, limit)
182 return
183 }
184 f.eventBatches = append(f.eventBatches, len(body.Events))
185 f.events = append(f.events, body.Events...)
186 f.eventsPosted += len(body.Events)
187 _, _ = io.WriteString(w, `{}`)
188 case r.Method == http.MethodPatch && strings.HasSuffix(path, "/ai_agent/sessions/99"):
189 if f.failWithBadGateway(w, "complete") {
190 return
191 }
192 f.completed++
193 _, _ = io.WriteString(w, `{}`)
194 default:
195 w.WriteHeader(http.StatusNotFound)
196 }
199// exceededJSONLimit returns the error GitLab's JSON validation answers an
200// audit events request with, or "" if the request is within its limits.
201func (f *fakeGitLab) exceededJSONLimit(raw []byte, body auditEventsRequest) string {
202 maxElements := f.maxElements
203 if maxElements == 0 {
204 maxElements = 5000
205 }
206 var v any
207 _ = json.Unmarshal(raw, &v)
208 switch {
209 case len(body.Events) > maxEventsPerRequest:
210 return "Array parameter too large"
211 case 1+jsonElements(v) >= maxElements:
212 return "Too many total parameters"
213 case f.tooLargeToolCall != "" && slices.ContainsFunc(body.Events, func(e auditEventRequest) bool {
214 return e.Details["tool_call_id"] == f.tooLargeToolCall
215 }):
216 return "Hash parameter too large"
217 }
218 return ""
221func toolIDs(n int) []string {
222 ids := make([]string, n)
223 for i := range ids {
224 ids[i] = fmt.Sprintf("toolu_%d", i)
225 }
226 return ids
229func eventNames(events []auditEventRequest) []string {
230 names := make([]string, 0, len(events))
231 for _, e := range events {
232 names = append(names, e.EventName)
233 }
234 return names
237func writeStatus(w http.ResponseWriter, code int) {
238 w.WriteHeader(code)
239 _, _ = fmt.Fprintf(w, `{"message":"%d %s"}`, code, http.StatusText(code))
242type syncAllEnv struct {
243 home string
244 fake *fakeGitLab
245 exec cmdtest.CmdExecFunc
246 mExec *cmdtest.MockExecutor
249func newSyncAllEnv(t *testing.T, hooksInstalled bool) *syncAllEnv {
250 t.Helper()
251 return newSyncAllEnvWithConfig(t, hooksInstalled, "hosts:\n "+testHost+":\n token: test-token\n")
254// newSyncAllEnvWithConfig is newSyncAllEnv with glab configuration cfg.
255func newSyncAllEnvWithConfig(t *testing.T, hooksInstalled bool, cfg string) *syncAllEnv {
256 t.Helper()
258 home := t.TempDir()
259 t.Setenv("HOME", home)
260 t.Setenv("GLAB_CONFIG_DIR", filepath.Join(home, "glab"))
261 t.Setenv("CLAUDE_CODE_SESSION_ID", "")
262 t.Setenv("OPENCODE_SESSION_ID", "")
263 t.Setenv(hookAgentEnv, "")
264 t.Setenv("XDG_CONFIG_HOME", "")
266 if hooksInstalled {
267 installOpenCodePlugin(t)
268 installClaudeStopHook(t)
269 }
271 fake := &fakeGitLab{projects: map[string]int64{"my-group/my-project": 42}, projectLookups: map[string]int{}}
272 server := httptest.NewServer(fake)
273 t.Cleanup(server.Close)
275 client, err := gitlab.NewClient("test-token", gitlab.WithBaseURL(server.URL+"/api/v4"), gitlab.WithOnlyIdempotentRetries())
276 require.NoError(t, err)
277 mExec := cmdtest.NewMockExecutor(gomock.NewController(t))
279 exec := cmdtest.SetupCmdForTest(
280 t,
281 NewCmd,
282 false,
283 cmdtest.WithApiClient(cmdtest.NewTestApiClient(t, nil, "test-token", testHost, api.WithGitLabClient(client))),
284 cmdtest.WithExecutor(mExec),
285 cmdtest.WithConfig(config.NewFromString(cfg)),
286 cmdtest.WithBuildInfo(api.BuildInfo{Version: "v1.2.3"}),
287 )
289 return &syncAllEnv{home: home, fake: fake, exec: exec, mExec: mExec}
292// writeClaudeSession writes a Claude Code transcript containing one tool call
293// per tool ID, and the metadata a hook records for it.
294func (e *syncAllEnv) writeClaudeSession(t *testing.T, sessionID, project string, toolIDs ...string) string {
295 t.Helper()
297 content := claudeTranscriptLines(t, sessionID, toolIDs...)
299 path := filepath.Join(e.home, ".claude", "projects", "-work-"+sessionID, sessionID+".jsonl")
300 require.NoError(t, os.MkdirAll(filepath.Dir(path), 0o755))
301 require.NoError(t, os.WriteFile(path, content, 0o644))
303 require.NoError(t, writeSessionMeta(sessionID, sessionMeta{
304 AgentType: "claude-code",
305 PathWithNamespace: project,
306 Host: testHost,
307 Transcript: path,
308 }))
309 return path
312func assertCursorAt(t *testing.T, sessionID string, want int64) {
313 t.Helper()
314 cursor, err := syncstate.ReadPosition(sessionID)
315 require.NoError(t, err)
316 assert.Equal(t, want, cursor)
319// recordWaits makes opts' waits return at once, and returns the waits asked for.
320func recordWaits(opts *options) *[]time.Duration {
321 var waits []time.Duration
322 opts.waitFor = func(_ context.Context, d time.Duration) error {
323 waits = append(waits, d)
324 return nil
325 }
326 return &waits
329func assertCursorAtEnd(t *testing.T, path string) {
330 t.Helper()
331 info, err := os.Stat(path)
332 require.NoError(t, err)
333 assertCursorAt(t, strings.TrimSuffix(filepath.Base(path), ".jsonl"), info.Size())
336func readStatus(t *testing.T) *fallbacksync.Status {
337 t.Helper()
338 status, err := fallbacksync.ReadStatus()
339 require.NoError(t, err)
340 return status
343func TestSyncAll_UploadsRecordedSession(t *testing.T) {
344 env := newSyncAllEnv(t, true)
345 path := env.writeClaudeSession(t, "sess-1", "my-group/my-project", "toolu_1", "toolu_2")
347 _, err := env.exec("--all")
348 require.NoError(t, err)
350 assert.Equal(t, []string{"sess-1"}, env.fake.sessionsCreated)
351 assert.Equal(t, []string{"fallback"}, env.fake.syncTypes)
352 assert.Equal(t, 2, env.fake.eventsPosted)
353 assert.Zero(t, env.fake.completed)
355 info, err := os.Stat(path)
356 require.NoError(t, err)
357 cursor, err := syncstate.ReadPosition("sess-1")
358 require.NoError(t, err)
359 assert.Equal(t, info.Size(), cursor)
361 status := readStatus(t)
362 assert.Equal(t, 1, status.SessionsSynced)
363 assert.Equal(t, 2, status.EventsPosted)
364 assert.Empty(t, status.Errors)
367func TestSyncAll_KeepsCursorWhenSessionHasNoID(t *testing.T) {
368 env := newSyncAllEnv(t, true)
369 env.fake.noSessionID = true
370 env.writeClaudeSession(t, "sess-1", "my-group/my-project", "toolu_1")
372 _, err := env.exec("--all")
373 require.NoError(t, err)
375 assert.Zero(t, env.fake.eventsPosted)
376 cursor, err := syncstate.ReadPosition("sess-1")
377 require.NoError(t, err)
378 assert.Zero(t, cursor, "unposted events must be retried on the next run")
380 status := readStatus(t)
381 require.Len(t, status.Errors, 1)
382 assert.Contains(t, status.Errors[0], "no session ID")
385func TestSyncAll_RecordsFailedIdentityRegistration(t *testing.T) {
386 env := newSyncAllEnv(t, true)
387 env.fake.identityStatus = http.StatusForbidden
388 env.writeClaudeSession(t, "sess-1", "my-group/my-project", "toolu_1")
390 _, err := env.exec("--all")
391 require.NoError(t, err)
393 assert.Empty(t, env.fake.sessionsCreated, "GitLab requires an agent identity to create a session")
394 cursor, err := syncstate.ReadPosition("sess-1")
395 require.NoError(t, err)
396 assert.Zero(t, cursor, "the session is retried on the next run")
397 status := readStatus(t)
398 assert.Zero(t, status.SessionsSynced)
399 require.Len(t, status.Errors, 1)
400 assert.Contains(t, status.Errors[0], "session sess-1: could not register agent identity")
403func TestSyncAll_RegistersIdentityOncePerProject(t *testing.T) {
404 env := newSyncAllEnv(t, true)
405 env.fake.identityStatus = http.StatusForbidden
406 for _, id := range []string{"sess-1", "sess-2", "sess-3"} {
407 env.writeClaudeSession(t, id, "my-group/my-project", "toolu_"+id)
408 }
410 _, err := env.exec("--all")
411 require.NoError(t, err)
413 assert.Equal(t, 1, env.fake.identityRequests, "a failed registration is not repeated for each session")
414 assert.Empty(t, env.fake.sessionsCreated)
415 assert.Len(t, readStatus(t).Errors, 1)
418func TestSyncAll_RecordsFailedProjectOnce(t *testing.T) {
419 env := newSyncAllEnv(t, true)
420 env.fake.projectStatus = http.StatusForbidden
421 env.writeClaudeSession(t, "sess-1", "gone/project", "toolu_1")
422 env.writeClaudeSession(t, "sess-2", "gone/project", "toolu_2")
424 _, err := env.exec("--all")
425 require.NoError(t, err)
427 assert.Equal(t, 1, env.fake.projectLookups["gone/project"])
428 status := readStatus(t)
429 require.Len(t, status.Errors, 1)
430 assert.Contains(t, status.Errors[0], "gone/project")
433func TestSyncAll_GovernanceNotEnabledIsNotAnError(t *testing.T) {
434 for _, tc := range []struct {
435 name string
436 identity int
437 session int
438 }{
439 {name: "identity registration", identity: http.StatusNotFound},
440 {name: "session creation", session: http.StatusNotFound},
441 } {
442 t.Run(tc.name, func(t *testing.T) {
443 env := newSyncAllEnv(t, true)
444 env.fake.identityStatus = tc.identity
445 env.fake.sessionStatus = tc.session
446 env.writeClaudeSession(t, "sess-1", "my-group/my-project", "toolu_1")
447 env.writeClaudeSession(t, "sess-2", "my-group/my-project", "toolu_2")
449 _, err := env.exec("--all")
450 require.NoError(t, err)
452 status := readStatus(t)
453 assert.Empty(t, status.Errors, "a project without governance is expected, not a failure")
454 assert.Equal(t, []string{testHost + "/my-group/my-project"}, status.GovernanceNotEnabled)
455 cursor, err := syncstate.ReadPosition("sess-1")
456 require.NoError(t, err)
457 assert.Zero(t, cursor, "the session syncs once governance is enabled")
458 })
459 }
462func TestSyncAll_ProjectNotFoundIsNotAnError(t *testing.T) {
463 env := newSyncAllEnv(t, true)
464 env.writeClaudeSession(t, "sess-1", "gone/project", "toolu_1")
465 env.writeClaudeSession(t, "sess-2", "gone/project", "toolu_2")
466 env.writeClaudeSession(t, "sess-good", "my-group/my-project", "toolu_3")
468 _, err := env.exec("--all")
469 require.NoError(t, err)
471 status := readStatus(t)
472 assert.Empty(t, status.Errors, "a project the user can't see is expected, not a failure")
473 assert.Equal(t, []string{testHost + "/gone/project"}, status.ProjectNotFound)
474 assert.Equal(t, []string{"sess-good"}, env.fake.sessionsCreated)
475 assert.Equal(t, 1, env.fake.projectLookups["gone/project"])
476 for _, id := range []string{"sess-1", "sess-2"} {
477 meta, err := readSessionMeta(id)
478 require.NoError(t, err)
479 assert.Nil(t, meta.CompletedAt, "a 404 can mean no token was found, so the session is kept")
480 }
482 env.fake.projects["gone/project"] = 7
483 _, err = env.exec("--all")
484 require.NoError(t, err)
485 assert.ElementsMatch(t, []string{"sess-good", "sess-1", "sess-2"}, env.fake.sessionsCreated, "the sessions sync once the project is visible")
486 assert.Empty(t, readStatus(t).ProjectNotFound)
489func TestSyncAll_RecordsHostsWithoutToken(t *testing.T) {
490 for _, name := range []string{"GITLAB_TOKEN", "GITLAB_ACCESS_TOKEN", "OAUTH_TOKEN", "JOB_TOKEN", "CI_JOB_TOKEN", "GLAB_ENABLE_CI_AUTOLOGIN"} {
491 t.Setenv(name, "")
492 }
493 env := newSyncAllEnvWithConfig(t, true, "hosts:\n "+testHost+":\n api_protocol: https\n")
494 env.writeClaudeSession(t, "sess-1", "my-group/my-project", "toolu_1")
495 env.writeClaudeSession(t, "sess-2", "gone/project", "toolu_2")
497 _, err := env.exec("--all")
498 require.NoError(t, err)
500 status := readStatus(t)
501 assert.Equal(t, []string{testHost + "/gone/project"}, status.ProjectNotFound, "the host is recorded because this lookup failed")
502 assert.Equal(t, []string{testHost}, status.NoToken, "each host is recorded once")
505func TestSyncAll_HostWithoutTokenThatSyncsIsNotRecorded(t *testing.T) {
506 for _, name := range []string{"GITLAB_TOKEN", "GITLAB_ACCESS_TOKEN", "OAUTH_TOKEN", "JOB_TOKEN", "CI_JOB_TOKEN", "GLAB_ENABLE_CI_AUTOLOGIN"} {
507 t.Setenv(name, "")
508 }
509 env := newSyncAllEnvWithConfig(t, true, "hosts:\n "+testHost+":\n api_protocol: https\n")
510 env.writeClaudeSession(t, "sess-1", "my-group/my-project", "toolu_1")
512 _, err := env.exec("--all")
513 require.NoError(t, err)
515 status := readStatus(t)
516 assert.Equal(t, 1, status.SessionsSynced)
517 assert.Empty(t, status.NoToken, "nothing failed, so the missing token did not matter")
520func TestSyncAll_HostWithTokenIsNotRecorded(t *testing.T) {
521 env := newSyncAllEnv(t, true)
522 env.writeClaudeSession(t, "sess-1", "my-group/my-project", "toolu_1")
524 _, err := env.exec("--all")
525 require.NoError(t, err)
527 assert.Empty(t, readStatus(t).NoToken)
530func TestSyncAll_HostWithJobTokenIsNotRecorded(t *testing.T) {
531 for _, name := range []string{"GITLAB_TOKEN", "GITLAB_ACCESS_TOKEN", "OAUTH_TOKEN", "JOB_TOKEN", "CI_JOB_TOKEN", "GLAB_ENABLE_CI_AUTOLOGIN"} {
532 t.Setenv(name, "")
533 }
534 env := newSyncAllEnvWithConfig(t, true, "hosts:\n "+testHost+":\n api_protocol: https\n job_token: job-token\n")
535 env.writeClaudeSession(t, "sess-1", "my-group/my-project", "toolu_1")
537 _, err := env.exec("--all")
538 require.NoError(t, err)
540 assert.Empty(t, readStatus(t).NoToken)
543func TestSyncAll_RejectedSessionErrorIsNotRepeated(t *testing.T) {
544 env := newSyncAllEnv(t, true)
545 env.fake.sessionStatus = http.StatusForbidden
546 env.writeClaudeSession(t, "sess-1", "my-group/my-project", "toolu_1")
548 _, err := env.exec("--all")
549 require.NoError(t, err)
551 status := readStatus(t)
552 require.Len(t, status.Errors, 1)
553 assert.Equal(t, 1, strings.Count(status.Errors[0], "could not create session"), status.Errors[0])
556func TestSyncAll_PostsLargeSessionsInBatches(t *testing.T) {
557 env := newSyncAllEnv(t, true)
558 path := env.writeClaudeSession(t, "sess-1", "my-group/my-project", toolIDs(1201)...)
560 _, err := env.exec("--all")
561 require.NoError(t, err)
563 assert.Zero(t, env.fake.auditRejections, "every batch is within GitLab's limits")
564 // Each of these events is 19 JSON elements, so 236 fit in maxElementsPerRequest.
565 assert.Equal(t, []int{236, 236, 236, 236, 236, 21}, env.fake.eventBatches)
566 assert.Equal(t, 1201, env.fake.eventsPosted)
567 assertCursorAtEnd(t, path)
570func TestSyncAll_SplitsBatchesOverGitLabLimits(t *testing.T) {
571 env := newSyncAllEnv(t, true)
572 env.fake.maxElements = 1000
573 path := env.writeClaudeSession(t, "sess-1", "my-group/my-project", toolIDs(300)...)
575 _, err := env.exec("--all")
576 require.NoError(t, err)
578 assert.NotZero(t, env.fake.auditRejections)
579 assert.Equal(t, 300, env.fake.eventsPosted)
580 assertCursorAtEnd(t, path)
583func TestSyncAll_SkipsEventTooLargeForGitLab(t *testing.T) {
584 env := newSyncAllEnv(t, true)
585 env.fake.tooLargeToolCall = "toolu_7"
586 path := env.writeClaudeSession(t, "sess-1", "my-group/my-project", toolIDs(20)...)
588 _, err := env.exec("--all")
589 require.NoError(t, err)
591 assert.Equal(t, 19, env.fake.eventsPosted)
592 status := readStatus(t)
593 assert.Equal(t, 19, status.EventsPosted)
594 assert.Equal(t, 1, status.EventsTooLarge)
595 assert.Empty(t, status.Errors)
596 assertCursorAtEnd(t, path)
599func TestSyncAll_KeepsEventsGitLabRejectsForAnotherReason(t *testing.T) {
600 env := newSyncAllEnv(t, true)
601 env.fake.auditStatus = http.StatusBadRequest
602 env.writeClaudeSession(t, "sess-1", "my-group/my-project", toolIDs(20)...)
604 _, err := env.exec("--all")
605 require.NoError(t, err)
607 assert.Equal(t, 1, env.fake.auditRequests, "the batch is not split")
608 status := readStatus(t)
609 assert.Zero(t, status.EventsTooLarge)
610 require.Len(t, status.Errors, 1)
611 assertCursorAt(t, "sess-1", 0)
614func TestSyncAll_WaitsOutRateLimit(t *testing.T) {
615 env := newSyncAllEnv(t, true)
616 // More than the API client retries on its own, with Retry-After: 0.
617 env.fake.rateLimited = 7
618 path := env.writeClaudeSession(t, "sess-1", "my-group/my-project", toolIDs(3)...)
620 _, err := env.exec("--all")
621 require.NoError(t, err)
623 assert.Equal(t, 8, env.fake.auditRequests)
624 assert.Equal(t, 3, env.fake.eventsPosted)
625 assert.Empty(t, readStatus(t).Errors)
626 assertCursorAtEnd(t, path)
629func TestSyncAll_RetriesWritesOnServerError(t *testing.T) {
630 env := newSyncAllEnv(t, true)
631 env.fake.badGateway = map[string]int{"session": 1, "audit": 1, "complete": 1}
632 path := env.writeClaudeSession(t, "sess-1", "my-group/my-project", "toolu_1")
633 idle := time.Now().Add(-idleCompleteAfter - time.Hour)
634 require.NoError(t, os.Chtimes(path, idle, idle))
636 _, err := env.exec("--all")
637 require.NoError(t, err)
639 assert.Empty(t, readStatus(t).Errors)
640 assert.Len(t, env.fake.sessionsCreated, 1)
641 assert.Equal(t, 1, env.fake.eventsPosted)
642 assert.Equal(t, 1, env.fake.completed)
645func TestSyncAll_FailedAuditEventsErrorIsNotRepeated(t *testing.T) {
646 env := newSyncAllEnv(t, true)
647 env.fake.auditStatus = http.StatusForbidden
648 env.writeClaudeSession(t, "sess-1", "my-group/my-project", "toolu_1")
650 _, err := env.exec("--all")
651 require.NoError(t, err)
653 status := readStatus(t)
654 require.Len(t, status.Errors, 1)
655 assert.Equal(t, 1, strings.Count(status.Errors[0], "could not post audit events"), status.Errors[0])
658func TestSyncAll_SkipsSessionsWithNothingNew(t *testing.T) {
659 env := newSyncAllEnv(t, true)
660 path := env.writeClaudeSession(t, "sess-1", "my-group/my-project", "toolu_1")
661 info, err := os.Stat(path)
662 require.NoError(t, err)
663 require.NoError(t, syncstate.WritePosition("sess-1", info.Size()))
665 _, err = env.exec("--all")
666 require.NoError(t, err)
668 assert.Empty(t, env.fake.projectLookups, "a session with nothing new must not reach the API")
669 assert.Empty(t, env.fake.sessionsCreated)
670 assert.Zero(t, readStatus(t).SessionsSynced)
673func TestSyncAll_LooksUpEachProjectOnce(t *testing.T) {
674 env := newSyncAllEnv(t, true)
675 env.writeClaudeSession(t, "sess-1", "my-group/my-project", "toolu_1")
676 env.writeClaudeSession(t, "sess-2", "my-group/my-project", "toolu_2")
678 _, err := env.exec("--all")
679 require.NoError(t, err)
681 assert.ElementsMatch(t, []string{"sess-1", "sess-2"}, env.fake.sessionsCreated)
682 assert.Equal(t, 1, env.fake.projectLookups["my-group/my-project"])
683 assert.Equal(t, 2, readStatus(t).SessionsSynced)
686func TestSyncAll_ContinuesPastFailedProjectLookup(t *testing.T) {
687 env := newSyncAllEnv(t, true)
688 env.fake.projectStatus = http.StatusForbidden
689 env.writeClaudeSession(t, "sess-bad", "gone/project", "toolu_1")
690 env.writeClaudeSession(t, "sess-good", "my-group/my-project", "toolu_2")
692 _, err := env.exec("--all")
693 require.NoError(t, err)
695 assert.Equal(t, []string{"sess-good"}, env.fake.sessionsCreated)
696 cursor, err := syncstate.ReadPosition("sess-bad")
697 require.NoError(t, err)
698 assert.Zero(t, cursor, "a failed session keeps its cursor so the next run retries it")
700 status := readStatus(t)
701 assert.Equal(t, 1, status.SessionsSynced)
702 require.Len(t, status.Errors, 1)
703 assert.Contains(t, status.Errors[0], "gone/project")
704 assert.Equal(t, 1, env.fake.projectLookups["gone/project"])
707func TestSyncAll_CompletesIdleSession(t *testing.T) {
708 env := newSyncAllEnv(t, true)
709 path := env.writeClaudeSession(t, "sess-1", "my-group/my-project", "toolu_1")
710 idle := time.Now().Add(-idleCompleteAfter - time.Hour)
711 require.NoError(t, os.Chtimes(path, idle, idle))
713 _, err := env.exec("--all")
714 require.NoError(t, err)
716 assert.Equal(t, 1, env.fake.completed)
717 meta, err := readSessionMeta("sess-1")
718 require.NoError(t, err)
719 assert.NotNil(t, meta.CompletedAt)
720 assert.Equal(t, 1, readStatus(t).SessionsCompleted)
722 // A completed session is not synced again.
723 _, err = env.exec("--all")
724 require.NoError(t, err)
725 assert.Equal(t, 1, env.fake.completed)
728func TestSyncAll_DoesNotCompleteActiveSession(t *testing.T) {
729 env := newSyncAllEnv(t, true)
730 env.writeClaudeSession(t, "sess-1", "my-group/my-project", "toolu_1")
732 _, err := env.exec("--all")
733 require.NoError(t, err)
735 assert.Zero(t, env.fake.completed)
736 meta, err := readSessionMeta("sess-1")
737 require.NoError(t, err)
738 assert.Nil(t, meta.CompletedAt)
741func TestSyncAll_ForgetsSessionWithDeletedTranscript(t *testing.T) {
742 env := newSyncAllEnv(t, true)
743 path := env.writeClaudeSession(t, "sess-1", "my-group/my-project", "toolu_1")
744 require.NoError(t, syncstate.WritePosition("sess-1", 10))
745 require.NoError(t, os.Remove(path))
747 _, err := env.exec("--all")
748 require.NoError(t, err)
750 assert.Empty(t, env.fake.projectLookups)
751 assert.Empty(t, readStatus(t).Errors, "a deleted transcript is not an error")
752 _, err = readSessionMeta("sess-1")
753 require.ErrorIs(t, err, errNoSessionMeta)
754 cp, err := syncstate.PositionPath("sess-1")
755 require.NoError(t, err)
756 assert.NoFileExists(t, cp)
759func TestSyncAll_RecordsUnreadableCursorsDir(t *testing.T) {
760 env := newSyncAllEnv(t, true)
761 gaigDir := filepath.Join(env.home, "glab", "gaig")
762 require.NoError(t, os.MkdirAll(gaigDir, 0o755))
763 require.NoError(t, os.WriteFile(filepath.Join(gaigDir, "cursors"), nil, 0o644))
765 _, err := env.exec("--all")
766 require.Error(t, err)
768 status := readStatus(t)
769 require.Len(t, status.Errors, 1)
770 assert.Contains(t, status.Errors[0], "could not read cursors directory")
773func TestSyncAll_FindsTranscriptAfterDirectoryChange(t *testing.T) {
774 env := newSyncAllEnv(t, true)
775 path := env.writeClaudeSession(t, "sess-1", "my-group/my-project", "toolu_1")
776 meta, err := readSessionMeta("sess-1")
777 require.NoError(t, err)
778 meta.Transcript = filepath.Join(env.home, ".claude", "projects", "-elsewhere", "sess-1.jsonl")
779 require.NoError(t, writeSessionMeta("sess-1", *meta))
781 _, err = env.exec("--all")
782 require.NoError(t, err)
784 assert.Equal(t, 1, env.fake.eventsPosted)
785 meta, err = readSessionMeta("sess-1")
786 require.NoError(t, err)
787 assert.Equal(t, path, meta.Transcript, "the found path is recorded so later runs don't search again")
790func TestSyncAll_ForgetsCompletedSessionOnceTranscriptDeleted(t *testing.T) {
791 env := newSyncAllEnv(t, true)
792 deleted := env.writeClaudeSession(t, "sess-deleted", "my-group/my-project", "toolu_1")
793 env.writeClaudeSession(t, "sess-kept", "my-group/my-project", "toolu_2")
794 require.NoError(t, markSessionCompleted("sess-deleted", time.Now()))
795 require.NoError(t, markSessionCompleted("sess-kept", time.Now()))
796 require.NoError(t, os.Remove(deleted))
798 _, err := env.exec("--all")
799 require.NoError(t, err)
801 _, err = readSessionMeta("sess-deleted")
802 require.ErrorIs(t, err, errNoSessionMeta)
803 _, err = readSessionMeta("sess-kept")
804 require.NoError(t, err, "a completed session can still be resumed while its transcript exists")
805 assert.Empty(t, env.fake.sessionsCreated, "completed sessions make no API calls")
806 assert.Empty(t, readStatus(t).Errors)
809func TestSyncAll_KeepsCompletedOpenCodeSession(t *testing.T) {
810 env := newSyncAllEnv(t, true)
811 require.NoError(t, writeSessionMeta("ses_1", sessionMeta{
812 AgentType: "opencode",
813 PathWithNamespace: "my-group/my-project",
814 Host: testHost,
815 Transcript: "/opencode/that/was/removed",
816 }))
817 require.NoError(t, markSessionCompleted("ses_1", time.Now()))
819 // The executor has no expectations, so running opencode export fails the test.
820 _, err := env.exec("--all")
821 require.NoError(t, err)
823 meta, err := readSessionMeta("ses_1")
824 require.NoError(t, err)
825 assert.Equal(t, "/opencode/that/was/removed", meta.Transcript)
828func installClaudeStopHook(t *testing.T) {
829 t.Helper()
830 hooks := map[string][]claudehooks.HookGroup{}
831 claudehooks.AddHook(hooks, "Stop", claudehooks.StopHookCommand)
832 hooksJSON, err := json.Marshal(hooks)
833 require.NoError(t, err)
834 settings, err := claudehooks.SettingsPath()
835 require.NoError(t, err)
836 require.NoError(t, claudehooks.WriteSettings(settings, map[string]json.RawMessage{"hooks": hooksJSON}))
839func installOpenCodePlugin(t *testing.T) {
840 t.Helper()
841 path, err := opencodeplugin.Path()
842 require.NoError(t, err)
843 _, err = opencodeplugin.Install(path)
844 require.NoError(t, err)
847func TestSyncAll_HooksRemovedPausesOnlyClaudeCode(t *testing.T) {
848 env := newSyncAllEnv(t, false)
849 installOpenCodePlugin(t)
850 env.writeClaudeSession(t, "sess-1", "my-group/my-project", "toolu_1")
851 env.writeOpenCodeSession(t, "ses_1", "call_1")
853 _, err := env.exec("--all")
854 require.NoError(t, err)
856 assert.Equal(t, []string{"ses_1"}, env.fake.sessionsCreated)
857 assert.Equal(t, []string{"claude-code: the glab Stop hook is not installed in ~/.claude/settings.json"}, readStatus(t).Paused)
860func TestSyncAll_PluginRemovedPausesOnlyOpenCode(t *testing.T) {
861 env := newSyncAllEnv(t, true)
862 path, err := opencodeplugin.Path()
863 require.NoError(t, err)
864 require.NoError(t, os.Remove(path))
865 env.writeClaudeSession(t, "sess-1", "my-group/my-project", "toolu_1")
866 require.NoError(t, writeSessionMeta("ses_1", sessionMeta{
867 AgentType: "opencode",
868 PathWithNamespace: "my-group/my-project",
869 Host: testHost,
870 Transcript: "/bin/sh",
871 }))
873 // The executor has no expectations, so running opencode export fails the test.
874 _, err = env.exec("--all")
875 require.NoError(t, err)
877 assert.Equal(t, []string{"sess-1"}, env.fake.sessionsCreated)
878 assert.Equal(t, []string{"opencode: the glab OpenCode plugin is not installed in ~/.config/opencode/plugins/glab-govern.js"}, readStatus(t).Paused)
881func TestOpenCodePausedReason(t *testing.T) {
882 t.Setenv("HOME", t.TempDir())
883 t.Setenv("XDG_CONFIG_HOME", "")
884 path, err := opencodeplugin.Path()
885 require.NoError(t, err)
886 require.NoError(t, os.MkdirAll(filepath.Dir(path), 0o755))
888 for name, content := range map[string]string{
889 "out of date": "// Installed by glab govern setup.\n// an older version\n",
890 "not installed by glab": "// the user's own plugin\n",
891 } {
892 require.NoError(t, os.WriteFile(path, []byte(content), 0o644))
893 reason, err := openCode{}.pausedReason()
894 require.NoError(t, err)
895 if name == "out of date" {
896 assert.Empty(t, reason, "an older plugin still syncs")
897 } else {
898 assert.Equal(t, "the glab OpenCode plugin is not installed in ~/.config/opencode/plugins/glab-govern.js", reason)
899 }
900 }
903func TestOpenCodePausedReason_Windows(t *testing.T) {
904 reason, err := openCodePausedReason("windows")
905 require.NoError(t, err)
906 assert.Equal(t, "the OpenCode plugin is not supported on Windows", reason)
909func TestSyncAll_UnsupportedAgent(t *testing.T) {
910 env := newSyncAllEnv(t, true)
911 require.NoError(t, writeSessionMeta("sess-1", sessionMeta{AgentType: "other-agent", PathWithNamespace: "my-group/my-project", Host: testHost}))
913 _, err := env.exec("--all")
914 require.NoError(t, err)
916 status := readStatus(t)
917 require.Len(t, status.Errors, 1)
918 assert.Contains(t, status.Errors[0], `unsupported agent "other-agent"`)
921func TestSyncAll_FlagConflicts(t *testing.T) {
922 env := newSyncAllEnv(t, true)
924 _, err := env.exec("--all -R my-group/my-project")
925 require.Error(t, err)
926 assert.Contains(t, err.Error(), "none of the others can be")
928 _, err = env.exec("--all --complete")
929 require.Error(t, err)
930 assert.Contains(t, err.Error(), "none of the others can be")
933// writeOpenCodeSession records an OpenCode session whose export contains one
934// tool call per call ID.
935func (e *syncAllEnv) writeOpenCodeSession(t *testing.T, sessionID string, callIDs ...string) {
936 t.Helper()
938 binary := filepath.Join(t.TempDir(), "opencode")
939 require.NoError(t, os.WriteFile(binary, nil, 0o755))
940 require.NoError(t, writeSessionMeta(sessionID, sessionMeta{
941 AgentType: "opencode",
942 PathWithNamespace: "my-group/my-project",
943 Host: testHost,
944 Transcript: binary,
945 }))
946 export := openCodeExportJSON(t, time.Now(), callIDs...)
947 e.mExec.EXPECT().
948 ExecWithIO(gomock.Any(), binary, []string{"session", "export", "--standalone", sessionID}, nil, nil, gomock.Any(), gomock.Any()).
949 DoAndReturn(func(_ context.Context, _ string, _, _ []string, _ io.Reader, stdout, _ io.Writer) error {
950 _, err := stdout.Write(export)
951 return err
952 })
955func TestSyncAll_UploadsOpenCodeSession(t *testing.T) {
956 env := newSyncAllEnv(t, true)
957 env.writeOpenCodeSession(t, "ses_1", "call_1", "call_2")
959 _, err := env.exec("--all")
960 require.NoError(t, err)
962 assert.Equal(t, []string{"ses_1"}, env.fake.sessionsCreated)
963 require.Len(t, env.fake.sessionRequests, 1)
964 assert.Equal(t, "1.19.4", env.fake.sessionRequests[0].AgentVersion)
965 assert.Equal(t, []string{eventToolInvoked, eventToolInvoked, eventToolResponse, eventToolResponse}, eventNames(env.fake.events),
966 "completed OpenCode tool calls also record their result")
967 cursor, err := syncstate.ReadPosition("ses_1")
968 require.NoError(t, err)
969 assert.Equal(t, int64(2), cursor)
972func TestRunSync_GovernanceNotEnabled(t *testing.T) {
973 env := newSyncAllEnv(t, true)
974 env.fake.identityStatus = http.StatusNotFound
975 t.Setenv("CLAUDE_CODE_SESSION_ID", "sess-1")
977 out, err := env.exec("-R my-group/my-project")
978 require.NoError(t, err)
980 assert.Contains(t, out.String(), governanceNotEnabled)
981 assert.Empty(t, out.Stderr(), "governance being off is not a failure")
984func TestRunSync_GovernanceNotEnabledSilent(t *testing.T) {
985 env := newSyncAllEnv(t, true)
986 env.fake.identityStatus = http.StatusNotFound
987 t.Setenv("CLAUDE_CODE_SESSION_ID", "sess-1")
988 writeHookTranscript(t, "sess-1", "toolu_1")
990 out, err := env.exec("-R my-group/my-project --silent")
991 require.NoError(t, err)
993 assert.Empty(t, out.String(), "hooks run with --silent")
994 assert.Empty(t, out.Stderr())
995 assert.Empty(t, env.fake.sessionsCreated, "no session is created without an identity")
998// writeHookTranscript writes a Claude Code transcript where a hook run from
999// the current directory looks for it.
1000func writeHookTranscript(t *testing.T, sessionID string, toolIDs ...string) {
1001 t.Helper()
1003 cwd, err := currentCWD()
1004 require.NoError(t, err)
1005 path, err := transcriptPath(sessionID, cwd)
1006 require.NoError(t, err)
1008 require.NoError(t, os.MkdirAll(filepath.Dir(path), 0o755))
1009 require.NoError(t, os.WriteFile(path, claudeTranscriptLines(t, sessionID, toolIDs...), 0o644))
1012// claudeTranscriptLines returns a Claude Code transcript with one Bash tool
1013// call for each ID.
1014func claudeTranscriptLines(t *testing.T, sessionID string, toolIDs ...string) []byte {
1015 t.Helper()
1017 var content []byte
1018 for _, id := range toolIDs {
1019 line, err := json.Marshal(map[string]any{
1020 "type": "assistant",
1021 "sessionId": sessionID,
1022 "timestamp": time.Now().Format(time.RFC3339),
1023 "version": "2.1.295",
1024 "message": map[string]any{
1025 "content": []map[string]any{{"type": "tool_use", "id": id, "name": "Bash"}},
1026 },
1027 })
1028 require.NoError(t, err)
1029 content = append(append(content, line...), '\n')
1031 return content
1034func TestRunSync_SendsGlabAndAgentVersions(t *testing.T) {
1035 env := newSyncAllEnv(t, true)
1036 t.Setenv("CLAUDE_CODE_SESSION_ID", "sess-1")
1037 writeHookTranscript(t, "sess-1", "toolu_1")
1039 _, err := env.exec("-R my-group/my-project --silent")
1040 require.NoError(t, err)
1042 require.Len(t, env.fake.sessionRequests, 1)
1043 assert.Equal(t, "1.2.3", env.fake.sessionRequests[0].GlabVersion, "sent as glab version prints it")
1044 assert.Equal(t, "2.1.295", env.fake.sessionRequests[0].AgentVersion)
1047func TestSessionVersion(t *testing.T) {
1048 t.Parallel()
1050 assert.Equal(t, "2.1.295", sessionVersion(" 2.1.295\n"))
1051 assert.Equal(t, strings.Repeat("é", maxVersionLength), sessionVersion(strings.Repeat("é", maxVersionLength)))
1052 assert.Empty(t, sessionVersion(strings.Repeat("1", maxVersionLength+1)), "GitLab would reject the session")
1053 assert.Empty(t, sessionVersion(" "))
1056func TestRunSync_IdentityErrorStillWarns(t *testing.T) {
1057 env := newSyncAllEnv(t, true)
1058 env.fake.identityStatus = http.StatusForbidden
1059 t.Setenv("CLAUDE_CODE_SESSION_ID", "sess-1")
1061 out, err := env.exec("-R my-group/my-project")
1062 require.NoError(t, err)
1064 assert.Contains(t, out.Stderr(), "warning: ")
1065 assert.NotContains(t, out.String(), governanceNotEnabled, "only a 404 means governance is off")
1068func TestRunSync_RecordsMetaBeforeProjectLookup(t *testing.T) {
1069 dir := t.TempDir()
1070 t.Setenv("HOME", dir)
1071 t.Setenv("GLAB_CONFIG_DIR", dir)
1072 t.Setenv("CLAUDE_CODE_SESSION_ID", "sess-meta")
1073 t.Setenv("OPENCODE_SESSION_ID", "")
1074 installClaudeStopHook(t)
1076 ctrl := gomock.NewController(t)
1077 tc := gitlabtesting.NewTestClientWithCtrl(ctrl, gitlab.WithBaseURL("https://"+testHost))
1078 tc.MockProjects.EXPECT().
1079 GetProject(gomock.Any(), gomock.Any(), gomock.Any()).
1080 Return(nil, nil, errors.New("project not found"))
1082 exec := cmdtest.SetupCmdForTest(
1083 t,
1084 NewCmd,
1085 false,
1086 cmdtest.WithApiClient(cmdtest.NewTestApiClient(t, nil, "test-token", testHost, api.WithGitLabClient(tc.Client))),
1089 _, err := exec("--silent -R my-group/my-project")
1090 require.Error(t, err)
1092 meta, err := readSessionMeta("sess-meta")
1093 require.NoError(t, err)
1094 assert.Equal(t, "claude-code", meta.AgentType)
1095 assert.Equal(t, "my-group/my-project", meta.PathWithNamespace)
1096 assert.Equal(t, "gitlab.com", meta.Host)
1097 assert.Equal(t, "sess-meta.jsonl", filepath.Base(meta.Transcript))
1100// writeUnfoundOpenCodeSession records an OpenCode session that opencode export
1101// reports as not found, last recorded by a hook at recorded.
1102func (e *syncAllEnv) writeUnfoundOpenCodeSession(t *testing.T, sessionID string, recorded time.Time) {
1103 t.Helper()
1105 require.NoError(t, writeSessionMeta(sessionID, sessionMeta{
1106 AgentType: "opencode",
1107 PathWithNamespace: "my-group/my-project",
1108 Host: testHost,
1109 Transcript: "/bin/sh",
1110 }))
1111 mp, err := metaPath(sessionID)
1112 require.NoError(t, err)
1113 require.NoError(t, os.Chtimes(mp, recorded, recorded))
1114 e.mExec.EXPECT().
1115 ExecWithIO(gomock.Any(), "/bin/sh", []string{"session", "export", "--standalone", sessionID}, nil, nil, gomock.Any(), gomock.Any()).
1116 DoAndReturn(func(_ context.Context, _ string, _, _ []string, _ io.Reader, _, stderr io.Writer) error {
1117 _, _ = io.WriteString(stderr, "Error: Session not found: "+sessionID)
1118 return errors.New("exit status 1")
1119 })
1122func TestSyncAll_KeepsRecentOpenCodeSessionNotFound(t *testing.T) {
1123 env := newSyncAllEnv(t, true)
1124 env.writeUnfoundOpenCodeSession(t, "ses_1", time.Now())
1126 _, err := env.exec("--all")
1127 require.NoError(t, err)
1129 _, err = readSessionMeta("ses_1")
1130 require.NoError(t, err, "a recently recorded session must not be forgotten")
1131 status := readStatus(t)
1132 require.Len(t, status.Errors, 1)
1133 assert.Contains(t, status.Errors[0], "the agent reports no such session")
1136func TestSyncAll_ForgetsLongUnfoundOpenCodeSession(t *testing.T) {
1137 env := newSyncAllEnv(t, true)
1138 env.writeUnfoundOpenCodeSession(t, "ses_1", time.Now().Add(-forgetUnfoundAfter-time.Hour))
1140 _, err := env.exec("--all")
1141 require.NoError(t, err)
1143 _, err = readSessionMeta("ses_1")
1144 require.ErrorIs(t, err, errNoSessionMeta)
1145 assert.Empty(t, readStatus(t).Errors)
1148func TestSyncAll_ForgetsLongCompletedOpenCodeSession(t *testing.T) {
1149 env := newSyncAllEnv(t, true)
1150 require.NoError(t, writeSessionMeta("ses_old", sessionMeta{
1151 AgentType: "opencode",
1152 PathWithNamespace: "my-group/my-project",
1153 Host: testHost,
1154 Transcript: "/opencode/that/was/removed",
1155 }))
1156 require.NoError(t, markSessionCompleted("ses_old", time.Now().Add(-forgetUnfoundAfter-time.Hour)))
1158 // The executor has no expectations: forgetting must not run opencode export.
1159 _, err := env.exec("--all")
1160 require.NoError(t, err)
1162 _, err = readSessionMeta("ses_old")
1163 require.ErrorIs(t, err, errNoSessionMeta)
1164 cp, err := syncstate.PositionPath("ses_old")
1165 require.NoError(t, err)
1166 assert.NoFileExists(t, cp)
1169func TestOpenCode_RecordedFallsBackToPATH(t *testing.T) {
1170 t.Parallel()
1172 binary := func(t *testing.T, recorded string) string {
1173 t.Helper()
1174 src, _, err := openCode{}.recorded("ses_1", recorded)
1175 require.NoError(t, err)
1176 oc, ok := src.(*openCodeTranscript)
1177 require.True(t, ok)
1178 return oc.binary
1181 assert.Empty(t, binary(t, "/opencode/that/was/removed"), "a missing recorded binary is looked up in PATH instead")
1182 assert.Equal(t, "/bin/sh", binary(t, "/bin/sh"))
1185func TestOpenCodeTranscript_LastActivityWithoutUpdated(t *testing.T) {
1186 t.Parallel()
1188 newTranscript := func(export string) *openCodeTranscript {
1189 src := &openCodeTranscript{sessionID: "ses_1"}
1190 src.raw = []byte(export)
1191 src.export = &openCodeExport{}
1192 require.NoError(t, json.Unmarshal(src.raw, src.export))
1193 return src
1196 t.Run("falls back to the latest message", func(t *testing.T) {
1197 t.Parallel()
1198 src := newTranscript(`{"info":{"time":{"created":1000}},"messages":[{"info":{"role":"user","time":{"created":5000}},"parts":[]}]}`)
1199 last, err := src.lastActivity(t.Context())
1200 require.NoError(t, err)
1201 assert.Equal(t, time.UnixMilli(5000), last)
1202 })
1204 t.Run("treats a session without timestamps as active", func(t *testing.T) {
1205 t.Parallel()
1206 src := newTranscript(`{"info":{},"messages":[]}`)
1207 last, err := src.lastActivity(t.Context())
1208 require.NoError(t, err)
1209 assert.Less(t, time.Since(last), idleCompleteAfter)
1210 })
1213func TestRunSync_RecordsOpenCodeMeta(t *testing.T) {
1214 dir := t.TempDir()
1215 t.Setenv("HOME", dir)
1216 t.Setenv("GLAB_CONFIG_DIR", dir)
1217 t.Setenv("CLAUDE_CODE_SESSION_ID", "")
1218 t.Setenv("OPENCODE_SESSION_ID", "ses_meta")
1219 installOpenCodePlugin(t)
1221 ctrl := gomock.NewController(t)
1222 tc := gitlabtesting.NewTestClientWithCtrl(ctrl, gitlab.WithBaseURL("https://"+testHost))
1223 tc.MockProjects.EXPECT().
1224 GetProject(gomock.Any(), gomock.Any(), gomock.Any()).
1225 Return(nil, nil, errors.New("project not found"))
1226 mExec := cmdtest.NewMockExecutor(ctrl)
1227 mExec.EXPECT().LookPath("opencode").Return("/home/me/.opencode/bin/opencode", nil)
1229 exec := cmdtest.SetupCmdForTest(
1230 t,
1231 NewCmd,
1232 false,
1233 cmdtest.WithApiClient(cmdtest.NewTestApiClient(t, nil, "test-token", testHost, api.WithGitLabClient(tc.Client))),
1234 cmdtest.WithExecutor(mExec),
1237 _, err := exec("--silent -R my-group/my-project")
1238 require.Error(t, err)
1240 meta, err := readSessionMeta("ses_meta")
1241 require.NoError(t, err)
1242 assert.Equal(t, "opencode", meta.AgentType)
1243 assert.Equal(t, "/home/me/.opencode/bin/opencode", meta.Transcript)
1246func openCodeExportJSON(t *testing.T, updated time.Time, callIDs ...string) []byte {
1247 t.Helper()
1249 parts := []map[string]any{}
1250 for _, id := range callIDs {
1251 parts = append(parts, map[string]any{
1252 "id": "prt_" + id,
1253 "type": "tool",
1254 "callID": id,
1255 "tool": "bash",
1256 "state": map[string]any{"status": "completed", "time": map[string]any{"start": updated.UnixMilli()}},
1257 })
1259 data, err := json.Marshal(map[string]any{
1260 "info": map[string]any{
1261 "id": "ses_1",
1262 "version": "1.19.4",
1263 "time": map[string]any{"created": updated.Add(-time.Hour).UnixMilli(), "updated": updated.UnixMilli()},
1264 },
1265 "messages": []map[string]any{
1267 "info": map[string]any{"role": "user", "time": map[string]any{"created": updated.Add(-time.Hour).UnixMilli()}},
1268 "parts": []map[string]any{{"id": "prt_goal", "type": "text", "text": "fix the flaky test"}},
1269 },
1271 "info": map[string]any{"role": "assistant", "time": map[string]any{"created": updated.UnixMilli()}},
1272 "parts": parts,
1273 },
1274 },
1275 })
1276 require.NoError(t, err)
1277 return data
1280func TestOpenCodeTranscript_Read(t *testing.T) {
1281 t.Parallel()
1283 updated := time.UnixMilli(time.Now().UnixMilli())
1284 export := openCodeExportJSON(t, updated, "call_1", "call_2", "call_3")
1286 ctrl := gomock.NewController(t)
1287 mExec := cmdtest.NewMockExecutor(ctrl)
1288 mExec.EXPECT().LookPath("opencode").Return("/usr/local/bin/opencode", nil)
1289 // OpenCode 1 has no session export, so it prints its help and fails.
1290 mExec.EXPECT().
1291 ExecWithIO(gomock.Any(), "/usr/local/bin/opencode", []string{"session", "export", "--standalone", "ses_1"}, nil, nil, gomock.Any(), gomock.Any()).
1292 DoAndReturn(func(_ context.Context, _ string, _, _ []string, _ io.Reader, _, stderr io.Writer) error {
1293 _, _ = io.WriteString(stderr, "opencode session\n\nmanage sessions\n")
1294 return errors.New("exit status 1")
1295 }).
1296 Times(1)
1297 mExec.EXPECT().
1298 ExecWithIO(gomock.Any(), "/usr/local/bin/opencode", []string{"export", "ses_1"}, nil, nil, gomock.Any(), gomock.Any()).
1299 DoAndReturn(func(_ context.Context, _ string, _, _ []string, _ io.Reader, stdout, stderr io.Writer) error {
1300 _, _ = io.WriteString(stderr, "Exporting session: ses_1\n")
1301 _, err := stdout.Write(export)
1302 return err
1303 }).
1304 Times(1)
1306 src := &openCodeTranscript{sessionID: "ses_1", executor: mExec}
1308 data, cursor, err := src.read(t.Context(), 0)
1309 require.NoError(t, err)
1310 assert.Equal(t, "fix the flaky test", data.Goal)
1311 require.Len(t, data.ToolCalls, 3)
1312 assert.Equal(t, "call_1", data.ToolCalls[0].ID)
1313 assert.Equal(t, "bash", data.ToolCalls[0].Name)
1314 assert.Equal(t, updated, data.ToolCalls[0].Timestamp)
1315 assert.Equal(t, int64(3), cursor)
1317 data, cursor, err = src.read(t.Context(), 2)
1318 require.NoError(t, err)
1319 assert.Empty(t, data.Goal)
1320 require.Len(t, data.ToolCalls, 1)
1321 assert.Equal(t, "call_3", data.ToolCalls[0].ID)
1322 assert.Equal(t, int64(3), cursor)
1324 last, err := src.lastActivity(t.Context())
1325 require.NoError(t, err)
1326 assert.Equal(t, updated, last)
1328 sum, err := src.checksum(t.Context())
1329 require.NoError(t, err)
1330 assert.Len(t, sum, 64)
1333func TestOpenCodeTranscript_ExportFails(t *testing.T) {
1334 t.Parallel()
1336 export := func(t *testing.T, stderrText string, attempts int) error {
1337 t.Helper()
1338 mExec := cmdtest.NewMockExecutor(gomock.NewController(t))
1339 mExec.EXPECT().
1340 ExecWithIO(gomock.Any(), "/bin/opencode", gomock.Any(), nil, nil, gomock.Any(), gomock.Any()).
1341 DoAndReturn(func(_ context.Context, _ string, _, _ []string, _ io.Reader, _, stderr io.Writer) error {
1342 _, _ = io.WriteString(stderr, stderrText)
1343 return errors.New("exit status 1")
1344 }).
1345 Times(attempts)
1347 src := &openCodeTranscript{sessionID: "ses_1", binary: "/bin/opencode", executor: mExec}
1348 _, cursor, err := src.read(t.Context(), 5)
1349 assert.Equal(t, int64(5), cursor)
1350 return err
1353 t.Run("session not found", func(t *testing.T) {
1354 t.Parallel()
1355 err := export(t, "Error: Session not found: ses_1", 1)
1356 require.ErrorIs(t, err, errAgentSessionNotFound)
1357 require.NotErrorIs(t, err, errTranscriptNotFound, "the job may see a different OpenCode data directory, so this is not proof of deletion")
1358 })
1360 t.Run("other failure", func(t *testing.T) {
1361 t.Parallel()
1362 err := export(t, "Error: database is locked", len(openCodeExportCommands))
1363 require.Error(t, err)
1364 require.NotErrorIs(t, err, errTranscriptNotFound, "only a deleted session may make --all forget it")
1365 assert.Contains(t, err.Error(), "database is locked")
1366 })
1369func TestClaudeTranscript_Missing(t *testing.T) {
1370 t.Parallel()
1372 src := claudeTranscript{path: filepath.Join(t.TempDir(), "missing.jsonl")}
1373 _, _, err := src.read(t.Context(), 0)
1374 require.ErrorIs(t, err, errTranscriptNotFound)
1377func TestGoalFromText(t *testing.T) {
1378 t.Parallel()
1380 assert.Equal(t, "fix the bug", goalFromText("fix the bug"))
1381 assert.Empty(t, goalFromText("<bash-input>ls</bash-input>"))
1382 assert.Equal(t, strings.Repeat("a", 256)+"...", goalFromText(strings.Repeat("a", 300)))
1383 assert.Empty(t, goalFromText(string(bytes.Repeat([]byte(" "), 2))+"<tag>"))
1386// processExecutor runs commands the same way as the production executor in
1387// internal/cmdutils, so tests can observe real process and pipe behavior.
1388type processExecutor struct {
1389 cmdutils.Executor
1392func (processExecutor) ExecWithIO(ctx context.Context, name string, args []string, env []string, stdin io.Reader, stdout, stderr io.Writer) error {
1393 cmd := osexec.CommandContext(ctx, name, args...)
1394 cmd.Env = env
1395 cmd.Stdin = stdin
1396 cmd.Stdout = stdout
1397 cmd.Stderr = stderr
1398 return cmd.Run()
1401// fakeOpenCode writes a shell script that stands in for opencode.
1402func fakeOpenCode(t *testing.T, script string) string {
1403 t.Helper()
1404 if runtime.GOOS == "windows" {
1405 t.Skip("needs a POSIX shell")
1407 path := filepath.Join(t.TempDir(), "opencode")
1408 require.NoError(t, os.WriteFile(path, []byte("#!/bin/sh\n"+script+"\n"), 0o755))
1409 return path
1412// openCodeV2ExportJSON returns an OpenCode 2 session export, shaped like a
1413// real one: a skipped first prompt, a completed shell call, a failed read, a
1414// call aborted before it ran, a call still streaming, and a block glab does not
1415// know.
1416func openCodeV2ExportJSON(t *testing.T, created time.Time) []byte {
1417 t.Helper()
1419 ms := func(d time.Duration) int64 { return created.Add(d).UnixMilli() }
1420 data, err := json.Marshal(map[string]any{
1421 "info": map[string]any{
1422 "id": "ses_2",
1423 "version": "2.0.0",
1424 "location": map[string]any{"directory": "/home/me/project"},
1425 "time": map[string]any{"created": ms(0), "updated": ms(10 * time.Second), "idle": ms(10 * time.Second)},
1426 },
1427 "messages": []map[string]any{
1428 {"id": "msg_0", "type": "user", "time": map[string]any{"created": ms(0)}, "text": "<command>/init</command>"},
1429 {"id": "msg_1", "type": "user", "time": map[string]any{"created": ms(0)}, "text": "explain each file", "files": []any{}, "agents": []any{}},
1431 "id": "msg_2", "type": "assistant", "time": map[string]any{"created": ms(time.Second), "completed": ms(5 * time.Second)},
1432 "content": []map[string]any{
1433 {"type": "text", "text": "I'll look at the files."},
1435 "type": "tool", "id": "call_ls", "name": "shell",
1436 "state": map[string]any{"status": "completed", "input": map[string]any{"command": "ls -la"}, "content": []any{map[string]any{"type": "text"}}},
1437 "time": map[string]any{"created": ms(2 * time.Second), "ran": ms(2*time.Second + 100*time.Millisecond), "completed": ms(2*time.Second + 300*time.Millisecond)},
1438 },
1440 "type": "tool", "id": "call_read", "name": "read",
1441 "state": map[string]any{"status": "error", "input": map[string]any{"path": "missing.md"}, "error": map[string]any{"type": "unknown", "message": "File not found"}},
1442 "time": map[string]any{"created": ms(3 * time.Second), "ran": ms(3 * time.Second), "completed": ms(3*time.Second + 50*time.Millisecond)},
1443 },
1444 {"type": "future-block", "content": "a shape glab does not know"},
1446 "type": "tool", "id": "call_edit", "name": "edit",
1447 "state": map[string]any{"status": "error", "input": map[string]any{}, "error": map[string]any{"type": "aborted"}},
1448 "time": map[string]any{"created": ms(4 * time.Second)},
1449 },
1451 "type": "tool", "id": "call_write", "name": "write",
1452 "state": map[string]any{"status": "streaming", "input": `{"path": "no`},
1453 "time": map[string]any{"created": ms(5 * time.Second)},
1454 },
1455 },
1456 },
1457 {"id": "msg_4", "type": "idle", "time": map[string]any{"created": ms(9 * time.Second)}},
1458 {"id": "msg_3", "type": "outcome", "outcome": map[string]any{"type": "completed"}, "time": map[string]any{"created": ms(10 * time.Second)}},
1459 },
1460 })
1461 require.NoError(t, err)
1462 return data
1465func TestOpenCodeTranscript_ReadOpenCode2(t *testing.T) {
1466 t.Parallel()
1468 created := time.UnixMilli(time.Now().Add(-time.Hour).UnixMilli())
1469 export := openCodeV2ExportJSON(t, created)
1470 mExec := cmdtest.NewMockExecutor(gomock.NewController(t))
1471 mExec.EXPECT().
1472 ExecWithIO(gomock.Any(), "/opt/opencode", []string{"session", "export", "--standalone", "ses_2"}, nil, nil, gomock.Any(), gomock.Any()).
1473 DoAndReturn(func(_ context.Context, _ string, _, _ []string, _ io.Reader, stdout, _ io.Writer) error {
1474 _, err := stdout.Write(export)
1475 return err
1476 }).
1477 Times(1)
1478 src := &openCodeTranscript{sessionID: "ses_2", binary: "/opt/opencode", executor: mExec}
1480 data, cursor, err := src.read(t.Context(), 0)
1481 require.NoError(t, err)
1482 assert.Equal(t, "explain each file", data.Goal, "a command prompt is not the goal")
1483 assert.Equal(t, created, data.StartedAt)
1484 assert.Equal(t, "2.0.0", data.AgentVersion)
1485 assert.Equal(t, int64(4), cursor)
1487 require.Len(t, data.ToolCalls, 4)
1488 assert.Equal(t, "call_ls", data.ToolCalls[0].ID)
1489 assert.Equal(t, "shell", data.ToolCalls[0].Name)
1490 assert.JSONEq(t, `{"command":"ls -la"}`, string(data.ToolCalls[0].Input))
1491 assert.Equal(t, created.Add(2*time.Second+100*time.Millisecond), data.ToolCalls[0].Timestamp, "a call starts when it ran")
1492 assert.Equal(t, created.Add(3*time.Second), data.ToolCalls[1].Timestamp)
1493 assert.Equal(t, created.Add(4*time.Second), data.ToolCalls[2].Timestamp, "a call that never ran starts when it was created")
1494 assert.Equal(t, "call_write", data.ToolCalls[3].ID)
1495 assert.Nil(t, data.ToolCalls[3].Input, "a streaming call's partial input is not recorded")
1497 require.Len(t, data.ToolResults, 3, "a streaming call has no result yet")
1498 assert.False(t, data.ToolResults[0].IsError)
1499 assert.Equal(t, 200*time.Millisecond, data.ToolResults[0].Duration)
1500 assert.True(t, data.ToolResults[1].IsError)
1501 assert.Equal(t, "File not found", data.ToolResults[1].Error)
1502 assert.Equal(t, 50*time.Millisecond, data.ToolResults[1].Duration)
1503 assert.Equal(t, "aborted", data.ToolResults[2].Error, "an error without a message reports its type")
1505 data, cursor, err = src.read(t.Context(), 1)
1506 require.NoError(t, err)
1507 assert.Empty(t, data.Goal)
1508 require.Len(t, data.ToolCalls, 3)
1509 assert.Equal(t, "call_read", data.ToolCalls[0].ID)
1510 assert.Equal(t, int64(4), cursor)
1512 last, err := src.lastActivity(t.Context())
1513 require.NoError(t, err)
1514 assert.Equal(t, created.Add(10*time.Second), last)
1517func TestOpenCodeTranscript_SessionNotFoundStopsFallback(t *testing.T) {
1518 t.Parallel()
1520 mExec := cmdtest.NewMockExecutor(gomock.NewController(t))
1521 mExec.EXPECT().
1522 ExecWithIO(gomock.Any(), "/opt/opencode", []string{"session", "export", "--standalone", "ses_gone"}, nil, nil, gomock.Any(), gomock.Any()).
1523 DoAndReturn(func(_ context.Context, _ string, _, _ []string, _ io.Reader, _, stderr io.Writer) error {
1524 _, _ = io.WriteString(stderr, "Session not found: ses_gone\n")
1525 return errors.New("exit status 1")
1526 }).
1527 Times(1)
1528 src := &openCodeTranscript{sessionID: "ses_gone", binary: "/opt/opencode", executor: mExec}
1530 _, _, err := src.read(t.Context(), 0)
1531 require.ErrorIs(t, err, errAgentSessionNotFound)
1534func TestOpenCodeTranscript_ReportsBothExportFailures(t *testing.T) {
1535 t.Parallel()
1537 mExec := cmdtest.NewMockExecutor(gomock.NewController(t))
1538 mExec.EXPECT().
1539 ExecWithIO(gomock.Any(), "/opt/opencode", gomock.Any(), nil, nil, gomock.Any(), gomock.Any()).
1540 DoAndReturn(func(_ context.Context, _ string, args []string, _ []string, _ io.Reader, _, stderr io.Writer) error {
1541 _, _ = io.WriteString(stderr, "broken "+args[0])
1542 return errors.New("exit status 2")
1543 }).
1544 Times(2)
1545 src := &openCodeTranscript{sessionID: "ses_1", binary: "/opt/opencode", executor: mExec}
1547 _, _, err := src.read(t.Context(), 0)
1548 require.Error(t, err)
1549 assert.Contains(t, err.Error(), "opencode session export --standalone ses_1: exit status 2: broken session")
1550 assert.Contains(t, err.Error(), "opencode export ses_1: exit status 2: broken export")
1553func TestOpenCodeTranscript_ChildKeepingOutputOpen(t *testing.T) {
1554 t.Parallel()
1556 // The background sleep inherits stdout and outlives opencode. Reading
1557 // stdout through a pipe would block until the sleep exits.
1558 binary := fakeOpenCode(t, `sleep 30 &
1559printf '%s' '{"info":{"time":{"created":1000,"updated":2000}},"messages":[]}'`)
1560 src := &openCodeTranscript{sessionID: "ses_1", binary: binary, executor: processExecutor{}}
1562 start := time.Now()
1563 last, err := src.lastActivity(t.Context())
1564 require.NoError(t, err)
1565 assert.Equal(t, time.UnixMilli(2000), last)
1566 // Generous because process startup takes seconds under full-suite load on macOS.
1567 assert.Less(t, time.Since(start), 15*time.Second, "export must not wait for opencode's child process")
1570func TestOpenCodeTranscript_ExportTimesOut(t *testing.T) {
1571 t.Parallel()
1573 binary := fakeOpenCode(t, `sleep 20 &
1574sleep 20`)
1575 src := &openCodeTranscript{sessionID: "ses_1", binary: binary, executor: processExecutor{}, timeout: 300 * time.Millisecond}
1577 start := time.Now()
1578 _, _, err := src.read(t.Context(), 0)
1579 require.Error(t, err)
1580 assert.Contains(t, err.Error(), "timed out after 300ms")
1581 assert.Less(t, time.Since(start), 5*time.Second, "a hung export must not block the run")
1584func TestOpenCodeTranscript_TimeoutStopsFallback(t *testing.T) {
1585 t.Parallel()
1587 mExec := cmdtest.NewMockExecutor(gomock.NewController(t))
1588 mExec.EXPECT().
1589 ExecWithIO(gomock.Any(), "/opt/opencode", gomock.Any(), nil, nil, gomock.Any(), gomock.Any()).
1590 DoAndReturn(func(ctx context.Context, _ string, _, _ []string, _ io.Reader, _, _ io.Writer) error {
1591 <-ctx.Done()
1592 return ctx.Err()
1593 }).
1594 Times(1)
1595 src := &openCodeTranscript{sessionID: "ses_1", binary: "/opt/opencode", executor: mExec, timeout: 50 * time.Millisecond}
1597 _, _, err := src.read(t.Context(), 0)
1598 require.ErrorIs(t, err, errOpenCodeExportTimedOut)
1601// A hook must finish quickly, so unlike a sync run directly it does not wait
1602// out GitLab's rate limit.
1603func TestSyncSession_ByCaller(t *testing.T) {
1604 tests := []struct {
1605 name string
1606 silent bool
1607 want string
1608 wantPosted int
1609 }{
1610 {name: "hook", silent: true, want: "hook", wantPosted: 0},
1611 {name: "run directly", silent: false, want: "manual", wantPosted: 1},
1613 for _, tt := range tests {
1614 t.Run(tt.name, func(t *testing.T) {
1615 dir := t.TempDir()
1616 t.Setenv("HOME", dir)
1617 t.Setenv("GLAB_CONFIG_DIR", dir)
1619 fake := &fakeGitLab{projects: map[string]int64{}, projectLookups: map[string]int{}, rateLimited: 7}
1620 server := httptest.NewServer(fake)
1621 t.Cleanup(server.Close)
1622 gl, err := gitlab.NewClient("test-token", gitlab.WithBaseURL(server.URL+"/api/v4"))
1623 require.NoError(t, err)
1624 client := cmdtest.NewTestApiClient(t, nil, "test-token", testHost, api.WithGitLabClient(gl))
1626 line, err := json.Marshal(map[string]any{
1627 "type": "assistant",
1628 "sessionId": "sess-1",
1629 "timestamp": time.Now().Format(time.RFC3339),
1630 "message": map[string]any{
1631 "content": []map[string]any{{"type": "tool_use", "id": "toolu_1", "name": "Bash"}},
1632 },
1633 })
1634 require.NoError(t, err)
1635 path := filepath.Join(dir, "sess-1.jsonl")
1636 require.NoError(t, os.WriteFile(path, append(line, '\n'), 0o644))
1638 ios, _, _, _ := cmdtest.TestIOStreams()
1639 opts := &options{io: ios, silent: tt.silent, agentType: "claude-code"}
1640 recordWaits(opts)
1641 dest := target{client: client, project: &gitlab.Project{ID: 42}}
1642 require.NoError(t, syncSession(t.Context(), dest, "sess-1", claudeTranscript{path: path}, opts))
1644 assert.Equal(t, []string{tt.want}, fake.syncTypes)
1645 assert.Equal(t, tt.wantPosted, fake.eventsPosted)
1646 })
1650func TestAuditEventPoster_RateLimit(t *testing.T) {
1651 tests := []struct {
1652 name string
1653 opts options
1654 limited int
1655 retryAfter string
1656 wantErr bool
1657 wantWaits int
1658 }{
1659 {name: "waits", opts: options{all: true}, limited: 2, wantWaits: 2},
1660 {name: "gives up after the most waits", opts: options{all: true}, limited: 100, wantErr: true, wantWaits: maxRateLimitWaits},
1662 name: "gives up when the run has waited enough",
1663 opts: options{all: true, rateLimitWaited: maxRateLimitWaitPerRun - time.Second},
1664 limited: 1, retryAfter: "60", wantErr: true,
1665 },
1666 {name: "hook does not wait", opts: options{silent: true}, limited: 1, wantErr: true},
1668 for _, tt := range tests {
1669 t.Run(tt.name, func(t *testing.T) {
1670 waits := recordWaits(&tt.opts)
1671 fake := &fakeGitLab{rateLimited: tt.limited, retryAfter: tt.retryAfter}
1672 poster := newTestPoster(t, fake, &tt.opts)
1673 _, err := poster.post(t.Context(), []auditEventRequest{{EventName: eventToolInvoked}})
1675 if tt.wantErr {
1676 assert.Equal(t, http.StatusTooManyRequests, gitlab.StatusCode(err))
1677 } else {
1678 require.NoError(t, err)
1680 assert.Len(t, *waits, tt.wantWaits)
1681 })
1685func TestAuditEventPoster_SplitsOnlyOutsideHooks(t *testing.T) {
1686 tests := []struct {
1687 name string
1688 opts options
1689 fallbackInstalled bool
1690 wantErr bool
1691 wantRequests int
1692 }{
1693 {name: "fallback sync splits", opts: options{all: true}, fallbackInstalled: true, wantRequests: 3},
1694 {name: "manual sync splits", fallbackInstalled: true, wantRequests: 3},
1695 {name: "hook leaves the batch for the fallback sync", opts: options{silent: true}, fallbackInstalled: true, wantErr: true, wantRequests: 1},
1696 {name: "hook splits without the fallback sync", opts: options{silent: true}, wantRequests: 3},
1698 for _, tt := range tests {
1699 t.Run(tt.name, func(t *testing.T) {
1700 home := t.TempDir()
1701 t.Setenv("HOME", home)
1702 if tt.fallbackInstalled {
1703 installFakeFallbackSync(t, home)
1705 fake := &fakeGitLab{maxElements: 30}
1706 poster := newTestPoster(t, fake, &tt.opts)
1708 events := make([]auditEventRequest, 4)
1709 for i := range events {
1710 events[i] = auditEventRequest{EventName: eventToolInvoked, CloudEventID: fmt.Sprintf("event-%d", i)}
1712 tooLarge, err := poster.post(t.Context(), events)
1714 if tt.wantErr {
1715 assert.True(t, requestTooLarge(err), err)
1716 } else {
1717 require.NoError(t, err)
1718 assert.Equal(t, 4, fake.eventsPosted)
1720 assert.Zero(t, tooLarge)
1721 assert.Equal(t, tt.wantRequests, fake.auditRequests)
1722 })
1726func newTestPoster(t *testing.T, fake *fakeGitLab, opts *options) auditEventPoster {
1727 t.Helper()
1728 server := httptest.NewServer(fake)
1729 t.Cleanup(server.Close)
1730 // WithoutRetries alone does not stop api.WithSafeRetries' per-request retries.
1731 gl, err := gitlab.NewClient("test-token", gitlab.WithBaseURL(server.URL+"/api/v4"), gitlab.WithoutRetries(), gitlab.WithCustomRetryMax(0))
1732 require.NoError(t, err)
1733 ios, _, _, _ := cmdtest.TestIOStreams()
1734 opts.io = ios
1735 client := cmdtest.NewTestApiClient(t, nil, "test-token", testHost, api.WithGitLabClient(gl))
1736 return auditEventPoster{client: client, projectID: 42, sessionID: 99, opts: opts}
1739func installFakeFallbackSync(t *testing.T, home string) {
1740 t.Helper()
1741 units, err := fallbacksync.Units(runtime.GOOS, home, fallbacksync.Job{})
1742 if errors.Is(err, fallbacksync.ErrUnsupportedOS) {
1743 t.Skip("the fallback sync is not available on this OS")
1745 require.NoError(t, err)
1746 require.NoError(t, os.MkdirAll(filepath.Dir(units[0].Path), 0o755))
1747 require.NoError(t, os.WriteFile(units[0].Path, nil, 0o644))
1750func TestWriteCursor_DoesNotMoveBack(t *testing.T) {
1751 t.Setenv("GLAB_CONFIG_DIR", t.TempDir())
1753 require.NoError(t, syncstate.WritePosition("sess-1", 200))
1754 require.NoError(t, syncstate.WritePosition("sess-1", 100))
1755 assertCursorAt(t, "sess-1", 200)
1757 require.NoError(t, syncstate.WritePosition("sess-1", 300))
1758 assertCursorAt(t, "sess-1", 300)
1761func TestOptionsWait_StopsWhenCanceled(t *testing.T) {
1762 ctx, cancel := context.WithCancel(t.Context())
1763 cancel()
1765 assert.ErrorIs(t, (&options{}).wait(ctx, time.Hour), context.Canceled)
1768// writeSessionWithoutProject records a Claude Code session the way a hook does
1769// in a folder without a GitLab remote.
1770func (e *syncAllEnv) writeSessionWithoutProject(t *testing.T, sessionID string) {
1771 t.Helper()
1772 path := e.writeClaudeSession(t, sessionID, "my-group/my-project", "toolu_1")
1773 require.NoError(t, writeSessionMeta(sessionID, sessionMeta{AgentType: "claude-code", Transcript: path}))
1776const notSyncedWithoutRemote = "claude-code sessions in a folder where glab could not identify a GitLab project"
1778func TestSyncAll_ReportsSessionWithoutGitLabRemote(t *testing.T) {
1779 env := newSyncAllEnv(t, true)
1780 env.writeSessionWithoutProject(t, "sess-1")
1782 _, err := env.exec("--all")
1783 require.NoError(t, err)
1785 assert.Empty(t, env.fake.sessionsCreated)
1786 status := readStatus(t)
1787 assert.Empty(t, status.Errors)
1788 assert.Equal(t, []string{notSyncedWithoutRemote}, status.Skipped)
1789 meta, err := readSessionMeta("sess-1")
1790 require.NoError(t, err)
1791 assert.Nil(t, meta.CompletedAt, "an active session is kept, so later runs still report it")
1794func TestSyncAll_CompletesIdleSessionWithoutGitLabRemote(t *testing.T) {
1795 env := newSyncAllEnv(t, true)
1796 env.writeSessionWithoutProject(t, "sess-1")
1797 path, err := metaPath("sess-1")
1798 require.NoError(t, err)
1799 idle := time.Now().Add(-2 * idleCompleteAfter)
1800 require.NoError(t, os.Chtimes(path, idle, idle))
1802 _, err = env.exec("--all")
1803 require.NoError(t, err)
1805 assert.Empty(t, env.fake.sessionsCreated)
1806 assert.Empty(t, readStatus(t).Errors)
1807 meta, err := readSessionMeta("sess-1")
1808 require.NoError(t, err)
1809 assert.NotNil(t, meta.CompletedAt, "the record is kept until the agent can no longer resume the session")
1812func TestSyncAll_SessionResumedInGitLabProjectAfterIdleCompletionSkipsEarlierActivity(t *testing.T) {
1813 env := newSyncAllEnv(t, true)
1814 env.writeSessionWithoutProject(t, "sess-2")
1815 path, err := metaPath("sess-2")
1816 require.NoError(t, err)
1817 idle := time.Now().Add(-2 * idleCompleteAfter)
1818 require.NoError(t, os.Chtimes(path, idle, idle))
1819 _, err = env.exec("--all")
1820 require.NoError(t, err)
1821 meta, err := readSessionMeta("sess-2")
1822 require.NoError(t, err)
1823 require.NotNil(t, meta.CompletedAt)
1824 content, err := os.ReadFile(meta.Transcript)
1825 require.NoError(t, err)
1827 opts := &options{agentType: "claude-code", baseRepo: func() (glrepo.Interface, error) {
1828 return glrepo.NewWithHost("my-group", "my-project", testHost), nil
1829 }}
1830 require.NoError(t, recordSessionMeta(t.Context(), opts, claudeCode{}, "sess-2", meta.Transcript))
1832 assertCursorAt(t, "sess-2", int64(len(content)))
1833 meta, err = readSessionMeta("sess-2")
1834 require.NoError(t, err)
1835 assert.Equal(t, "my-group/my-project", meta.PathWithNamespace)
1836 assert.Nil(t, meta.CompletedAt, "the resumed session syncs again")
1839func TestSyncAll_ReportsSessionWithoutGitLabRemoteWhoseTranscriptIsGone(t *testing.T) {
1840 env := newSyncAllEnv(t, true)
1841 env.writeSessionWithoutProject(t, "sess-1")
1842 meta, err := readSessionMeta("sess-1")
1843 require.NoError(t, err)
1844 require.NoError(t, os.Remove(meta.Transcript))
1846 _, err = env.exec("--all")
1847 require.NoError(t, err)
1849 status := readStatus(t)
1850 assert.Empty(t, status.Errors)
1851 assert.Equal(t, []string{notSyncedWithoutRemote}, status.Skipped)
1852 _, err = readSessionMeta("sess-1")
1853 assert.NoError(t, err, "unlike a session with a project, it is not forgotten when its transcript is gone")
Diagnostics9 git calls · 345 ms
CallStatusSizeTime0345 ms
discover200185 B2 ms
git.upload-pack discover
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=ls-refs
git.upstream.dur_ms=2
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 · hit2 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=HIT
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 · 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=32926
git.response.cache=HIT
git.response.duration_ms=2
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=44
Open 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:02001.8 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=1857
git.response.cache=HIT
git.response.duration_ms=3
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=fb03183b7909876778f740d196d7516811003517
Open pack map
fetchtree:0200261 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=261
git.response.cache=HIT
git.response.duration_ms=3
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=e0a52f164f79506da6b0dcc275ed62911f5383bf
Open pack map
fetchtree:0200139 B · 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=139
git.response.cache=HIT
git.response.duration_ms=4
git.fetch.filter=tree:0
git.fetch.wants=f91da6c620e9fe39086f689d1ae91b87356cda50
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=139
git.pkt.payload.max=112
git.sideband.band1.bytes=112
git.sideband.band2.bytes=0
git.sideband.band3.bytes=0
git.pack.objects=1
git.pack.bytes=112
git.pack.trailer=a35549813b2a01d473947912b5773e993ce7c2e2
Open pack map
fetchtree:0200638 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=638
git.response.cache=HIT
git.response.duration_ms=2
git.fetch.filter=tree:0
git.fetch.wants=02089b627a9895becfd23127f25e46df629ce9b2
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=638
git.pkt.payload.max=611
git.sideband.band1.bytes=611
git.sideband.band2.bytes=0
git.sideband.band3.bytes=0
git.pack.objects=1
git.pack.bytes=611
git.pack.trailer=f2a6246e346c2fa34e54ecb04cb1dd1c524f65bc
Open pack map
fetch20014 KiB328 ms
git.upload-pack fetch
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=fetch
git.upstream.dur_ms=328
git.response.bytes=13943
git.response.cache=MISS
git.response.duration_ms=328
git.fetch.wants=7762cd098f9d7853c25b03547c23397ab22ecc5d
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=13943
git.pkt.payload.max=13916
git.sideband.band1.bytes=13916
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
a5e2e16428404af4
Request
d1e61435…
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