GitLabgitlab-org
cli
main
1//go:build !integration
3package sync
5import (
6 "context"
7 "encoding/json"
8 "errors"
9 "fmt"
10 "io"
11 "os"
12 "path/filepath"
13 "testing"
14 "time"
16 "github.com/stretchr/testify/assert"
17 "github.com/stretchr/testify/require"
18 "go.uber.org/mock/gomock"
20 "gitlab.com/gitlab-org/cli/internal/commands/govern/internal/fallbacksync"
21 "gitlab.com/gitlab-org/cli/internal/commands/govern/internal/syncstate"
22)
24// claudeTurns returns a Claude Code transcript of sess-1 with a prompt and a tool call
25// at each time, numbered from 0.
26func claudeTurns(t *testing.T, at ...time.Time) []byte {
27 t.Helper()
28 const sessionID = "sess-1"
29 var records []any
30 for i, ts := range at {
31 stamp := ts.UTC().Format(time.RFC3339Nano)
32 records = append(records,
33 map[string]any{
34 "type": "user", "sessionId": sessionID, "uuid": fmt.Sprintf("u-%d", i), "promptId": fmt.Sprintf("p-%d", i),
35 "timestamp": stamp, "message": map[string]any{"role": "user", "content": fmt.Sprintf("prompt %d", i)},
36 },
37 map[string]any{
38 "type": "assistant", "sessionId": sessionID, "timestamp": stamp,
39 "message": map[string]any{"content": []map[string]any{{"type": "tool_use", "id": fmt.Sprintf("toolu_%d", i), "name": "Bash"}}},
40 },
41 )
42 }
43 return []byte(jsonLines(t, records...))
44}
46// uploadedActivity names the prompts and tool calls in events.
47func uploadedActivity(events []auditEventRequest) []string {
48 var got []string
49 for _, e := range events {
50 switch e.EventName {
51 case eventUserInput:
52 got = append(got, fmt.Sprint("prompt: ", e.Details["content"]))
53 case eventToolInvoked:
54 got = append(got, fmt.Sprint("tool: ", e.Details["tool_call_id"]))
55 }
56 }
57 return got
58}
60func setUpAgent(t *testing.T, agent string, setup fallbacksync.AgentSetup) {
61 t.Helper()
62 require.NoError(t, fallbacksync.SetAgentSetups(fallbacksync.AgentSetups{agent: setup}))
63}
65func TestDropBefore(t *testing.T) {
66 t.Parallel()
68 since := time.Date(2026, 11, 20, 10, 0, 0, 0, time.UTC)
69 before, after := since.Add(-time.Hour), since.Add(time.Hour)
70 full := func() *sessionData {
71 return &sessionData{
72 Goal: "first",
73 StartedAt: before,
74 Prompts: []prompt{{ID: "p-0", Text: "first", Timestamp: before}, {ID: "p-1", Text: "second", Timestamp: after}},
75 ToolCalls: []toolCall{{ID: "toolu_0", Timestamp: before}, {ID: "toolu_1", Timestamp: since}},
76 // toolu_0 spans since: it is called before since and ends after.
77 ToolResults: []toolResult{{CallID: "toolu_0", Timestamp: after}, {CallID: "toolu_1", Timestamp: after}},
78 Responses: []llmResponse{{ID: "msg_0", Timestamp: before}, {ID: "msg_1", Timestamp: after}},
79 }
80 }
82 tests := map[string]struct {
83 data *sessionData
84 since time.Time
85 want *sessionData
86 }{
87 "no limit": {data: full(), want: full()},
88 "session started before since": {
89 data: full(),
90 since: since,
91 want: &sessionData{
92 Prompts: []prompt{{ID: "p-1", Text: "second", Timestamp: after}},
93 ToolCalls: []toolCall{{ID: "toolu_1", Timestamp: since}},
94 ToolResults: []toolResult{{CallID: "toolu_1", Timestamp: after}},
95 Responses: []llmResponse{{ID: "msg_1", Timestamp: after}},
96 },
97 },
98 "nothing after since": {
99 data: &sessionData{Goal: "first", StartedAt: before, Prompts: []prompt{{ID: "p-0", Text: "first", Timestamp: before}}},
100 since: since,
101 want: &sessionData{Prompts: []prompt{}},
102 },
103 "goal without prompts, as from OpenCode": {
104 data: &sessionData{Goal: "fix the flaky test", StartedAt: before},
105 since: since,
106 want: &sessionData{},
107 },
108 "session started after since": {
109 data: &sessionData{Goal: "second", StartedAt: after, Prompts: []prompt{{ID: "p-1", Text: "second", Timestamp: after}}},
110 since: since,
111 want: &sessionData{Goal: "second", StartedAt: after, Prompts: []prompt{{ID: "p-1", Text: "second", Timestamp: after}}},
112 },
113 "goal kept on a later read, which sets none": {
114 data: &sessionData{Prompts: []prompt{{ID: "p-0", Text: "first", Timestamp: before}, {ID: "p-1", Text: "second", Timestamp: after}}},
115 since: since,
116 want: &sessionData{Prompts: []prompt{{ID: "p-1", Text: "second", Timestamp: after}}},
117 },
118 }
119 for name, tc := range tests {
120 t.Run(name, func(t *testing.T) {
121 t.Parallel()
122 tc.data.dropBefore(tc.since)
123 assert.Equal(t, tc.want.Goal, tc.data.Goal)
124 assert.Equal(t, tc.want.StartedAt, tc.data.StartedAt)
125 assert.ElementsMatch(t, tc.want.Prompts, tc.data.Prompts)
126 assert.ElementsMatch(t, tc.want.ToolCalls, tc.data.ToolCalls)
127 assert.ElementsMatch(t, tc.want.ToolResults, tc.data.ToolResults)
128 assert.ElementsMatch(t, tc.want.Responses, tc.data.Responses)
129 })
130 }
131}
133func TestRunSync_UploadsClaudeCodeActivityFromSetup(t *testing.T) {
134 now := time.Now()
136 tests := map[string]struct {
137 setup *fallbacksync.AgentSetup
138 turns []time.Time
139 args string
140 want []string
141 // wantGoal is empty when no session is created.
142 wantGoal string
143 }{
144 "session started after setup": {
145 setup: &fallbacksync.AgentSetup{SetUpAt: now.Add(-2 * time.Hour)},
146 turns: []time.Time{now.Add(-time.Hour), now.Add(-time.Minute)},
147 want: []string{"prompt: prompt 0", "prompt: prompt 1", "tool: toolu_0", "tool: toolu_1"},
148 wantGoal: "prompt 0",
149 },
150 "session from before setup, resumed": {
151 setup: &fallbacksync.AgentSetup{SetUpAt: now.Add(-time.Hour)},
152 turns: []time.Time{now.Add(-3 * time.Hour), now.Add(-time.Minute)},
153 want: []string{"prompt: prompt 1", "tool: toolu_1"},
154 wantGoal: "prompt 1",
155 },
156 "history": {
157 setup: &fallbacksync.AgentSetup{SetUpAt: now.Add(-time.Hour), History: true},
158 turns: []time.Time{now.Add(-3 * time.Hour), now.Add(-time.Minute)},
159 want: []string{"prompt: prompt 0", "prompt: prompt 1", "tool: toolu_0", "tool: toolu_1"},
160 wantGoal: "prompt 0",
161 },
162 "set up before glab recorded when": {
163 turns: []time.Time{now.Add(-3 * time.Hour), now.Add(-time.Minute)},
164 want: []string{"prompt: prompt 0", "prompt: prompt 1", "tool: toolu_0", "tool: toolu_1"},
165 wantGoal: "prompt 0",
166 },
167 "session from before setup, ended": {
168 setup: &fallbacksync.AgentSetup{SetUpAt: now.Add(-time.Hour)},
169 turns: []time.Time{now.Add(-3 * time.Hour)},
170 args: " --complete",
171 },
172 }
173 for name, tc := range tests {
174 t.Run(name, func(t *testing.T) {
175 env := newSyncAllEnv(t, true)
176 t.Setenv("CLAUDE_CODE_SESSION_ID", "sess-1")
177 if tc.setup != nil {
178 setUpAgent(t, "claude-code", *tc.setup)
179 }
180 cwd, err := currentCWD()
181 require.NoError(t, err)
182 path, err := transcriptPath("sess-1", cwd)
183 require.NoError(t, err)
184 require.NoError(t, os.MkdirAll(filepath.Dir(path), 0o755))
185 require.NoError(t, os.WriteFile(path, claudeTurns(t, tc.turns...), 0o644))
187 _, err = env.exec("-R my-group/my-project --silent" + tc.args)
188 require.NoError(t, err)
190 assert.ElementsMatch(t, tc.want, uploadedActivity(env.fake.events))
191 if tc.wantGoal == "" {
192 assert.Empty(t, env.fake.sessionRequests, "a session with nothing to upload is not created on GitLab")
193 assert.Zero(t, env.fake.completed)
194 return
195 }
196 require.Len(t, env.fake.sessionRequests, 1)
197 assert.Equal(t, tc.wantGoal, env.fake.sessionRequests[0].Goal)
198 })
199 }
200}
202func TestRunSync_UnreadableAgentSetupsUploadNothing(t *testing.T) {
203 env := newSyncAllEnv(t, true)
204 t.Setenv("CLAUDE_CODE_SESSION_ID", "sess-1")
205 writeHookTranscript(t, "sess-1", "toolu_1")
206 path := filepath.Join(env.home, "glab", "gaig", "agent-setups.json")
207 require.NoError(t, os.MkdirAll(filepath.Dir(path), 0o755))
208 require.NoError(t, os.WriteFile(path, []byte("{not json"), 0o600))
210 _, err := env.exec("-R my-group/my-project --silent")
211 require.ErrorContains(t, err, "could not tell which claude-code activity to upload")
212 assert.Empty(t, env.fake.sessionRequests)
214 _, err = env.exec("--all")
215 require.Error(t, err)
216 assert.Empty(t, env.fake.sessionRequests)
217 assert.Contains(t, readStatus(t).Errors[0], "could not tell which activity to upload")
218}
220func TestSyncAll_UploadsClaudeCodeActivityFromSetup(t *testing.T) {
221 env := newSyncAllEnv(t, true)
222 now := time.Now()
223 setUpAgent(t, "claude-code", fallbacksync.AgentSetup{SetUpAt: now.Add(-time.Hour)})
224 path := env.writeClaudeSession(t, "sess-1", "my-group/my-project")
225 require.NoError(t, os.WriteFile(path, claudeTurns(t, now.Add(-3*time.Hour), now.Add(-time.Minute)), 0o644))
227 _, err := env.exec("--all")
228 require.NoError(t, err)
230 assert.ElementsMatch(t, []string{"prompt: prompt 1", "tool: toolu_1"}, uploadedActivity(env.fake.events))
231 assertCursorAtEnd(t, path)
232}
234func TestSyncAll_UploadsCodexActivityFromSetup(t *testing.T) {
235 now := time.Now()
236 remote := "git@" + testHost + ":my-group/my-project.git"
237 call := func(at time.Time, id string) map[string]any {
238 return codexItem(at.UTC().Format(time.RFC3339), map[string]any{"type": "function_call", "name": "exec_command", "call_id": id})
239 }
241 t.Run("session that runs across setup", func(t *testing.T) {
242 env := newSyncAllEnv(t, true)
243 require.NoError(t, fallbacksync.SetDiscoveredAgents([]string{"codex"}))
244 setUpAgent(t, "codex", fallbacksync.AgentSetup{SetUpAt: now.Add(-time.Hour)})
245 writeCodexRollout(t, env.home, "th-1", jsonLines(t,
246 codexSessionMetaLine("th-1", "/work", remote),
247 call(now.Add(-3*time.Hour), "call_before"),
248 call(now.Add(-time.Minute), "call_after"),
249 ))
251 _, err := env.exec("--all")
252 require.NoError(t, err)
254 assert.Equal(t, []string{"tool: call_after"}, uploadedActivity(env.fake.events))
255 })
257 t.Run("session from before setup", func(t *testing.T) {
258 env := newSyncAllEnv(t, true)
259 require.NoError(t, fallbacksync.SetDiscoveredAgents([]string{"codex"}))
260 setUpAgent(t, "codex", fallbacksync.AgentSetup{SetUpAt: now.Add(-24 * time.Hour)})
261 old := now.Add(-3 * 24 * time.Hour)
262 path := writeCodexRollout(t, env.home, "th-1", jsonLines(t,
263 codexSessionMetaLine("th-1", "/work", remote),
264 call(old, "call_before"),
265 ))
266 require.NoError(t, os.Chtimes(path, old, old))
268 for range 2 {
269 _, err := env.exec("--all")
270 require.NoError(t, err)
271 }
273 assert.Empty(t, env.fake.sessionRequests, "an idle session with only activity from before setup is not created on GitLab, to be completed")
274 meta, err := readSessionMeta("th-1")
275 require.NoError(t, err)
276 assert.Nil(t, meta.CompletedAt, "a session from before setup is kept, in case the user resumes it")
277 assertCursorAt(t, "th-1", fileSize(t, path))
279 f, err := os.OpenFile(path, os.O_APPEND|os.O_WRONLY, 0o644)
280 require.NoError(t, err)
281 _, err = f.WriteString(jsonLines(t,
282 map[string]any{"timestamp": now.UTC().Format(time.RFC3339), "type": "event_msg", "payload": map[string]any{"type": "user_message", "message": "a prompt after setup"}},
283 call(now, "call_resumed"),
284 ))
285 require.NoError(t, errors.Join(err, f.Close()))
287 _, err = env.exec("--all")
288 require.NoError(t, err)
290 assert.Equal(t, []string{"prompt: a prompt after setup", "tool: call_resumed"}, uploadedActivity(env.fake.events), "the session uploads what the user does after resuming it")
291 require.Len(t, env.fake.sessionRequests, 1)
292 assert.Equal(t, "a prompt after setup", env.fake.sessionRequests[0].Goal, "the goal is the first prompt after setup")
293 assert.Empty(t, env.fake.sessionRequests[0].StartedAt, "the session started before setup")
294 })
296 t.Run("session from before setup that GitLab would not accept", func(t *testing.T) {
297 env := newSyncAllEnv(t, true)
298 require.NoError(t, fallbacksync.SetDiscoveredAgents([]string{"codex"}))
299 setUpAgent(t, "codex", fallbacksync.AgentSetup{SetUpAt: now.Add(-24 * time.Hour)})
300 old := now.Add(-100 * 24 * time.Hour)
301 path := writeCodexRollout(t, env.home, "th-1", jsonLines(t, codexSessionMetaLine("th-1", "/work", remote)))
302 require.NoError(t, os.Chtimes(path, old, old))
304 _, err := env.exec("--all")
305 require.NoError(t, err)
307 meta, err := readSessionMeta("th-1")
308 require.NoError(t, err)
309 assert.NotNil(t, meta.CompletedAt, "it is not checked again, as without setup")
310 })
311}
313func TestSyncAll_UploadsOpenCodeActivityFromSetup(t *testing.T) {
314 env := newSyncAllEnv(t, true)
315 now := time.UnixMilli(time.Now().UnixMilli())
316 setUpAgent(t, "opencode", fallbacksync.AgentSetup{SetUpAt: now.Add(-time.Hour)})
318 tool := func(id string, at time.Time) map[string]any {
319 return map[string]any{
320 "id": "prt_" + id, "type": "tool", "callID": id, "tool": "bash",
321 "state": map[string]any{"status": "completed", "time": map[string]any{"start": at.UnixMilli(), "end": at.UnixMilli()}},
322 }
323 }
324 export, err := json.Marshal(map[string]any{
325 "info": map[string]any{"id": "ses_1", "time": map[string]any{"created": now.Add(-3 * time.Hour).UnixMilli(), "updated": now.UnixMilli()}},
326 "messages": []map[string]any{
327 {
328 "info": map[string]any{"role": "user", "time": map[string]any{"created": now.Add(-3 * time.Hour).UnixMilli()}},
329 "parts": []map[string]any{{"id": "prt_goal", "type": "text", "text": "a prompt from before setup"}},
330 },
331 {
332 "info": map[string]any{"role": "assistant", "time": map[string]any{"created": now.UnixMilli()}},
333 "parts": []map[string]any{tool("call_before", now.Add(-3*time.Hour)), tool("call_after", now)},
334 },
335 },
336 })
337 require.NoError(t, err)
338 binary := filepath.Join(t.TempDir(), "opencode")
339 require.NoError(t, os.WriteFile(binary, nil, 0o755))
340 require.NoError(t, writeSessionMeta("ses_1", sessionMeta{AgentType: "opencode", PathWithNamespace: "my-group/my-project", Host: testHost, Transcript: binary}))
341 env.mExec.EXPECT().
342 ExecWithIO(gomock.Any(), binary, []string{"session", "export", "--standalone", "ses_1"}, nil, nil, gomock.Any(), gomock.Any()).
343 DoAndReturn(func(_ context.Context, _ string, _, _ []string, _ io.Reader, stdout, _ io.Writer) error {
344 _, err := stdout.Write(export)
345 return err
346 })
348 _, err = env.exec("--all")
349 require.NoError(t, err)
351 assert.Equal(t, []string{"tool: call_after"}, uploadedActivity(env.fake.events))
352 require.Len(t, env.fake.sessionRequests, 1)
353 assert.Empty(t, env.fake.sessionRequests[0].Goal, "the goal is a prompt from before setup")
354 assertCursorAt(t, "ses_1", 2)
355}
357func TestSyncAll_UploadsCursorActivityFromSetup(t *testing.T) {
358 now := time.Now()
359 promptLine := func(text string) string {
360 return jsonLines(t, map[string]any{"role": "user", "message": map[string]any{"content": []any{map[string]any{"type": "text", "text": "<user_query>" + text + "</user_query>"}}}})
361 }
363 tests := map[string]struct {
364 setUpAt time.Time
365 // snapshot starts the session where its transcript ends, as setup
366 // does for the Cursor sessions that exist when it runs.
367 snapshot bool
368 want []string
369 }{
370 "session created after setup": {
371 setUpAt: now.Add(-time.Hour),
372 want: []string{"prompt: earlier turn", "prompt: later turn"},
373 },
374 "session from before setup, resumed": {
375 setUpAt: now.Add(-time.Hour),
376 snapshot: true,
377 want: []string{"prompt: later turn"},
378 },
379 "session last active before setup, which setup did not see": {
380 setUpAt: now.Add(time.Minute),
381 want: []string{"prompt: later turn"},
382 },
383 }
384 for name, tc := range tests {
385 t.Run(name, func(t *testing.T) {
386 env := newSyncAllEnv(t, true)
387 require.NoError(t, fallbacksync.SetDiscoveredAgents([]string{"cursor"}))
388 setUpAgent(t, "cursor", fallbacksync.AgentSetup{SetUpAt: tc.setUpAt})
389 path := filepath.Join(t.TempDir(), "conv-1", "conv-1.jsonl")
390 require.NoError(t, os.MkdirAll(filepath.Dir(path), 0o755))
391 require.NoError(t, os.WriteFile(path, []byte(promptLine("earlier turn")), 0o644))
392 if tc.snapshot {
393 require.NoError(t, syncstate.StartAt("conv-1", fileSize(t, path)))
394 }
395 require.NoError(t, writeSessionMeta("conv-1", sessionMeta{AgentType: "cursor", PathWithNamespace: "my-group/my-project", Host: testHost, Transcript: path}))
397 _, err := env.exec("--all")
398 require.NoError(t, err)
400 f, err := os.OpenFile(path, os.O_APPEND|os.O_WRONLY, 0o644)
401 require.NoError(t, err)
402 _, err = f.WriteString(promptLine("later turn"))
403 require.NoError(t, errors.Join(err, f.Close()))
404 later := now.Add(3 * time.Minute)
405 require.NoError(t, os.Chtimes(path, later, later))
407 _, err = env.exec("--all")
408 require.NoError(t, err)
410 assert.Equal(t, tc.want, uploadedActivity(env.fake.events))
411 assertCursorAt(t, "conv-1", fileSize(t, path))
412 })
413 }
414}
416func fileSize(t *testing.T, path string) int64 {
417 t.Helper()
418 info, err := os.Stat(path)
419 require.NoError(t, err)
420 return info.Size()
421}
423func TestRunSync_SkipsClaudeCodeCompactionSummaries(t *testing.T) {
424 env := newSyncAllEnv(t, true)
425 t.Setenv("CLAUDE_CODE_SESSION_ID", "sess-1")
426 now := time.Now()
427 setUpAgent(t, "claude-code", fallbacksync.AgentSetup{SetUpAt: now.Add(-time.Hour)})
428 summary := func(field string) map[string]any {
429 return map[string]any{
430 "type": "user", "sessionId": "sess-1", "uuid": "u-" + field, "promptId": "p-" + field, field: true,
431 "timestamp": now.Add(-time.Minute).UTC().Format(time.RFC3339Nano),
432 "message": map[string]any{"role": "user", "content": "This session continues a conversation from before setup."},
433 }
434 }
435 cwd, err := currentCWD()
436 require.NoError(t, err)
437 path, err := transcriptPath("sess-1", cwd)
438 require.NoError(t, err)
439 content := append(claudeTurns(t, now.Add(-3*time.Hour)), jsonLines(t, summary("isCompactSummary"), summary("isVisibleInTranscriptOnly"))...)
440 content = append(content, jsonLines(t, map[string]any{
441 "type": "user", "sessionId": "sess-1", "uuid": "u-after", "promptId": "p-after",
442 "timestamp": now.UTC().Format(time.RFC3339Nano), "message": map[string]any{"role": "user", "content": "a prompt after setup"},
443 })...)
444 require.NoError(t, os.MkdirAll(filepath.Dir(path), 0o755))
445 require.NoError(t, os.WriteFile(path, content, 0o644))
447 _, err = env.exec("-R my-group/my-project --silent")
448 require.NoError(t, err)
450 assert.Equal(t, []string{"prompt: a prompt after setup"}, uploadedActivity(env.fake.events), "a summary of the conversation before setup is not uploaded")
451 require.Len(t, env.fake.sessionRequests, 1)
452 assert.Equal(t, "a prompt after setup", env.fake.sessionRequests[0].Goal)
453}
455func TestRunSync_CompleteOnlySessionsWithUploads(t *testing.T) {
456 tests := map[string]struct {
457 uploaded bool
458 wantCompleted int
459 }{
460 "nothing uploaded": {},
461 "uploaded before": {uploaded: true, wantCompleted: 1},
462 }
463 for name, tc := range tests {
464 t.Run(name, func(t *testing.T) {
465 env := newSyncAllEnv(t, true)
466 t.Setenv("CLAUDE_CODE_SESSION_ID", "sess-1")
467 setUpAgent(t, "claude-code", fallbacksync.AgentSetup{SetUpAt: time.Now().Add(-time.Hour)})
468 cwd, err := currentCWD()
469 require.NoError(t, err)
470 path, err := transcriptPath("sess-1", cwd)
471 require.NoError(t, err)
472 require.NoError(t, os.MkdirAll(filepath.Dir(path), 0o755))
473 line := jsonLines(t, map[string]any{"type": "system", "sessionId": "sess-1", "timestamp": time.Now().UTC().Format(time.RFC3339Nano)})
474 require.NoError(t, os.WriteFile(path, []byte(line), 0o644))
475 if tc.uploaded {
476 require.NoError(t, syncstate.WritePosition("sess-1", int64(len(line))))
477 }
479 _, err = env.exec("-R my-group/my-project --silent --complete")
480 require.NoError(t, err)
482 assert.Equal(t, tc.wantCompleted, env.fake.completed)
483 assert.Len(t, env.fake.sessionRequests, tc.wantCompleted, "a session with nothing uploaded is not created on GitLab")
484 })
485 }
486}
488func TestRunSync_CursorHookSessionFromBeforeSetup(t *testing.T) {
489 env := newSyncAllEnv(t, true)
490 require.NoError(t, fallbacksync.SetDiscoveredAgents([]string{"cursor"}))
491 setUpAgent(t, "cursor", fallbacksync.AgentSetup{SetUpAt: time.Now().Add(-time.Hour)})
492 path := writeCursorTranscript(t, env.home, "conv-1")
493 require.NoError(t, syncstate.StartAt("conv-1", fileSize(t, path)))
494 t.Setenv(hookAgentEnv, "cursor")
495 t.Setenv(hookSessionEnv, "conv-1")
496 t.Setenv(hookTranscriptEnv, path)
498 _, err := env.exec("--silent -R " + testHost + "/my-group/my-project")
499 require.NoError(t, err)
500 assert.Empty(t, env.fake.sessionRequests, "the turns from before setup are not uploaded")
502 f, err := os.OpenFile(path, os.O_APPEND|os.O_WRONLY, 0o644)
503 require.NoError(t, err)
504 _, err = f.WriteString(jsonLines(t, map[string]any{"role": "user", "message": map[string]any{"content": []any{map[string]any{"type": "text", "text": "<user_query>a turn after setup</user_query>"}}}}))
505 require.NoError(t, errors.Join(err, f.Close()))
507 _, err = env.exec("--silent -R " + testHost + "/my-group/my-project")
508 require.NoError(t, err)
509 assert.Equal(t, []string{"prompt: a turn after setup"}, uploadedActivity(env.fake.events))
510 require.Len(t, env.fake.sessionRequests, 1)
511 assert.Equal(t, "a turn after setup", env.fake.sessionRequests[0].Goal, "the goal is the first prompt after setup")
512}
514func TestRunSync_UnreadableCursorUploadsNothing(t *testing.T) {
515 env := newSyncAllEnv(t, true)
516 require.NoError(t, fallbacksync.SetDiscoveredAgents([]string{"cursor"}))
517 setUpAgent(t, "cursor", fallbacksync.AgentSetup{SetUpAt: time.Now().Add(-time.Hour)})
518 path := writeCursorTranscript(t, env.home, "conv-1")
519 cp, err := syncstate.PositionPath("conv-1")
520 require.NoError(t, err)
521 require.NoError(t, os.MkdirAll(filepath.Dir(cp), 0o755))
522 require.NoError(t, os.WriteFile(cp, []byte("not a number"), 0o644))
523 t.Setenv(hookAgentEnv, "cursor")
524 t.Setenv(hookSessionEnv, "conv-1")
525 t.Setenv(hookTranscriptEnv, path)
527 _, err = env.exec("--silent -R " + testHost + "/my-group/my-project")
528 require.ErrorContains(t, err, "could not read the sync position")
529 assert.Empty(t, env.fake.sessionRequests, "the transcript is not uploaded again from its beginning")
530}
532func TestRunSync_ClaudeCodeSessionFromBeforeSetupTakesItsGoalAfterSetup(t *testing.T) {
533 env := newSyncAllEnv(t, true)
534 t.Setenv("CLAUDE_CODE_SESSION_ID", "sess-1")
535 now := time.Now()
536 setUpAgent(t, "claude-code", fallbacksync.AgentSetup{SetUpAt: now.Add(-time.Hour)})
537 cwd, err := currentCWD()
538 require.NoError(t, err)
539 path, err := transcriptPath("sess-1", cwd)
540 require.NoError(t, err)
541 require.NoError(t, os.MkdirAll(filepath.Dir(path), 0o755))
542 require.NoError(t, os.WriteFile(path, claudeTurns(t, now.Add(-3*time.Hour)), 0o644))
543 old := now.Add(-2 * time.Hour)
544 require.NoError(t, os.Chtimes(path, old, old))
546 _, err = env.exec("-R my-group/my-project --silent")
547 require.NoError(t, err)
548 require.Empty(t, env.fake.sessionRequests)
550 f, err := os.OpenFile(path, os.O_APPEND|os.O_WRONLY, 0o644)
551 require.NoError(t, err)
552 _, err = f.WriteString(jsonLines(t, map[string]any{
553 "type": "user", "sessionId": "sess-1", "uuid": "u-after", "promptId": "p-after",
554 "timestamp": now.UTC().Format(time.RFC3339Nano), "message": map[string]any{"role": "user", "content": "a prompt after setup"},
555 }))
556 require.NoError(t, errors.Join(err, f.Close()))
558 _, err = env.exec("-R my-group/my-project --silent")
559 require.NoError(t, err)
561 assert.Equal(t, []string{"prompt: a prompt after setup"}, uploadedActivity(env.fake.events))
562 require.Len(t, env.fake.sessionRequests, 1)
563 assert.Equal(t, "a prompt after setup", env.fake.sessionRequests[0].Goal)
564}
566// A call that starts before setup and ends after it, such as the agent
567// running glab minder setup, uploads neither the call nor its result.
568func TestSync_LeavesOutResultsOfCallsFromBeforeSetup(t *testing.T) {
569 now := time.Now()
570 setUpAt := now.Add(-time.Hour)
571 before, after := setUpAt.Add(-time.Minute), setUpAt.Add(time.Minute)
573 t.Run("claude-code", func(t *testing.T) {
574 env := newSyncAllEnv(t, true)
575 t.Setenv("CLAUDE_CODE_SESSION_ID", "sess-1")
576 setUpAgent(t, "claude-code", fallbacksync.AgentSetup{SetUpAt: setUpAt})
577 call := func(id string) map[string]any {
578 return map[string]any{
579 "type": "assistant", "sessionId": "sess-1", "timestamp": before.UTC().Format(time.RFC3339Nano),
580 "message": map[string]any{"content": []map[string]any{{"type": "tool_use", "id": id, "name": "Bash"}}},
581 }
582 }
583 result := func(id string, failed bool) map[string]any {
584 return map[string]any{
585 "type": "user", "sessionId": "sess-1", "timestamp": after.UTC().Format(time.RFC3339Nano),
586 "message": map[string]any{"role": "user", "content": []map[string]any{{"type": "tool_result", "tool_use_id": id, "is_error": failed, "content": "tool output"}}},
587 }
588 }
589 cwd, err := currentCWD()
590 require.NoError(t, err)
591 path, err := transcriptPath("sess-1", cwd)
592 require.NoError(t, err)
593 require.NoError(t, os.MkdirAll(filepath.Dir(path), 0o755))
594 require.NoError(t, os.WriteFile(path, []byte(jsonLines(t, call("toolu_fails"), call("toolu_succeeds"), result("toolu_fails", true), result("toolu_succeeds", false))), 0o644))
596 _, err = env.exec("-R my-group/my-project --silent")
597 require.NoError(t, err)
599 assert.Empty(t, env.fake.events)
600 assert.Empty(t, env.fake.sessionRequests, "no session is created for the results alone")
601 })
603 t.Run("codex", func(t *testing.T) {
604 env := newSyncAllEnv(t, true)
605 require.NoError(t, fallbacksync.SetDiscoveredAgents([]string{"codex"}))
606 setUpAgent(t, "codex", fallbacksync.AgentSetup{SetUpAt: setUpAt})
607 writeCodexRollout(t, env.home, "th-1", jsonLines(t,
608 codexSessionMetaLine("th-1", "/work", "git@"+testHost+":my-group/my-project.git"),
609 codexItem(before.UTC().Format(time.RFC3339), map[string]any{"type": "function_call", "name": "exec_command", "call_id": "call_1"}),
610 codexItem(after.UTC().Format(time.RFC3339), map[string]any{"type": "function_call_output", "call_id": "call_1"}),
611 ))
613 _, err := env.exec("--all")
614 require.NoError(t, err)
616 assert.Empty(t, env.fake.events)
617 assert.Empty(t, env.fake.sessionRequests, "no session is created for the result alone")
618 })
619}
621// appendLines appends JSONL records to the transcript at path.
622func appendLines(t *testing.T, path string, records ...any) {
623 t.Helper()
624 f, err := os.OpenFile(path, os.O_APPEND|os.O_WRONLY, 0o644)
625 require.NoError(t, err)
626 _, err = f.WriteString(jsonLines(t, records...))
627 require.NoError(t, errors.Join(err, f.Close()))
628}
630// A call still running when glab skips a transcript from before setup ends in
631// a later read, which must not upload its result without the call.
632func TestSync_LeavesOutResultsOfCallsSkippedBeforeSetup(t *testing.T) {
633 now := time.Now()
634 setUpAt := now.Add(-24 * time.Hour)
635 old := now.Add(-3 * 24 * time.Hour)
636 stamp := func(at time.Time) string { return at.UTC().Format(time.RFC3339Nano) }
638 tests := map[string]struct {
639 agent string
640 sessionID string
641 // write writes a transcript from before setup with a running call,
642 // and returns its path.
643 write func(t *testing.T, env *syncAllEnv) string
644 // result and prompt are the records the agent adds after setup.
645 result, prompt any
646 args string
647 }{
648 "claude-code": {
649 agent: "claude-code",
650 sessionID: "sess-1",
651 write: func(t *testing.T, env *syncAllEnv) string {
652 t.Helper()
653 t.Setenv("CLAUDE_CODE_SESSION_ID", "sess-1")
654 cwd, err := currentCWD()
655 require.NoError(t, err)
656 path, err := transcriptPath("sess-1", cwd)
657 require.NoError(t, err)
658 require.NoError(t, os.MkdirAll(filepath.Dir(path), 0o755))
659 return path
660 },
661 result: map[string]any{
662 "type": "user", "sessionId": "sess-1", "timestamp": stamp(now),
663 "message": map[string]any{"role": "user", "content": []map[string]any{{"type": "tool_result", "tool_use_id": "toolu_0", "content": "tool output"}}},
664 },
665 prompt: map[string]any{
666 "type": "user", "sessionId": "sess-1", "uuid": "u-after", "promptId": "p-after",
667 "timestamp": stamp(now), "message": map[string]any{"role": "user", "content": "a prompt after setup"},
668 },
669 args: "-R my-group/my-project --silent",
670 },
671 "codex": {
672 agent: "codex",
673 sessionID: "th-1",
674 write: func(t *testing.T, env *syncAllEnv) string {
675 t.Helper()
676 require.NoError(t, fallbacksync.SetDiscoveredAgents([]string{"codex"}))
677 return writeCodexRollout(t, env.home, "th-1", jsonLines(t, codexSessionMetaLine("th-1", "/work", "git@"+testHost+":my-group/my-project.git")))
678 },
679 result: codexItem(stamp(now), map[string]any{"type": "function_call_output", "call_id": "toolu_0"}),
680 prompt: map[string]any{"timestamp": stamp(now), "type": "event_msg", "payload": map[string]any{"type": "user_message", "message": "a prompt after setup"}},
681 args: "--all",
682 },
683 }
684 for name, tc := range tests {
685 t.Run(name, func(t *testing.T) {
686 env := newSyncAllEnv(t, true)
687 setUpAgent(t, tc.agent, fallbacksync.AgentSetup{SetUpAt: setUpAt})
688 path := tc.write(t, env)
689 if tc.agent == "claude-code" {
690 require.NoError(t, os.WriteFile(path, claudeTurns(t, old), 0o644))
691 } else {
692 appendLines(t, path, codexItem(stamp(old), map[string]any{"type": "function_call", "name": "exec_command", "call_id": "toolu_0"}))
693 }
694 require.NoError(t, os.Chtimes(path, old, old))
696 _, err := env.exec(tc.args)
697 require.NoError(t, err)
698 assertCursorAt(t, tc.sessionID, fileSize(t, path))
700 appendLines(t, path, tc.result)
701 _, err = env.exec(tc.args)
702 require.NoError(t, err)
703 assert.Empty(t, env.fake.sessionRequests, "no session is created for the result alone")
705 appendLines(t, path, tc.prompt)
706 _, err = env.exec(tc.args)
707 require.NoError(t, err)
708 assert.Equal(t, []string{eventUserInput}, eventNames(env.fake.events))
709 })
710 }
711}
Diagnostics9 git calls · 231 ms
CallStatusSizeTime0231 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
fetchcombine:blob:none+tree:2 · deepen 12004.2 KiB · hit2 ms
git.upload-pack fetch http.response.status_code=200 git.upstream.cf_ray=- git.upstream.phase=fetch git.upstream.dur_ms=3 git.response.bytes=4273 git.response.cache=HIT git.response.duration_ms=2 git.fetch.filter=combine:blob:none+tree:2 git.fetch.wants=0dd7574dce9e385c5c30540e6c15657adc6bdce9 git.fetch.haves.count=0 git.fetch.deepen=1 git.fetch.thin_pack=false git.fetch.ofs_delta=true git.protocol.version=2 git.pkt.frames=7 git.pkt.data=5 git.pkt.flush=1 git.pkt.delim=1 git.pkt.bytes=4273 git.pkt.payload.max=4173 git.sideband.band1.bytes=4173 git.sideband.band2.bytes=0 git.sideband.band3.bytes=0 git.pack.objects=11 git.pack.bytes=4173 git.fetch.wide.objects=11 git.fetch.wide.extra_bytes=3930 git.fetch.wide.blobs=0
fetchtree:0 · deepen 1020032 KiB · 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=32926 git.response.cache=HIT git.response.duration_ms=4 git.fetch.filter=tree:0 git.fetch.wants=0dd7574dce9e385c5c30540e6c15657adc6bdce9 git.fetch.haves.count=0 git.fetch.deepen=10 git.fetch.thin_pack=false git.fetch.ofs_delta=true git.protocol.version=2 git.pkt.frames=22 git.pkt.data=20 git.pkt.flush=1 git.pkt.delim=1 git.pkt.bytes=32926 git.pkt.payload.max=32046 git.sideband.band1.bytes=32046 git.sideband.band2.bytes=0 git.sideband.band3.bytes=0 git.pack.objects=80 git.pack.bytes=32046 git.pack.ofs_delta=36 git.pack.ref_delta=0 git.pack.chain.max=2 git.pack.trailer=cb0bad5d7ffc514895d8b21c4dd470327f90bc91 git.pack.full=44Open pack map
fetchtree:02001.8 KiB · 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=fb03183b7909876778f740d196d7516811003517Open 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=e0a52f164f79506da6b0dcc275ed62911f5383bfOpen pack map
fetchtree:0200139 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=139 git.response.cache=HIT git.response.duration_ms=3 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=a35549813b2a01d473947912b5773e993ce7c2e2Open pack map
fetchtree:0200638 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=638 git.response.cache=HIT git.response.duration_ms=3 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=f2a6246e346c2fa34e54ecb04cb1dd1c524f65bcOpen pack map
fetch2005.6 KiB215 ms
git.upload-pack fetch http.response.status_code=200 git.upstream.cf_ray=- git.upstream.phase=fetch git.upstream.dur_ms=215 git.response.bytes=5767 git.response.cache=MISS git.response.duration_ms=215 git.fetch.wants=71f88cb1331f38b4d6392631e05f4b1e3e15281a 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=5767 git.pkt.payload.max=5740 git.sideband.band1.bytes=5740 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
- a5e2d98fcdca14c2
- Request
- 9ec93962…
- 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