//go:build !integration
package sync
import (
"context"
"encoding/json"
"errors"
"fmt"
"io"
"os"
"path/filepath"
"testing"
"time"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"go.uber.org/mock/gomock"
"gitlab.com/gitlab-org/cli/internal/commands/govern/internal/fallbacksync"
"gitlab.com/gitlab-org/cli/internal/commands/govern/internal/syncstate"
)
// claudeTurns returns a Claude Code transcript of sess-1 with a prompt and a tool call
// at each time, numbered from 0.
func claudeTurns(t *testing.T, at ...time.Time) []byte {
t.Helper()
const sessionID = "sess-1"
var records []any
for i, ts := range at {
stamp := ts.UTC().Format(time.RFC3339Nano)
records = append(records,
map[string]any{
"type": "user", "sessionId": sessionID, "uuid": fmt.Sprintf("u-%d", i), "promptId": fmt.Sprintf("p-%d", i),
"timestamp": stamp, "message": map[string]any{"role": "user", "content": fmt.Sprintf("prompt %d", i)},
},
map[string]any{
"type": "assistant", "sessionId": sessionID, "timestamp": stamp,
"message": map[string]any{"content": []map[string]any{{"type": "tool_use", "id": fmt.Sprintf("toolu_%d", i), "name": "Bash"}}},
},
)
}
return []byte(jsonLines(t, records...))
}
// uploadedActivity names the prompts and tool calls in events.
func uploadedActivity(events []auditEventRequest) []string {
var got []string
for _, e := range events {
switch e.EventName {
case eventUserInput:
got = append(got, fmt.Sprint("prompt: ", e.Details["content"]))
case eventToolInvoked:
got = append(got, fmt.Sprint("tool: ", e.Details["tool_call_id"]))
}
}
return got
}
func setUpAgent(t *testing.T, agent string, setup fallbacksync.AgentSetup) {
t.Helper()
require.NoError(t, fallbacksync.SetAgentSetups(fallbacksync.AgentSetups{agent: setup}))
}
func TestDropBefore(t *testing.T) {
t.Parallel()
since := time.Date(2026, 11, 20, 10, 0, 0, 0, time.UTC)
before, after := since.Add(-time.Hour), since.Add(time.Hour)
full := func() *sessionData {
return &sessionData{
Goal: "first",
StartedAt: before,
Prompts: []prompt{{ID: "p-0", Text: "first", Timestamp: before}, {ID: "p-1", Text: "second", Timestamp: after}},
ToolCalls: []toolCall{{ID: "toolu_0", Timestamp: before}, {ID: "toolu_1", Timestamp: since}},
// toolu_0 spans since: it is called before since and ends after.
ToolResults: []toolResult{{CallID: "toolu_0", Timestamp: after}, {CallID: "toolu_1", Timestamp: after}},
Responses: []llmResponse{{ID: "msg_0", Timestamp: before}, {ID: "msg_1", Timestamp: after}},
}
}
tests := map[string]struct {
data *sessionData
since time.Time
want *sessionData
}{
"no limit": {data: full(), want: full()},
"session started before since": {
data: full(),
since: since,
want: &sessionData{
Prompts: []prompt{{ID: "p-1", Text: "second", Timestamp: after}},
ToolCalls: []toolCall{{ID: "toolu_1", Timestamp: since}},
ToolResults: []toolResult{{CallID: "toolu_1", Timestamp: after}},
Responses: []llmResponse{{ID: "msg_1", Timestamp: after}},
},
},
"nothing after since": {
data: &sessionData{Goal: "first", StartedAt: before, Prompts: []prompt{{ID: "p-0", Text: "first", Timestamp: before}}},
since: since,
want: &sessionData{Prompts: []prompt{}},
},
"goal without prompts, as from OpenCode": {
data: &sessionData{Goal: "fix the flaky test", StartedAt: before},
since: since,
want: &sessionData{},
},
"session started after since": {
data: &sessionData{Goal: "second", StartedAt: after, Prompts: []prompt{{ID: "p-1", Text: "second", Timestamp: after}}},
since: since,
want: &sessionData{Goal: "second", StartedAt: after, Prompts: []prompt{{ID: "p-1", Text: "second", Timestamp: after}}},
},
"goal kept on a later read, which sets none": {
data: &sessionData{Prompts: []prompt{{ID: "p-0", Text: "first", Timestamp: before}, {ID: "p-1", Text: "second", Timestamp: after}}},
since: since,
want: &sessionData{Prompts: []prompt{{ID: "p-1", Text: "second", Timestamp: after}}},
},
}
for name, tc := range tests {
t.Run(name, func(t *testing.T) {
t.Parallel()
tc.data.dropBefore(tc.since)
assert.Equal(t, tc.want.Goal, tc.data.Goal)
assert.Equal(t, tc.want.StartedAt, tc.data.StartedAt)
assert.ElementsMatch(t, tc.want.Prompts, tc.data.Prompts)
assert.ElementsMatch(t, tc.want.ToolCalls, tc.data.ToolCalls)
assert.ElementsMatch(t, tc.want.ToolResults, tc.data.ToolResults)
assert.ElementsMatch(t, tc.want.Responses, tc.data.Responses)
})
}
}
func TestRunSync_UploadsClaudeCodeActivityFromSetup(t *testing.T) {
now := time.Now()
tests := map[string]struct {
setup *fallbacksync.AgentSetup
turns []time.Time
args string
want []string
// wantGoal is empty when no session is created.
wantGoal string
}{
"session started after setup": {
setup: &fallbacksync.AgentSetup{SetUpAt: now.Add(-2 * time.Hour)},
turns: []time.Time{now.Add(-time.Hour), now.Add(-time.Minute)},
want: []string{"prompt: prompt 0", "prompt: prompt 1", "tool: toolu_0", "tool: toolu_1"},
wantGoal: "prompt 0",
},
"session from before setup, resumed": {
setup: &fallbacksync.AgentSetup{SetUpAt: now.Add(-time.Hour)},
turns: []time.Time{now.Add(-3 * time.Hour), now.Add(-time.Minute)},
want: []string{"prompt: prompt 1", "tool: toolu_1"},
wantGoal: "prompt 1",
},
"history": {
setup: &fallbacksync.AgentSetup{SetUpAt: now.Add(-time.Hour), History: true},
turns: []time.Time{now.Add(-3 * time.Hour), now.Add(-time.Minute)},
want: []string{"prompt: prompt 0", "prompt: prompt 1", "tool: toolu_0", "tool: toolu_1"},
wantGoal: "prompt 0",
},
"set up before glab recorded when": {
turns: []time.Time{now.Add(-3 * time.Hour), now.Add(-time.Minute)},
want: []string{"prompt: prompt 0", "prompt: prompt 1", "tool: toolu_0", "tool: toolu_1"},
wantGoal: "prompt 0",
},
"session from before setup, ended": {
setup: &fallbacksync.AgentSetup{SetUpAt: now.Add(-time.Hour)},
turns: []time.Time{now.Add(-3 * time.Hour)},
args: " --complete",
},
}
for name, tc := range tests {
t.Run(name, func(t *testing.T) {
env := newSyncAllEnv(t, true)
t.Setenv("CLAUDE_CODE_SESSION_ID", "sess-1")
if tc.setup != nil {
setUpAgent(t, "claude-code", *tc.setup)
}
cwd, err := currentCWD()
require.NoError(t, err)
path, err := transcriptPath("sess-1", cwd)
require.NoError(t, err)
require.NoError(t, os.MkdirAll(filepath.Dir(path), 0o755))
require.NoError(t, os.WriteFile(path, claudeTurns(t, tc.turns...), 0o644))
_, err = env.exec("-R my-group/my-project --silent" + tc.args)
require.NoError(t, err)
assert.ElementsMatch(t, tc.want, uploadedActivity(env.fake.events))
if tc.wantGoal == "" {
assert.Empty(t, env.fake.sessionRequests, "a session with nothing to upload is not created on GitLab")
assert.Zero(t, env.fake.completed)
return
}
require.Len(t, env.fake.sessionRequests, 1)
assert.Equal(t, tc.wantGoal, env.fake.sessionRequests[0].Goal)
})
}
}
func TestRunSync_UnreadableAgentSetupsUploadNothing(t *testing.T) {
env := newSyncAllEnv(t, true)
t.Setenv("CLAUDE_CODE_SESSION_ID", "sess-1")
writeHookTranscript(t, "sess-1", "toolu_1")
path := filepath.Join(env.home, "glab", "gaig", "agent-setups.json")
require.NoError(t, os.MkdirAll(filepath.Dir(path), 0o755))
require.NoError(t, os.WriteFile(path, []byte("{not json"), 0o600))
_, err := env.exec("-R my-group/my-project --silent")
require.ErrorContains(t, err, "could not tell which claude-code activity to upload")
assert.Empty(t, env.fake.sessionRequests)
_, err = env.exec("--all")
require.Error(t, err)
assert.Empty(t, env.fake.sessionRequests)
assert.Contains(t, readStatus(t).Errors[0], "could not tell which activity to upload")
}
func TestSyncAll_UploadsClaudeCodeActivityFromSetup(t *testing.T) {
env := newSyncAllEnv(t, true)
now := time.Now()
setUpAgent(t, "claude-code", fallbacksync.AgentSetup{SetUpAt: now.Add(-time.Hour)})
path := env.writeClaudeSession(t, "sess-1", "my-group/my-project")
require.NoError(t, os.WriteFile(path, claudeTurns(t, now.Add(-3*time.Hour), now.Add(-time.Minute)), 0o644))
_, err := env.exec("--all")
require.NoError(t, err)
assert.ElementsMatch(t, []string{"prompt: prompt 1", "tool: toolu_1"}, uploadedActivity(env.fake.events))
assertCursorAtEnd(t, path)
}
func TestSyncAll_UploadsCodexActivityFromSetup(t *testing.T) {
now := time.Now()
remote := "git@" + testHost + ":my-group/my-project.git"
call := func(at time.Time, id string) map[string]any {
return codexItem(at.UTC().Format(time.RFC3339), map[string]any{"type": "function_call", "name": "exec_command", "call_id": id})
}
t.Run("session that runs across setup", func(t *testing.T) {
env := newSyncAllEnv(t, true)
require.NoError(t, fallbacksync.SetDiscoveredAgents([]string{"codex"}))
setUpAgent(t, "codex", fallbacksync.AgentSetup{SetUpAt: now.Add(-time.Hour)})
writeCodexRollout(t, env.home, "th-1", jsonLines(t,
codexSessionMetaLine("th-1", "/work", remote),
call(now.Add(-3*time.Hour), "call_before"),
call(now.Add(-time.Minute), "call_after"),
))
_, err := env.exec("--all")
require.NoError(t, err)
assert.Equal(t, []string{"tool: call_after"}, uploadedActivity(env.fake.events))
})
t.Run("session from before setup", func(t *testing.T) {
env := newSyncAllEnv(t, true)
require.NoError(t, fallbacksync.SetDiscoveredAgents([]string{"codex"}))
setUpAgent(t, "codex", fallbacksync.AgentSetup{SetUpAt: now.Add(-24 * time.Hour)})
old := now.Add(-3 * 24 * time.Hour)
path := writeCodexRollout(t, env.home, "th-1", jsonLines(t,
codexSessionMetaLine("th-1", "/work", remote),
call(old, "call_before"),
))
require.NoError(t, os.Chtimes(path, old, old))
for range 2 {
_, err := env.exec("--all")
require.NoError(t, err)
}
assert.Empty(t, env.fake.sessionRequests, "an idle session with only activity from before setup is not created on GitLab, to be completed")
meta, err := readSessionMeta("th-1")
require.NoError(t, err)
assert.Nil(t, meta.CompletedAt, "a session from before setup is kept, in case the user resumes it")
assertCursorAt(t, "th-1", fileSize(t, path))
f, err := os.OpenFile(path, os.O_APPEND|os.O_WRONLY, 0o644)
require.NoError(t, err)
_, err = f.WriteString(jsonLines(t,
map[string]any{"timestamp": now.UTC().Format(time.RFC3339), "type": "event_msg", "payload": map[string]any{"type": "user_message", "message": "a prompt after setup"}},
call(now, "call_resumed"),
))
require.NoError(t, errors.Join(err, f.Close()))
_, err = env.exec("--all")
require.NoError(t, err)
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")
require.Len(t, env.fake.sessionRequests, 1)
assert.Equal(t, "a prompt after setup", env.fake.sessionRequests[0].Goal, "the goal is the first prompt after setup")
assert.Empty(t, env.fake.sessionRequests[0].StartedAt, "the session started before setup")
})
t.Run("session from before setup that GitLab would not accept", func(t *testing.T) {
env := newSyncAllEnv(t, true)
require.NoError(t, fallbacksync.SetDiscoveredAgents([]string{"codex"}))
setUpAgent(t, "codex", fallbacksync.AgentSetup{SetUpAt: now.Add(-24 * time.Hour)})
old := now.Add(-100 * 24 * time.Hour)
path := writeCodexRollout(t, env.home, "th-1", jsonLines(t, codexSessionMetaLine("th-1", "/work", remote)))
require.NoError(t, os.Chtimes(path, old, old))
_, err := env.exec("--all")
require.NoError(t, err)
meta, err := readSessionMeta("th-1")
require.NoError(t, err)
assert.NotNil(t, meta.CompletedAt, "it is not checked again, as without setup")
})
}
func TestSyncAll_UploadsOpenCodeActivityFromSetup(t *testing.T) {
env := newSyncAllEnv(t, true)
now := time.UnixMilli(time.Now().UnixMilli())
setUpAgent(t, "opencode", fallbacksync.AgentSetup{SetUpAt: now.Add(-time.Hour)})
tool := func(id string, at time.Time) map[string]any {
return map[string]any{
"id": "prt_" + id, "type": "tool", "callID": id, "tool": "bash",
"state": map[string]any{"status": "completed", "time": map[string]any{"start": at.UnixMilli(), "end": at.UnixMilli()}},
}
}
export, err := json.Marshal(map[string]any{
"info": map[string]any{"id": "ses_1", "time": map[string]any{"created": now.Add(-3 * time.Hour).UnixMilli(), "updated": now.UnixMilli()}},
"messages": []map[string]any{
{
"info": map[string]any{"role": "user", "time": map[string]any{"created": now.Add(-3 * time.Hour).UnixMilli()}},
"parts": []map[string]any{{"id": "prt_goal", "type": "text", "text": "a prompt from before setup"}},
},
{
"info": map[string]any{"role": "assistant", "time": map[string]any{"created": now.UnixMilli()}},
"parts": []map[string]any{tool("call_before", now.Add(-3*time.Hour)), tool("call_after", now)},
},
},
})
require.NoError(t, err)
binary := filepath.Join(t.TempDir(), "opencode")
require.NoError(t, os.WriteFile(binary, nil, 0o755))
require.NoError(t, writeSessionMeta("ses_1", sessionMeta{AgentType: "opencode", PathWithNamespace: "my-group/my-project", Host: testHost, Transcript: binary}))
env.mExec.EXPECT().
ExecWithIO(gomock.Any(), binary, []string{"session", "export", "--standalone", "ses_1"}, nil, nil, gomock.Any(), gomock.Any()).
DoAndReturn(func(_ context.Context, _ string, _, _ []string, _ io.Reader, stdout, _ io.Writer) error {
_, err := stdout.Write(export)
return err
})
_, err = env.exec("--all")
require.NoError(t, err)
assert.Equal(t, []string{"tool: call_after"}, uploadedActivity(env.fake.events))
require.Len(t, env.fake.sessionRequests, 1)
assert.Empty(t, env.fake.sessionRequests[0].Goal, "the goal is a prompt from before setup")
assertCursorAt(t, "ses_1", 2)
}
func TestSyncAll_UploadsCursorActivityFromSetup(t *testing.T) {
now := time.Now()
promptLine := func(text string) string {
return jsonLines(t, map[string]any{"role": "user", "message": map[string]any{"content": []any{map[string]any{"type": "text", "text": "" + text + ""}}}})
}
tests := map[string]struct {
setUpAt time.Time
// snapshot starts the session where its transcript ends, as setup
// does for the Cursor sessions that exist when it runs.
snapshot bool
want []string
}{
"session created after setup": {
setUpAt: now.Add(-time.Hour),
want: []string{"prompt: earlier turn", "prompt: later turn"},
},
"session from before setup, resumed": {
setUpAt: now.Add(-time.Hour),
snapshot: true,
want: []string{"prompt: later turn"},
},
"session last active before setup, which setup did not see": {
setUpAt: now.Add(time.Minute),
want: []string{"prompt: later turn"},
},
}
for name, tc := range tests {
t.Run(name, func(t *testing.T) {
env := newSyncAllEnv(t, true)
require.NoError(t, fallbacksync.SetDiscoveredAgents([]string{"cursor"}))
setUpAgent(t, "cursor", fallbacksync.AgentSetup{SetUpAt: tc.setUpAt})
path := filepath.Join(t.TempDir(), "conv-1", "conv-1.jsonl")
require.NoError(t, os.MkdirAll(filepath.Dir(path), 0o755))
require.NoError(t, os.WriteFile(path, []byte(promptLine("earlier turn")), 0o644))
if tc.snapshot {
require.NoError(t, syncstate.StartAt("conv-1", fileSize(t, path)))
}
require.NoError(t, writeSessionMeta("conv-1", sessionMeta{AgentType: "cursor", PathWithNamespace: "my-group/my-project", Host: testHost, Transcript: path}))
_, err := env.exec("--all")
require.NoError(t, err)
f, err := os.OpenFile(path, os.O_APPEND|os.O_WRONLY, 0o644)
require.NoError(t, err)
_, err = f.WriteString(promptLine("later turn"))
require.NoError(t, errors.Join(err, f.Close()))
later := now.Add(3 * time.Minute)
require.NoError(t, os.Chtimes(path, later, later))
_, err = env.exec("--all")
require.NoError(t, err)
assert.Equal(t, tc.want, uploadedActivity(env.fake.events))
assertCursorAt(t, "conv-1", fileSize(t, path))
})
}
}
func fileSize(t *testing.T, path string) int64 {
t.Helper()
info, err := os.Stat(path)
require.NoError(t, err)
return info.Size()
}
func TestRunSync_SkipsClaudeCodeCompactionSummaries(t *testing.T) {
env := newSyncAllEnv(t, true)
t.Setenv("CLAUDE_CODE_SESSION_ID", "sess-1")
now := time.Now()
setUpAgent(t, "claude-code", fallbacksync.AgentSetup{SetUpAt: now.Add(-time.Hour)})
summary := func(field string) map[string]any {
return map[string]any{
"type": "user", "sessionId": "sess-1", "uuid": "u-" + field, "promptId": "p-" + field, field: true,
"timestamp": now.Add(-time.Minute).UTC().Format(time.RFC3339Nano),
"message": map[string]any{"role": "user", "content": "This session continues a conversation from before setup."},
}
}
cwd, err := currentCWD()
require.NoError(t, err)
path, err := transcriptPath("sess-1", cwd)
require.NoError(t, err)
content := append(claudeTurns(t, now.Add(-3*time.Hour)), jsonLines(t, summary("isCompactSummary"), summary("isVisibleInTranscriptOnly"))...)
content = append(content, jsonLines(t, map[string]any{
"type": "user", "sessionId": "sess-1", "uuid": "u-after", "promptId": "p-after",
"timestamp": now.UTC().Format(time.RFC3339Nano), "message": map[string]any{"role": "user", "content": "a prompt after setup"},
})...)
require.NoError(t, os.MkdirAll(filepath.Dir(path), 0o755))
require.NoError(t, os.WriteFile(path, content, 0o644))
_, err = env.exec("-R my-group/my-project --silent")
require.NoError(t, err)
assert.Equal(t, []string{"prompt: a prompt after setup"}, uploadedActivity(env.fake.events), "a summary of the conversation before setup is not uploaded")
require.Len(t, env.fake.sessionRequests, 1)
assert.Equal(t, "a prompt after setup", env.fake.sessionRequests[0].Goal)
}
func TestRunSync_CompleteOnlySessionsWithUploads(t *testing.T) {
tests := map[string]struct {
uploaded bool
wantCompleted int
}{
"nothing uploaded": {},
"uploaded before": {uploaded: true, wantCompleted: 1},
}
for name, tc := range tests {
t.Run(name, func(t *testing.T) {
env := newSyncAllEnv(t, true)
t.Setenv("CLAUDE_CODE_SESSION_ID", "sess-1")
setUpAgent(t, "claude-code", fallbacksync.AgentSetup{SetUpAt: time.Now().Add(-time.Hour)})
cwd, err := currentCWD()
require.NoError(t, err)
path, err := transcriptPath("sess-1", cwd)
require.NoError(t, err)
require.NoError(t, os.MkdirAll(filepath.Dir(path), 0o755))
line := jsonLines(t, map[string]any{"type": "system", "sessionId": "sess-1", "timestamp": time.Now().UTC().Format(time.RFC3339Nano)})
require.NoError(t, os.WriteFile(path, []byte(line), 0o644))
if tc.uploaded {
require.NoError(t, syncstate.WritePosition("sess-1", int64(len(line))))
}
_, err = env.exec("-R my-group/my-project --silent --complete")
require.NoError(t, err)
assert.Equal(t, tc.wantCompleted, env.fake.completed)
assert.Len(t, env.fake.sessionRequests, tc.wantCompleted, "a session with nothing uploaded is not created on GitLab")
})
}
}
func TestRunSync_CursorHookSessionFromBeforeSetup(t *testing.T) {
env := newSyncAllEnv(t, true)
require.NoError(t, fallbacksync.SetDiscoveredAgents([]string{"cursor"}))
setUpAgent(t, "cursor", fallbacksync.AgentSetup{SetUpAt: time.Now().Add(-time.Hour)})
path := writeCursorTranscript(t, env.home, "conv-1")
require.NoError(t, syncstate.StartAt("conv-1", fileSize(t, path)))
t.Setenv(hookAgentEnv, "cursor")
t.Setenv(hookSessionEnv, "conv-1")
t.Setenv(hookTranscriptEnv, path)
_, err := env.exec("--silent -R " + testHost + "/my-group/my-project")
require.NoError(t, err)
assert.Empty(t, env.fake.sessionRequests, "the turns from before setup are not uploaded")
f, err := os.OpenFile(path, os.O_APPEND|os.O_WRONLY, 0o644)
require.NoError(t, err)
_, err = f.WriteString(jsonLines(t, map[string]any{"role": "user", "message": map[string]any{"content": []any{map[string]any{"type": "text", "text": "a turn after setup"}}}}))
require.NoError(t, errors.Join(err, f.Close()))
_, err = env.exec("--silent -R " + testHost + "/my-group/my-project")
require.NoError(t, err)
assert.Equal(t, []string{"prompt: a turn after setup"}, uploadedActivity(env.fake.events))
require.Len(t, env.fake.sessionRequests, 1)
assert.Equal(t, "a turn after setup", env.fake.sessionRequests[0].Goal, "the goal is the first prompt after setup")
}
func TestRunSync_UnreadableCursorUploadsNothing(t *testing.T) {
env := newSyncAllEnv(t, true)
require.NoError(t, fallbacksync.SetDiscoveredAgents([]string{"cursor"}))
setUpAgent(t, "cursor", fallbacksync.AgentSetup{SetUpAt: time.Now().Add(-time.Hour)})
path := writeCursorTranscript(t, env.home, "conv-1")
cp, err := syncstate.PositionPath("conv-1")
require.NoError(t, err)
require.NoError(t, os.MkdirAll(filepath.Dir(cp), 0o755))
require.NoError(t, os.WriteFile(cp, []byte("not a number"), 0o644))
t.Setenv(hookAgentEnv, "cursor")
t.Setenv(hookSessionEnv, "conv-1")
t.Setenv(hookTranscriptEnv, path)
_, err = env.exec("--silent -R " + testHost + "/my-group/my-project")
require.ErrorContains(t, err, "could not read the sync position")
assert.Empty(t, env.fake.sessionRequests, "the transcript is not uploaded again from its beginning")
}
func TestRunSync_ClaudeCodeSessionFromBeforeSetupTakesItsGoalAfterSetup(t *testing.T) {
env := newSyncAllEnv(t, true)
t.Setenv("CLAUDE_CODE_SESSION_ID", "sess-1")
now := time.Now()
setUpAgent(t, "claude-code", fallbacksync.AgentSetup{SetUpAt: now.Add(-time.Hour)})
cwd, err := currentCWD()
require.NoError(t, err)
path, err := transcriptPath("sess-1", cwd)
require.NoError(t, err)
require.NoError(t, os.MkdirAll(filepath.Dir(path), 0o755))
require.NoError(t, os.WriteFile(path, claudeTurns(t, now.Add(-3*time.Hour)), 0o644))
old := now.Add(-2 * time.Hour)
require.NoError(t, os.Chtimes(path, old, old))
_, err = env.exec("-R my-group/my-project --silent")
require.NoError(t, err)
require.Empty(t, env.fake.sessionRequests)
f, err := os.OpenFile(path, os.O_APPEND|os.O_WRONLY, 0o644)
require.NoError(t, err)
_, err = f.WriteString(jsonLines(t, map[string]any{
"type": "user", "sessionId": "sess-1", "uuid": "u-after", "promptId": "p-after",
"timestamp": now.UTC().Format(time.RFC3339Nano), "message": map[string]any{"role": "user", "content": "a prompt after setup"},
}))
require.NoError(t, errors.Join(err, f.Close()))
_, err = env.exec("-R my-group/my-project --silent")
require.NoError(t, err)
assert.Equal(t, []string{"prompt: a prompt after setup"}, uploadedActivity(env.fake.events))
require.Len(t, env.fake.sessionRequests, 1)
assert.Equal(t, "a prompt after setup", env.fake.sessionRequests[0].Goal)
}
// A call that starts before setup and ends after it, such as the agent
// running glab minder setup, uploads neither the call nor its result.
func TestSync_LeavesOutResultsOfCallsFromBeforeSetup(t *testing.T) {
now := time.Now()
setUpAt := now.Add(-time.Hour)
before, after := setUpAt.Add(-time.Minute), setUpAt.Add(time.Minute)
t.Run("claude-code", func(t *testing.T) {
env := newSyncAllEnv(t, true)
t.Setenv("CLAUDE_CODE_SESSION_ID", "sess-1")
setUpAgent(t, "claude-code", fallbacksync.AgentSetup{SetUpAt: setUpAt})
call := func(id string) map[string]any {
return map[string]any{
"type": "assistant", "sessionId": "sess-1", "timestamp": before.UTC().Format(time.RFC3339Nano),
"message": map[string]any{"content": []map[string]any{{"type": "tool_use", "id": id, "name": "Bash"}}},
}
}
result := func(id string, failed bool) map[string]any {
return map[string]any{
"type": "user", "sessionId": "sess-1", "timestamp": after.UTC().Format(time.RFC3339Nano),
"message": map[string]any{"role": "user", "content": []map[string]any{{"type": "tool_result", "tool_use_id": id, "is_error": failed, "content": "tool output"}}},
}
}
cwd, err := currentCWD()
require.NoError(t, err)
path, err := transcriptPath("sess-1", cwd)
require.NoError(t, err)
require.NoError(t, os.MkdirAll(filepath.Dir(path), 0o755))
require.NoError(t, os.WriteFile(path, []byte(jsonLines(t, call("toolu_fails"), call("toolu_succeeds"), result("toolu_fails", true), result("toolu_succeeds", false))), 0o644))
_, err = env.exec("-R my-group/my-project --silent")
require.NoError(t, err)
assert.Empty(t, env.fake.events)
assert.Empty(t, env.fake.sessionRequests, "no session is created for the results alone")
})
t.Run("codex", func(t *testing.T) {
env := newSyncAllEnv(t, true)
require.NoError(t, fallbacksync.SetDiscoveredAgents([]string{"codex"}))
setUpAgent(t, "codex", fallbacksync.AgentSetup{SetUpAt: setUpAt})
writeCodexRollout(t, env.home, "th-1", jsonLines(t,
codexSessionMetaLine("th-1", "/work", "git@"+testHost+":my-group/my-project.git"),
codexItem(before.UTC().Format(time.RFC3339), map[string]any{"type": "function_call", "name": "exec_command", "call_id": "call_1"}),
codexItem(after.UTC().Format(time.RFC3339), map[string]any{"type": "function_call_output", "call_id": "call_1"}),
))
_, err := env.exec("--all")
require.NoError(t, err)
assert.Empty(t, env.fake.events)
assert.Empty(t, env.fake.sessionRequests, "no session is created for the result alone")
})
}
// appendLines appends JSONL records to the transcript at path.
func appendLines(t *testing.T, path string, records ...any) {
t.Helper()
f, err := os.OpenFile(path, os.O_APPEND|os.O_WRONLY, 0o644)
require.NoError(t, err)
_, err = f.WriteString(jsonLines(t, records...))
require.NoError(t, errors.Join(err, f.Close()))
}
// A call still running when glab skips a transcript from before setup ends in
// a later read, which must not upload its result without the call.
func TestSync_LeavesOutResultsOfCallsSkippedBeforeSetup(t *testing.T) {
now := time.Now()
setUpAt := now.Add(-24 * time.Hour)
old := now.Add(-3 * 24 * time.Hour)
stamp := func(at time.Time) string { return at.UTC().Format(time.RFC3339Nano) }
tests := map[string]struct {
agent string
sessionID string
// write writes a transcript from before setup with a running call,
// and returns its path.
write func(t *testing.T, env *syncAllEnv) string
// result and prompt are the records the agent adds after setup.
result, prompt any
args string
}{
"claude-code": {
agent: "claude-code",
sessionID: "sess-1",
write: func(t *testing.T, env *syncAllEnv) string {
t.Helper()
t.Setenv("CLAUDE_CODE_SESSION_ID", "sess-1")
cwd, err := currentCWD()
require.NoError(t, err)
path, err := transcriptPath("sess-1", cwd)
require.NoError(t, err)
require.NoError(t, os.MkdirAll(filepath.Dir(path), 0o755))
return path
},
result: map[string]any{
"type": "user", "sessionId": "sess-1", "timestamp": stamp(now),
"message": map[string]any{"role": "user", "content": []map[string]any{{"type": "tool_result", "tool_use_id": "toolu_0", "content": "tool output"}}},
},
prompt: map[string]any{
"type": "user", "sessionId": "sess-1", "uuid": "u-after", "promptId": "p-after",
"timestamp": stamp(now), "message": map[string]any{"role": "user", "content": "a prompt after setup"},
},
args: "-R my-group/my-project --silent",
},
"codex": {
agent: "codex",
sessionID: "th-1",
write: func(t *testing.T, env *syncAllEnv) string {
t.Helper()
require.NoError(t, fallbacksync.SetDiscoveredAgents([]string{"codex"}))
return writeCodexRollout(t, env.home, "th-1", jsonLines(t, codexSessionMetaLine("th-1", "/work", "git@"+testHost+":my-group/my-project.git")))
},
result: codexItem(stamp(now), map[string]any{"type": "function_call_output", "call_id": "toolu_0"}),
prompt: map[string]any{"timestamp": stamp(now), "type": "event_msg", "payload": map[string]any{"type": "user_message", "message": "a prompt after setup"}},
args: "--all",
},
}
for name, tc := range tests {
t.Run(name, func(t *testing.T) {
env := newSyncAllEnv(t, true)
setUpAgent(t, tc.agent, fallbacksync.AgentSetup{SetUpAt: setUpAt})
path := tc.write(t, env)
if tc.agent == "claude-code" {
require.NoError(t, os.WriteFile(path, claudeTurns(t, old), 0o644))
} else {
appendLines(t, path, codexItem(stamp(old), map[string]any{"type": "function_call", "name": "exec_command", "call_id": "toolu_0"}))
}
require.NoError(t, os.Chtimes(path, old, old))
_, err := env.exec(tc.args)
require.NoError(t, err)
assertCursorAt(t, tc.sessionID, fileSize(t, path))
appendLines(t, path, tc.result)
_, err = env.exec(tc.args)
require.NoError(t, err)
assert.Empty(t, env.fake.sessionRequests, "no session is created for the result alone")
appendLines(t, path, tc.prompt)
_, err = env.exec(tc.args)
require.NoError(t, err)
assert.Equal(t, []string{eventUserInput}, eventNames(env.fake.events))
})
}
}