//go:build !integration
package sync
import (
"bytes"
"cmp"
"context"
"encoding/json"
"errors"
"fmt"
"io"
"net/http"
"net/http/httptest"
"net/url"
"os"
osexec "os/exec"
"path/filepath"
"runtime"
"slices"
"strings"
gosync "sync"
"testing"
"time"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"go.uber.org/mock/gomock"
gitlab "gitlab.com/gitlab-org/api/client-go/v3"
gitlabtesting "gitlab.com/gitlab-org/api/client-go/v3/testing"
"gitlab.com/gitlab-org/cli/internal/api"
"gitlab.com/gitlab-org/cli/internal/cmdutils"
"gitlab.com/gitlab-org/cli/internal/commands/govern/internal/claudehooks"
"gitlab.com/gitlab-org/cli/internal/commands/govern/internal/fallbacksync"
"gitlab.com/gitlab-org/cli/internal/commands/govern/internal/opencodeplugin"
"gitlab.com/gitlab-org/cli/internal/commands/govern/internal/syncstate"
"gitlab.com/gitlab-org/cli/internal/config"
"gitlab.com/gitlab-org/cli/internal/glrepo"
"gitlab.com/gitlab-org/cli/internal/testing/cmdtest"
)
const testHost = "gitlab.example.com"
// fakeGitLab serves the project lookups and AI agent governance endpoints.
// It is an HTTP server rather than a client-go mock because the governance
// endpoints are raw requests that client-go has no service for.
type fakeGitLab struct {
mu gosync.Mutex
projects map[string]int64
projectLookups map[string]int
sessionsCreated []string
sessionRequests []sessionRequest
agentTypes []string
syncTypes []string
identityRequests int
eventBatches []int
events []auditEventRequest
eventsPosted int
completed int
// noSessionID makes session creation succeed without returning an ID.
noSessionID bool
// identityStatus and sessionStatus, when set, answer those endpoints with
// that HTTP status. GitLab answers 404 while AI agent governance is off
// for the project.
identityStatus int
sessionStatus int
// projectStatus, when set, answers lookups of unknown projects with that
// HTTP status instead of 404.
projectStatus int
// identityBody, when set, is the body sent with identityStatus.
identityBody string
// maxElements, when set, replaces the 5,000 JSON elements GitLab accepts
// in an audit events request.
maxElements int
// auditStatus, when set, answers audit event requests with that status.
auditStatus int
// tooLargeToolCall, when set, makes any audit events request with an event
// for that tool call exceed GitLab's JSON limits.
tooLargeToolCall string
auditRequests int
// rateLimited is how many audit event requests GitLab answers with 429
// before it accepts them.
rateLimited int
// retryAfter is the Retry-After GitLab sends with a 429, "0" if unset.
retryAfter string
// auditRejections counts the audit event requests over GitLab's limits.
auditRejections int
// badGateway is how many 502s each write endpoint ("session", "audit",
// "complete") answers with before it accepts requests.
badGateway map[string]int
}
// failWithBadGateway answers with a 502 if endpoint has one left to send.
func (f *fakeGitLab) failWithBadGateway(w http.ResponseWriter, endpoint string) bool {
if f.badGateway[endpoint] == 0 {
return false
}
f.badGateway[endpoint]--
writeStatus(w, http.StatusBadGateway)
return true
}
func (f *fakeGitLab) ServeHTTP(w http.ResponseWriter, r *http.Request) {
f.mu.Lock()
defer f.mu.Unlock()
w.Header().Set("Content-Type", "application/json")
path := r.URL.Path
project, isProjectLookup := strings.CutPrefix(r.URL.EscapedPath(), "/api/v4/projects/")
isProjectLookup = isProjectLookup && r.Method == http.MethodGet && !strings.Contains(project, "/")
switch {
case isProjectLookup:
name, _ := url.PathUnescape(project)
f.projectLookups[name]++
id, ok := f.projects[name]
if !ok && f.projectStatus != 0 {
writeStatus(w, f.projectStatus)
return
}
if !ok {
w.WriteHeader(http.StatusNotFound)
_, _ = io.WriteString(w, `{"message":"404 Project Not Found"}`)
return
}
_ = json.NewEncoder(w).Encode(map[string]any{"id": id, "path_with_namespace": name})
case r.Method == http.MethodPost && strings.HasSuffix(path, "/ai_agent/identities"):
f.identityRequests++
if f.identityStatus != 0 {
if f.identityBody != "" {
w.WriteHeader(f.identityStatus)
_, _ = io.WriteString(w, f.identityBody)
return
}
writeStatus(w, f.identityStatus)
return
}
_, _ = io.WriteString(w, `{"id": 7}`)
case r.Method == http.MethodPost && strings.HasSuffix(path, "/ai_agent/sessions"):
if f.failWithBadGateway(w, "session") {
return
}
if f.sessionStatus != 0 {
writeStatus(w, f.sessionStatus)
return
}
var body sessionRequest
_ = json.NewDecoder(r.Body).Decode(&body)
f.sessionsCreated = append(f.sessionsCreated, body.IdempotencyKey)
f.sessionRequests = append(f.sessionRequests, body)
f.agentTypes = append(f.agentTypes, body.AgentType)
f.syncTypes = append(f.syncTypes, body.SyncType)
if f.noSessionID {
_, _ = io.WriteString(w, `{}`)
return
}
_, _ = io.WriteString(w, `{"id": 99}`)
case r.Method == http.MethodPost && strings.HasSuffix(path, "/ai_agent/audit_events"):
f.auditRequests++
if f.failWithBadGateway(w, "audit") {
return
}
if f.auditRequests <= f.rateLimited {
// A Ratelimit-Reset in the past keeps the API client's own retries short.
w.Header().Set("Ratelimit-Reset", "1")
w.Header().Set("Retry-After", cmp.Or(f.retryAfter, "0"))
writeStatus(w, http.StatusTooManyRequests)
return
}
if f.auditStatus != 0 {
writeStatus(w, f.auditStatus)
return
}
raw, _ := io.ReadAll(r.Body)
var body auditEventsRequest
_ = json.Unmarshal(raw, &body)
if limit := f.exceededJSONLimit(raw, body); limit != "" {
f.auditRejections++
w.WriteHeader(http.StatusBadRequest)
_, _ = fmt.Fprintf(w, `{"error":%q}`, limit)
return
}
f.eventBatches = append(f.eventBatches, len(body.Events))
f.events = append(f.events, body.Events...)
f.eventsPosted += len(body.Events)
_, _ = io.WriteString(w, `{}`)
case r.Method == http.MethodPatch && strings.HasSuffix(path, "/ai_agent/sessions/99"):
if f.failWithBadGateway(w, "complete") {
return
}
f.completed++
_, _ = io.WriteString(w, `{}`)
default:
w.WriteHeader(http.StatusNotFound)
}
}
// exceededJSONLimit returns the error GitLab's JSON validation answers an
// audit events request with, or "" if the request is within its limits.
func (f *fakeGitLab) exceededJSONLimit(raw []byte, body auditEventsRequest) string {
maxElements := f.maxElements
if maxElements == 0 {
maxElements = 5000
}
var v any
_ = json.Unmarshal(raw, &v)
switch {
case len(body.Events) > maxEventsPerRequest:
return "Array parameter too large"
case 1+jsonElements(v) >= maxElements:
return "Too many total parameters"
case f.tooLargeToolCall != "" && slices.ContainsFunc(body.Events, func(e auditEventRequest) bool {
return e.Details["tool_call_id"] == f.tooLargeToolCall
}):
return "Hash parameter too large"
}
return ""
}
func toolIDs(n int) []string {
ids := make([]string, n)
for i := range ids {
ids[i] = fmt.Sprintf("toolu_%d", i)
}
return ids
}
func eventNames(events []auditEventRequest) []string {
names := make([]string, 0, len(events))
for _, e := range events {
names = append(names, e.EventName)
}
return names
}
func writeStatus(w http.ResponseWriter, code int) {
w.WriteHeader(code)
_, _ = fmt.Fprintf(w, `{"message":"%d %s"}`, code, http.StatusText(code))
}
type syncAllEnv struct {
home string
fake *fakeGitLab
exec cmdtest.CmdExecFunc
mExec *cmdtest.MockExecutor
}
func newSyncAllEnv(t *testing.T, hooksInstalled bool) *syncAllEnv {
t.Helper()
return newSyncAllEnvWithConfig(t, hooksInstalled, "hosts:\n "+testHost+":\n token: test-token\n")
}
// newSyncAllEnvWithConfig is newSyncAllEnv with glab configuration cfg.
func newSyncAllEnvWithConfig(t *testing.T, hooksInstalled bool, cfg string) *syncAllEnv {
t.Helper()
home := t.TempDir()
t.Setenv("HOME", home)
t.Setenv("GLAB_CONFIG_DIR", filepath.Join(home, "glab"))
t.Setenv("CLAUDE_CODE_SESSION_ID", "")
t.Setenv("OPENCODE_SESSION_ID", "")
t.Setenv(hookAgentEnv, "")
t.Setenv("XDG_CONFIG_HOME", "")
if hooksInstalled {
installOpenCodePlugin(t)
installClaudeStopHook(t)
}
fake := &fakeGitLab{projects: map[string]int64{"my-group/my-project": 42}, projectLookups: map[string]int{}}
server := httptest.NewServer(fake)
t.Cleanup(server.Close)
client, err := gitlab.NewClient("test-token", gitlab.WithBaseURL(server.URL+"/api/v4"), gitlab.WithOnlyIdempotentRetries())
require.NoError(t, err)
mExec := cmdtest.NewMockExecutor(gomock.NewController(t))
exec := cmdtest.SetupCmdForTest(
t,
NewCmd,
false,
cmdtest.WithApiClient(cmdtest.NewTestApiClient(t, nil, "test-token", testHost, api.WithGitLabClient(client))),
cmdtest.WithExecutor(mExec),
cmdtest.WithConfig(config.NewFromString(cfg)),
cmdtest.WithBuildInfo(api.BuildInfo{Version: "v1.2.3"}),
)
return &syncAllEnv{home: home, fake: fake, exec: exec, mExec: mExec}
}
// writeClaudeSession writes a Claude Code transcript containing one tool call
// per tool ID, and the metadata a hook records for it.
func (e *syncAllEnv) writeClaudeSession(t *testing.T, sessionID, project string, toolIDs ...string) string {
t.Helper()
content := claudeTranscriptLines(t, sessionID, toolIDs...)
path := filepath.Join(e.home, ".claude", "projects", "-work-"+sessionID, sessionID+".jsonl")
require.NoError(t, os.MkdirAll(filepath.Dir(path), 0o755))
require.NoError(t, os.WriteFile(path, content, 0o644))
require.NoError(t, writeSessionMeta(sessionID, sessionMeta{
AgentType: "claude-code",
PathWithNamespace: project,
Host: testHost,
Transcript: path,
}))
return path
}
func assertCursorAt(t *testing.T, sessionID string, want int64) {
t.Helper()
cursor, err := syncstate.ReadPosition(sessionID)
require.NoError(t, err)
assert.Equal(t, want, cursor)
}
// recordWaits makes opts' waits return at once, and returns the waits asked for.
func recordWaits(opts *options) *[]time.Duration {
var waits []time.Duration
opts.waitFor = func(_ context.Context, d time.Duration) error {
waits = append(waits, d)
return nil
}
return &waits
}
func assertCursorAtEnd(t *testing.T, path string) {
t.Helper()
info, err := os.Stat(path)
require.NoError(t, err)
assertCursorAt(t, strings.TrimSuffix(filepath.Base(path), ".jsonl"), info.Size())
}
func readStatus(t *testing.T) *fallbacksync.Status {
t.Helper()
status, err := fallbacksync.ReadStatus()
require.NoError(t, err)
return status
}
func TestSyncAll_UploadsRecordedSession(t *testing.T) {
env := newSyncAllEnv(t, true)
path := env.writeClaudeSession(t, "sess-1", "my-group/my-project", "toolu_1", "toolu_2")
_, err := env.exec("--all")
require.NoError(t, err)
assert.Equal(t, []string{"sess-1"}, env.fake.sessionsCreated)
assert.Equal(t, []string{"fallback"}, env.fake.syncTypes)
assert.Equal(t, 2, env.fake.eventsPosted)
assert.Zero(t, env.fake.completed)
info, err := os.Stat(path)
require.NoError(t, err)
cursor, err := syncstate.ReadPosition("sess-1")
require.NoError(t, err)
assert.Equal(t, info.Size(), cursor)
status := readStatus(t)
assert.Equal(t, 1, status.SessionsSynced)
assert.Equal(t, 2, status.EventsPosted)
assert.Empty(t, status.Errors)
}
func TestSyncAll_KeepsCursorWhenSessionHasNoID(t *testing.T) {
env := newSyncAllEnv(t, true)
env.fake.noSessionID = true
env.writeClaudeSession(t, "sess-1", "my-group/my-project", "toolu_1")
_, err := env.exec("--all")
require.NoError(t, err)
assert.Zero(t, env.fake.eventsPosted)
cursor, err := syncstate.ReadPosition("sess-1")
require.NoError(t, err)
assert.Zero(t, cursor, "unposted events must be retried on the next run")
status := readStatus(t)
require.Len(t, status.Errors, 1)
assert.Contains(t, status.Errors[0], "no session ID")
}
func TestSyncAll_RecordsFailedIdentityRegistration(t *testing.T) {
env := newSyncAllEnv(t, true)
env.fake.identityStatus = http.StatusForbidden
env.writeClaudeSession(t, "sess-1", "my-group/my-project", "toolu_1")
_, err := env.exec("--all")
require.NoError(t, err)
assert.Empty(t, env.fake.sessionsCreated, "GitLab requires an agent identity to create a session")
cursor, err := syncstate.ReadPosition("sess-1")
require.NoError(t, err)
assert.Zero(t, cursor, "the session is retried on the next run")
status := readStatus(t)
assert.Zero(t, status.SessionsSynced)
require.Len(t, status.Errors, 1)
assert.Contains(t, status.Errors[0], "session sess-1: could not register agent identity")
}
func TestSyncAll_RegistersIdentityOncePerProject(t *testing.T) {
env := newSyncAllEnv(t, true)
env.fake.identityStatus = http.StatusForbidden
for _, id := range []string{"sess-1", "sess-2", "sess-3"} {
env.writeClaudeSession(t, id, "my-group/my-project", "toolu_"+id)
}
_, err := env.exec("--all")
require.NoError(t, err)
assert.Equal(t, 1, env.fake.identityRequests, "a failed registration is not repeated for each session")
assert.Empty(t, env.fake.sessionsCreated)
assert.Len(t, readStatus(t).Errors, 1)
}
func TestSyncAll_RecordsFailedProjectOnce(t *testing.T) {
env := newSyncAllEnv(t, true)
env.fake.projectStatus = http.StatusForbidden
env.writeClaudeSession(t, "sess-1", "gone/project", "toolu_1")
env.writeClaudeSession(t, "sess-2", "gone/project", "toolu_2")
_, err := env.exec("--all")
require.NoError(t, err)
assert.Equal(t, 1, env.fake.projectLookups["gone/project"])
status := readStatus(t)
require.Len(t, status.Errors, 1)
assert.Contains(t, status.Errors[0], "gone/project")
}
func TestSyncAll_GovernanceNotEnabledIsNotAnError(t *testing.T) {
for _, tc := range []struct {
name string
identity int
session int
}{
{name: "identity registration", identity: http.StatusNotFound},
{name: "session creation", session: http.StatusNotFound},
} {
t.Run(tc.name, func(t *testing.T) {
env := newSyncAllEnv(t, true)
env.fake.identityStatus = tc.identity
env.fake.sessionStatus = tc.session
env.writeClaudeSession(t, "sess-1", "my-group/my-project", "toolu_1")
env.writeClaudeSession(t, "sess-2", "my-group/my-project", "toolu_2")
_, err := env.exec("--all")
require.NoError(t, err)
status := readStatus(t)
assert.Empty(t, status.Errors, "a project without governance is expected, not a failure")
assert.Equal(t, []string{testHost + "/my-group/my-project"}, status.GovernanceNotEnabled)
cursor, err := syncstate.ReadPosition("sess-1")
require.NoError(t, err)
assert.Zero(t, cursor, "the session syncs once governance is enabled")
})
}
}
func TestSyncAll_ProjectNotFoundIsNotAnError(t *testing.T) {
env := newSyncAllEnv(t, true)
env.writeClaudeSession(t, "sess-1", "gone/project", "toolu_1")
env.writeClaudeSession(t, "sess-2", "gone/project", "toolu_2")
env.writeClaudeSession(t, "sess-good", "my-group/my-project", "toolu_3")
_, err := env.exec("--all")
require.NoError(t, err)
status := readStatus(t)
assert.Empty(t, status.Errors, "a project the user can't see is expected, not a failure")
assert.Equal(t, []string{testHost + "/gone/project"}, status.ProjectNotFound)
assert.Equal(t, []string{"sess-good"}, env.fake.sessionsCreated)
assert.Equal(t, 1, env.fake.projectLookups["gone/project"])
for _, id := range []string{"sess-1", "sess-2"} {
meta, err := readSessionMeta(id)
require.NoError(t, err)
assert.Nil(t, meta.CompletedAt, "a 404 can mean no token was found, so the session is kept")
}
env.fake.projects["gone/project"] = 7
_, err = env.exec("--all")
require.NoError(t, err)
assert.ElementsMatch(t, []string{"sess-good", "sess-1", "sess-2"}, env.fake.sessionsCreated, "the sessions sync once the project is visible")
assert.Empty(t, readStatus(t).ProjectNotFound)
}
func TestSyncAll_RecordsHostsWithoutToken(t *testing.T) {
for _, name := range []string{"GITLAB_TOKEN", "GITLAB_ACCESS_TOKEN", "OAUTH_TOKEN", "JOB_TOKEN", "CI_JOB_TOKEN", "GLAB_ENABLE_CI_AUTOLOGIN"} {
t.Setenv(name, "")
}
env := newSyncAllEnvWithConfig(t, true, "hosts:\n "+testHost+":\n api_protocol: https\n")
env.writeClaudeSession(t, "sess-1", "my-group/my-project", "toolu_1")
env.writeClaudeSession(t, "sess-2", "gone/project", "toolu_2")
_, err := env.exec("--all")
require.NoError(t, err)
status := readStatus(t)
assert.Equal(t, []string{testHost + "/gone/project"}, status.ProjectNotFound, "the host is recorded because this lookup failed")
assert.Equal(t, []string{testHost}, status.NoToken, "each host is recorded once")
}
func TestSyncAll_HostWithoutTokenThatSyncsIsNotRecorded(t *testing.T) {
for _, name := range []string{"GITLAB_TOKEN", "GITLAB_ACCESS_TOKEN", "OAUTH_TOKEN", "JOB_TOKEN", "CI_JOB_TOKEN", "GLAB_ENABLE_CI_AUTOLOGIN"} {
t.Setenv(name, "")
}
env := newSyncAllEnvWithConfig(t, true, "hosts:\n "+testHost+":\n api_protocol: https\n")
env.writeClaudeSession(t, "sess-1", "my-group/my-project", "toolu_1")
_, err := env.exec("--all")
require.NoError(t, err)
status := readStatus(t)
assert.Equal(t, 1, status.SessionsSynced)
assert.Empty(t, status.NoToken, "nothing failed, so the missing token did not matter")
}
func TestSyncAll_HostWithTokenIsNotRecorded(t *testing.T) {
env := newSyncAllEnv(t, true)
env.writeClaudeSession(t, "sess-1", "my-group/my-project", "toolu_1")
_, err := env.exec("--all")
require.NoError(t, err)
assert.Empty(t, readStatus(t).NoToken)
}
func TestSyncAll_HostWithJobTokenIsNotRecorded(t *testing.T) {
for _, name := range []string{"GITLAB_TOKEN", "GITLAB_ACCESS_TOKEN", "OAUTH_TOKEN", "JOB_TOKEN", "CI_JOB_TOKEN", "GLAB_ENABLE_CI_AUTOLOGIN"} {
t.Setenv(name, "")
}
env := newSyncAllEnvWithConfig(t, true, "hosts:\n "+testHost+":\n api_protocol: https\n job_token: job-token\n")
env.writeClaudeSession(t, "sess-1", "my-group/my-project", "toolu_1")
_, err := env.exec("--all")
require.NoError(t, err)
assert.Empty(t, readStatus(t).NoToken)
}
func TestSyncAll_RejectedSessionErrorIsNotRepeated(t *testing.T) {
env := newSyncAllEnv(t, true)
env.fake.sessionStatus = http.StatusForbidden
env.writeClaudeSession(t, "sess-1", "my-group/my-project", "toolu_1")
_, err := env.exec("--all")
require.NoError(t, err)
status := readStatus(t)
require.Len(t, status.Errors, 1)
assert.Equal(t, 1, strings.Count(status.Errors[0], "could not create session"), status.Errors[0])
}
func TestSyncAll_PostsLargeSessionsInBatches(t *testing.T) {
env := newSyncAllEnv(t, true)
path := env.writeClaudeSession(t, "sess-1", "my-group/my-project", toolIDs(1201)...)
_, err := env.exec("--all")
require.NoError(t, err)
assert.Zero(t, env.fake.auditRejections, "every batch is within GitLab's limits")
// Each of these events is 19 JSON elements, so 236 fit in maxElementsPerRequest.
assert.Equal(t, []int{236, 236, 236, 236, 236, 21}, env.fake.eventBatches)
assert.Equal(t, 1201, env.fake.eventsPosted)
assertCursorAtEnd(t, path)
}
func TestSyncAll_SplitsBatchesOverGitLabLimits(t *testing.T) {
env := newSyncAllEnv(t, true)
env.fake.maxElements = 1000
path := env.writeClaudeSession(t, "sess-1", "my-group/my-project", toolIDs(300)...)
_, err := env.exec("--all")
require.NoError(t, err)
assert.NotZero(t, env.fake.auditRejections)
assert.Equal(t, 300, env.fake.eventsPosted)
assertCursorAtEnd(t, path)
}
func TestSyncAll_SkipsEventTooLargeForGitLab(t *testing.T) {
env := newSyncAllEnv(t, true)
env.fake.tooLargeToolCall = "toolu_7"
path := env.writeClaudeSession(t, "sess-1", "my-group/my-project", toolIDs(20)...)
_, err := env.exec("--all")
require.NoError(t, err)
assert.Equal(t, 19, env.fake.eventsPosted)
status := readStatus(t)
assert.Equal(t, 19, status.EventsPosted)
assert.Equal(t, 1, status.EventsTooLarge)
assert.Empty(t, status.Errors)
assertCursorAtEnd(t, path)
}
func TestSyncAll_KeepsEventsGitLabRejectsForAnotherReason(t *testing.T) {
env := newSyncAllEnv(t, true)
env.fake.auditStatus = http.StatusBadRequest
env.writeClaudeSession(t, "sess-1", "my-group/my-project", toolIDs(20)...)
_, err := env.exec("--all")
require.NoError(t, err)
assert.Equal(t, 1, env.fake.auditRequests, "the batch is not split")
status := readStatus(t)
assert.Zero(t, status.EventsTooLarge)
require.Len(t, status.Errors, 1)
assertCursorAt(t, "sess-1", 0)
}
func TestSyncAll_WaitsOutRateLimit(t *testing.T) {
env := newSyncAllEnv(t, true)
// More than the API client retries on its own, with Retry-After: 0.
env.fake.rateLimited = 7
path := env.writeClaudeSession(t, "sess-1", "my-group/my-project", toolIDs(3)...)
_, err := env.exec("--all")
require.NoError(t, err)
assert.Equal(t, 8, env.fake.auditRequests)
assert.Equal(t, 3, env.fake.eventsPosted)
assert.Empty(t, readStatus(t).Errors)
assertCursorAtEnd(t, path)
}
func TestSyncAll_RetriesWritesOnServerError(t *testing.T) {
env := newSyncAllEnv(t, true)
env.fake.badGateway = map[string]int{"session": 1, "audit": 1, "complete": 1}
path := env.writeClaudeSession(t, "sess-1", "my-group/my-project", "toolu_1")
idle := time.Now().Add(-idleCompleteAfter - time.Hour)
require.NoError(t, os.Chtimes(path, idle, idle))
_, err := env.exec("--all")
require.NoError(t, err)
assert.Empty(t, readStatus(t).Errors)
assert.Len(t, env.fake.sessionsCreated, 1)
assert.Equal(t, 1, env.fake.eventsPosted)
assert.Equal(t, 1, env.fake.completed)
}
func TestSyncAll_FailedAuditEventsErrorIsNotRepeated(t *testing.T) {
env := newSyncAllEnv(t, true)
env.fake.auditStatus = http.StatusForbidden
env.writeClaudeSession(t, "sess-1", "my-group/my-project", "toolu_1")
_, err := env.exec("--all")
require.NoError(t, err)
status := readStatus(t)
require.Len(t, status.Errors, 1)
assert.Equal(t, 1, strings.Count(status.Errors[0], "could not post audit events"), status.Errors[0])
}
func TestSyncAll_SkipsSessionsWithNothingNew(t *testing.T) {
env := newSyncAllEnv(t, true)
path := env.writeClaudeSession(t, "sess-1", "my-group/my-project", "toolu_1")
info, err := os.Stat(path)
require.NoError(t, err)
require.NoError(t, syncstate.WritePosition("sess-1", info.Size()))
_, err = env.exec("--all")
require.NoError(t, err)
assert.Empty(t, env.fake.projectLookups, "a session with nothing new must not reach the API")
assert.Empty(t, env.fake.sessionsCreated)
assert.Zero(t, readStatus(t).SessionsSynced)
}
func TestSyncAll_LooksUpEachProjectOnce(t *testing.T) {
env := newSyncAllEnv(t, true)
env.writeClaudeSession(t, "sess-1", "my-group/my-project", "toolu_1")
env.writeClaudeSession(t, "sess-2", "my-group/my-project", "toolu_2")
_, err := env.exec("--all")
require.NoError(t, err)
assert.ElementsMatch(t, []string{"sess-1", "sess-2"}, env.fake.sessionsCreated)
assert.Equal(t, 1, env.fake.projectLookups["my-group/my-project"])
assert.Equal(t, 2, readStatus(t).SessionsSynced)
}
func TestSyncAll_ContinuesPastFailedProjectLookup(t *testing.T) {
env := newSyncAllEnv(t, true)
env.fake.projectStatus = http.StatusForbidden
env.writeClaudeSession(t, "sess-bad", "gone/project", "toolu_1")
env.writeClaudeSession(t, "sess-good", "my-group/my-project", "toolu_2")
_, err := env.exec("--all")
require.NoError(t, err)
assert.Equal(t, []string{"sess-good"}, env.fake.sessionsCreated)
cursor, err := syncstate.ReadPosition("sess-bad")
require.NoError(t, err)
assert.Zero(t, cursor, "a failed session keeps its cursor so the next run retries it")
status := readStatus(t)
assert.Equal(t, 1, status.SessionsSynced)
require.Len(t, status.Errors, 1)
assert.Contains(t, status.Errors[0], "gone/project")
assert.Equal(t, 1, env.fake.projectLookups["gone/project"])
}
func TestSyncAll_CompletesIdleSession(t *testing.T) {
env := newSyncAllEnv(t, true)
path := env.writeClaudeSession(t, "sess-1", "my-group/my-project", "toolu_1")
idle := time.Now().Add(-idleCompleteAfter - time.Hour)
require.NoError(t, os.Chtimes(path, idle, idle))
_, err := env.exec("--all")
require.NoError(t, err)
assert.Equal(t, 1, env.fake.completed)
meta, err := readSessionMeta("sess-1")
require.NoError(t, err)
assert.NotNil(t, meta.CompletedAt)
assert.Equal(t, 1, readStatus(t).SessionsCompleted)
// A completed session is not synced again.
_, err = env.exec("--all")
require.NoError(t, err)
assert.Equal(t, 1, env.fake.completed)
}
func TestSyncAll_DoesNotCompleteActiveSession(t *testing.T) {
env := newSyncAllEnv(t, true)
env.writeClaudeSession(t, "sess-1", "my-group/my-project", "toolu_1")
_, err := env.exec("--all")
require.NoError(t, err)
assert.Zero(t, env.fake.completed)
meta, err := readSessionMeta("sess-1")
require.NoError(t, err)
assert.Nil(t, meta.CompletedAt)
}
func TestSyncAll_ForgetsSessionWithDeletedTranscript(t *testing.T) {
env := newSyncAllEnv(t, true)
path := env.writeClaudeSession(t, "sess-1", "my-group/my-project", "toolu_1")
require.NoError(t, syncstate.WritePosition("sess-1", 10))
require.NoError(t, os.Remove(path))
_, err := env.exec("--all")
require.NoError(t, err)
assert.Empty(t, env.fake.projectLookups)
assert.Empty(t, readStatus(t).Errors, "a deleted transcript is not an error")
_, err = readSessionMeta("sess-1")
require.ErrorIs(t, err, errNoSessionMeta)
cp, err := syncstate.PositionPath("sess-1")
require.NoError(t, err)
assert.NoFileExists(t, cp)
}
func TestSyncAll_RecordsUnreadableCursorsDir(t *testing.T) {
env := newSyncAllEnv(t, true)
gaigDir := filepath.Join(env.home, "glab", "gaig")
require.NoError(t, os.MkdirAll(gaigDir, 0o755))
require.NoError(t, os.WriteFile(filepath.Join(gaigDir, "cursors"), nil, 0o644))
_, err := env.exec("--all")
require.Error(t, err)
status := readStatus(t)
require.Len(t, status.Errors, 1)
assert.Contains(t, status.Errors[0], "could not read cursors directory")
}
func TestSyncAll_FindsTranscriptAfterDirectoryChange(t *testing.T) {
env := newSyncAllEnv(t, true)
path := env.writeClaudeSession(t, "sess-1", "my-group/my-project", "toolu_1")
meta, err := readSessionMeta("sess-1")
require.NoError(t, err)
meta.Transcript = filepath.Join(env.home, ".claude", "projects", "-elsewhere", "sess-1.jsonl")
require.NoError(t, writeSessionMeta("sess-1", *meta))
_, err = env.exec("--all")
require.NoError(t, err)
assert.Equal(t, 1, env.fake.eventsPosted)
meta, err = readSessionMeta("sess-1")
require.NoError(t, err)
assert.Equal(t, path, meta.Transcript, "the found path is recorded so later runs don't search again")
}
func TestSyncAll_ForgetsCompletedSessionOnceTranscriptDeleted(t *testing.T) {
env := newSyncAllEnv(t, true)
deleted := env.writeClaudeSession(t, "sess-deleted", "my-group/my-project", "toolu_1")
env.writeClaudeSession(t, "sess-kept", "my-group/my-project", "toolu_2")
require.NoError(t, markSessionCompleted("sess-deleted", time.Now()))
require.NoError(t, markSessionCompleted("sess-kept", time.Now()))
require.NoError(t, os.Remove(deleted))
_, err := env.exec("--all")
require.NoError(t, err)
_, err = readSessionMeta("sess-deleted")
require.ErrorIs(t, err, errNoSessionMeta)
_, err = readSessionMeta("sess-kept")
require.NoError(t, err, "a completed session can still be resumed while its transcript exists")
assert.Empty(t, env.fake.sessionsCreated, "completed sessions make no API calls")
assert.Empty(t, readStatus(t).Errors)
}
func TestSyncAll_KeepsCompletedOpenCodeSession(t *testing.T) {
env := newSyncAllEnv(t, true)
require.NoError(t, writeSessionMeta("ses_1", sessionMeta{
AgentType: "opencode",
PathWithNamespace: "my-group/my-project",
Host: testHost,
Transcript: "/opencode/that/was/removed",
}))
require.NoError(t, markSessionCompleted("ses_1", time.Now()))
// The executor has no expectations, so running opencode export fails the test.
_, err := env.exec("--all")
require.NoError(t, err)
meta, err := readSessionMeta("ses_1")
require.NoError(t, err)
assert.Equal(t, "/opencode/that/was/removed", meta.Transcript)
}
func installClaudeStopHook(t *testing.T) {
t.Helper()
hooks := map[string][]claudehooks.HookGroup{}
claudehooks.AddHook(hooks, "Stop", claudehooks.StopHookCommand)
hooksJSON, err := json.Marshal(hooks)
require.NoError(t, err)
settings, err := claudehooks.SettingsPath()
require.NoError(t, err)
require.NoError(t, claudehooks.WriteSettings(settings, map[string]json.RawMessage{"hooks": hooksJSON}))
}
func installOpenCodePlugin(t *testing.T) {
t.Helper()
path, err := opencodeplugin.Path()
require.NoError(t, err)
_, err = opencodeplugin.Install(path)
require.NoError(t, err)
}
func TestSyncAll_HooksRemovedPausesOnlyClaudeCode(t *testing.T) {
env := newSyncAllEnv(t, false)
installOpenCodePlugin(t)
env.writeClaudeSession(t, "sess-1", "my-group/my-project", "toolu_1")
env.writeOpenCodeSession(t, "ses_1", "call_1")
_, err := env.exec("--all")
require.NoError(t, err)
assert.Equal(t, []string{"ses_1"}, env.fake.sessionsCreated)
assert.Equal(t, []string{"claude-code: the glab Stop hook is not installed in ~/.claude/settings.json"}, readStatus(t).Paused)
}
func TestSyncAll_PluginRemovedPausesOnlyOpenCode(t *testing.T) {
env := newSyncAllEnv(t, true)
path, err := opencodeplugin.Path()
require.NoError(t, err)
require.NoError(t, os.Remove(path))
env.writeClaudeSession(t, "sess-1", "my-group/my-project", "toolu_1")
require.NoError(t, writeSessionMeta("ses_1", sessionMeta{
AgentType: "opencode",
PathWithNamespace: "my-group/my-project",
Host: testHost,
Transcript: "/bin/sh",
}))
// The executor has no expectations, so running opencode export fails the test.
_, err = env.exec("--all")
require.NoError(t, err)
assert.Equal(t, []string{"sess-1"}, env.fake.sessionsCreated)
assert.Equal(t, []string{"opencode: the glab OpenCode plugin is not installed in ~/.config/opencode/plugins/glab-govern.js"}, readStatus(t).Paused)
}
func TestOpenCodePausedReason(t *testing.T) {
t.Setenv("HOME", t.TempDir())
t.Setenv("XDG_CONFIG_HOME", "")
path, err := opencodeplugin.Path()
require.NoError(t, err)
require.NoError(t, os.MkdirAll(filepath.Dir(path), 0o755))
for name, content := range map[string]string{
"out of date": "// Installed by glab govern setup.\n// an older version\n",
"not installed by glab": "// the user's own plugin\n",
} {
require.NoError(t, os.WriteFile(path, []byte(content), 0o644))
reason, err := openCode{}.pausedReason()
require.NoError(t, err)
if name == "out of date" {
assert.Empty(t, reason, "an older plugin still syncs")
} else {
assert.Equal(t, "the glab OpenCode plugin is not installed in ~/.config/opencode/plugins/glab-govern.js", reason)
}
}
}
func TestOpenCodePausedReason_Windows(t *testing.T) {
reason, err := openCodePausedReason("windows")
require.NoError(t, err)
assert.Equal(t, "the OpenCode plugin is not supported on Windows", reason)
}
func TestSyncAll_UnsupportedAgent(t *testing.T) {
env := newSyncAllEnv(t, true)
require.NoError(t, writeSessionMeta("sess-1", sessionMeta{AgentType: "other-agent", PathWithNamespace: "my-group/my-project", Host: testHost}))
_, err := env.exec("--all")
require.NoError(t, err)
status := readStatus(t)
require.Len(t, status.Errors, 1)
assert.Contains(t, status.Errors[0], `unsupported agent "other-agent"`)
}
func TestSyncAll_FlagConflicts(t *testing.T) {
env := newSyncAllEnv(t, true)
_, err := env.exec("--all -R my-group/my-project")
require.Error(t, err)
assert.Contains(t, err.Error(), "none of the others can be")
_, err = env.exec("--all --complete")
require.Error(t, err)
assert.Contains(t, err.Error(), "none of the others can be")
}
// writeOpenCodeSession records an OpenCode session whose export contains one
// tool call per call ID.
func (e *syncAllEnv) writeOpenCodeSession(t *testing.T, sessionID string, callIDs ...string) {
t.Helper()
binary := filepath.Join(t.TempDir(), "opencode")
require.NoError(t, os.WriteFile(binary, nil, 0o755))
require.NoError(t, writeSessionMeta(sessionID, sessionMeta{
AgentType: "opencode",
PathWithNamespace: "my-group/my-project",
Host: testHost,
Transcript: binary,
}))
export := openCodeExportJSON(t, time.Now(), callIDs...)
e.mExec.EXPECT().
ExecWithIO(gomock.Any(), binary, []string{"session", "export", "--standalone", sessionID}, nil, nil, gomock.Any(), gomock.Any()).
DoAndReturn(func(_ context.Context, _ string, _, _ []string, _ io.Reader, stdout, _ io.Writer) error {
_, err := stdout.Write(export)
return err
})
}
func TestSyncAll_UploadsOpenCodeSession(t *testing.T) {
env := newSyncAllEnv(t, true)
env.writeOpenCodeSession(t, "ses_1", "call_1", "call_2")
_, err := env.exec("--all")
require.NoError(t, err)
assert.Equal(t, []string{"ses_1"}, env.fake.sessionsCreated)
require.Len(t, env.fake.sessionRequests, 1)
assert.Equal(t, "1.19.4", env.fake.sessionRequests[0].AgentVersion)
assert.Equal(t, []string{eventToolInvoked, eventToolInvoked, eventToolResponse, eventToolResponse}, eventNames(env.fake.events),
"completed OpenCode tool calls also record their result")
cursor, err := syncstate.ReadPosition("ses_1")
require.NoError(t, err)
assert.Equal(t, int64(2), cursor)
}
func TestRunSync_GovernanceNotEnabled(t *testing.T) {
env := newSyncAllEnv(t, true)
env.fake.identityStatus = http.StatusNotFound
t.Setenv("CLAUDE_CODE_SESSION_ID", "sess-1")
out, err := env.exec("-R my-group/my-project")
require.NoError(t, err)
assert.Contains(t, out.String(), governanceNotEnabled)
assert.Empty(t, out.Stderr(), "governance being off is not a failure")
}
func TestRunSync_GovernanceNotEnabledSilent(t *testing.T) {
env := newSyncAllEnv(t, true)
env.fake.identityStatus = http.StatusNotFound
t.Setenv("CLAUDE_CODE_SESSION_ID", "sess-1")
writeHookTranscript(t, "sess-1", "toolu_1")
out, err := env.exec("-R my-group/my-project --silent")
require.NoError(t, err)
assert.Empty(t, out.String(), "hooks run with --silent")
assert.Empty(t, out.Stderr())
assert.Empty(t, env.fake.sessionsCreated, "no session is created without an identity")
}
// writeHookTranscript writes a Claude Code transcript where a hook run from
// the current directory looks for it.
func writeHookTranscript(t *testing.T, sessionID string, toolIDs ...string) {
t.Helper()
cwd, err := currentCWD()
require.NoError(t, err)
path, err := transcriptPath(sessionID, cwd)
require.NoError(t, err)
require.NoError(t, os.MkdirAll(filepath.Dir(path), 0o755))
require.NoError(t, os.WriteFile(path, claudeTranscriptLines(t, sessionID, toolIDs...), 0o644))
}
// claudeTranscriptLines returns a Claude Code transcript with one Bash tool
// call for each ID.
func claudeTranscriptLines(t *testing.T, sessionID string, toolIDs ...string) []byte {
t.Helper()
var content []byte
for _, id := range toolIDs {
line, err := json.Marshal(map[string]any{
"type": "assistant",
"sessionId": sessionID,
"timestamp": time.Now().Format(time.RFC3339),
"version": "2.1.295",
"message": map[string]any{
"content": []map[string]any{{"type": "tool_use", "id": id, "name": "Bash"}},
},
})
require.NoError(t, err)
content = append(append(content, line...), '\n')
}
return content
}
func TestRunSync_SendsGlabAndAgentVersions(t *testing.T) {
env := newSyncAllEnv(t, true)
t.Setenv("CLAUDE_CODE_SESSION_ID", "sess-1")
writeHookTranscript(t, "sess-1", "toolu_1")
_, err := env.exec("-R my-group/my-project --silent")
require.NoError(t, err)
require.Len(t, env.fake.sessionRequests, 1)
assert.Equal(t, "1.2.3", env.fake.sessionRequests[0].GlabVersion, "sent as glab version prints it")
assert.Equal(t, "2.1.295", env.fake.sessionRequests[0].AgentVersion)
}
func TestSessionVersion(t *testing.T) {
t.Parallel()
assert.Equal(t, "2.1.295", sessionVersion(" 2.1.295\n"))
assert.Equal(t, strings.Repeat("é", maxVersionLength), sessionVersion(strings.Repeat("é", maxVersionLength)))
assert.Empty(t, sessionVersion(strings.Repeat("1", maxVersionLength+1)), "GitLab would reject the session")
assert.Empty(t, sessionVersion(" "))
}
func TestRunSync_IdentityErrorStillWarns(t *testing.T) {
env := newSyncAllEnv(t, true)
env.fake.identityStatus = http.StatusForbidden
t.Setenv("CLAUDE_CODE_SESSION_ID", "sess-1")
out, err := env.exec("-R my-group/my-project")
require.NoError(t, err)
assert.Contains(t, out.Stderr(), "warning: ")
assert.NotContains(t, out.String(), governanceNotEnabled, "only a 404 means governance is off")
}
func TestRunSync_RecordsMetaBeforeProjectLookup(t *testing.T) {
dir := t.TempDir()
t.Setenv("HOME", dir)
t.Setenv("GLAB_CONFIG_DIR", dir)
t.Setenv("CLAUDE_CODE_SESSION_ID", "sess-meta")
t.Setenv("OPENCODE_SESSION_ID", "")
installClaudeStopHook(t)
ctrl := gomock.NewController(t)
tc := gitlabtesting.NewTestClientWithCtrl(ctrl, gitlab.WithBaseURL("https://"+testHost))
tc.MockProjects.EXPECT().
GetProject(gomock.Any(), gomock.Any(), gomock.Any()).
Return(nil, nil, errors.New("project not found"))
exec := cmdtest.SetupCmdForTest(
t,
NewCmd,
false,
cmdtest.WithApiClient(cmdtest.NewTestApiClient(t, nil, "test-token", testHost, api.WithGitLabClient(tc.Client))),
)
_, err := exec("--silent -R my-group/my-project")
require.Error(t, err)
meta, err := readSessionMeta("sess-meta")
require.NoError(t, err)
assert.Equal(t, "claude-code", meta.AgentType)
assert.Equal(t, "my-group/my-project", meta.PathWithNamespace)
assert.Equal(t, "gitlab.com", meta.Host)
assert.Equal(t, "sess-meta.jsonl", filepath.Base(meta.Transcript))
}
// writeUnfoundOpenCodeSession records an OpenCode session that opencode export
// reports as not found, last recorded by a hook at recorded.
func (e *syncAllEnv) writeUnfoundOpenCodeSession(t *testing.T, sessionID string, recorded time.Time) {
t.Helper()
require.NoError(t, writeSessionMeta(sessionID, sessionMeta{
AgentType: "opencode",
PathWithNamespace: "my-group/my-project",
Host: testHost,
Transcript: "/bin/sh",
}))
mp, err := metaPath(sessionID)
require.NoError(t, err)
require.NoError(t, os.Chtimes(mp, recorded, recorded))
e.mExec.EXPECT().
ExecWithIO(gomock.Any(), "/bin/sh", []string{"session", "export", "--standalone", sessionID}, nil, nil, gomock.Any(), gomock.Any()).
DoAndReturn(func(_ context.Context, _ string, _, _ []string, _ io.Reader, _, stderr io.Writer) error {
_, _ = io.WriteString(stderr, "Error: Session not found: "+sessionID)
return errors.New("exit status 1")
})
}
func TestSyncAll_KeepsRecentOpenCodeSessionNotFound(t *testing.T) {
env := newSyncAllEnv(t, true)
env.writeUnfoundOpenCodeSession(t, "ses_1", time.Now())
_, err := env.exec("--all")
require.NoError(t, err)
_, err = readSessionMeta("ses_1")
require.NoError(t, err, "a recently recorded session must not be forgotten")
status := readStatus(t)
require.Len(t, status.Errors, 1)
assert.Contains(t, status.Errors[0], "the agent reports no such session")
}
func TestSyncAll_ForgetsLongUnfoundOpenCodeSession(t *testing.T) {
env := newSyncAllEnv(t, true)
env.writeUnfoundOpenCodeSession(t, "ses_1", time.Now().Add(-forgetUnfoundAfter-time.Hour))
_, err := env.exec("--all")
require.NoError(t, err)
_, err = readSessionMeta("ses_1")
require.ErrorIs(t, err, errNoSessionMeta)
assert.Empty(t, readStatus(t).Errors)
}
func TestSyncAll_ForgetsLongCompletedOpenCodeSession(t *testing.T) {
env := newSyncAllEnv(t, true)
require.NoError(t, writeSessionMeta("ses_old", sessionMeta{
AgentType: "opencode",
PathWithNamespace: "my-group/my-project",
Host: testHost,
Transcript: "/opencode/that/was/removed",
}))
require.NoError(t, markSessionCompleted("ses_old", time.Now().Add(-forgetUnfoundAfter-time.Hour)))
// The executor has no expectations: forgetting must not run opencode export.
_, err := env.exec("--all")
require.NoError(t, err)
_, err = readSessionMeta("ses_old")
require.ErrorIs(t, err, errNoSessionMeta)
cp, err := syncstate.PositionPath("ses_old")
require.NoError(t, err)
assert.NoFileExists(t, cp)
}
func TestOpenCode_RecordedFallsBackToPATH(t *testing.T) {
t.Parallel()
binary := func(t *testing.T, recorded string) string {
t.Helper()
src, _, err := openCode{}.recorded("ses_1", recorded)
require.NoError(t, err)
oc, ok := src.(*openCodeTranscript)
require.True(t, ok)
return oc.binary
}
assert.Empty(t, binary(t, "/opencode/that/was/removed"), "a missing recorded binary is looked up in PATH instead")
assert.Equal(t, "/bin/sh", binary(t, "/bin/sh"))
}
func TestOpenCodeTranscript_LastActivityWithoutUpdated(t *testing.T) {
t.Parallel()
newTranscript := func(export string) *openCodeTranscript {
src := &openCodeTranscript{sessionID: "ses_1"}
src.raw = []byte(export)
src.export = &openCodeExport{}
require.NoError(t, json.Unmarshal(src.raw, src.export))
return src
}
t.Run("falls back to the latest message", func(t *testing.T) {
t.Parallel()
src := newTranscript(`{"info":{"time":{"created":1000}},"messages":[{"info":{"role":"user","time":{"created":5000}},"parts":[]}]}`)
last, err := src.lastActivity(t.Context())
require.NoError(t, err)
assert.Equal(t, time.UnixMilli(5000), last)
})
t.Run("treats a session without timestamps as active", func(t *testing.T) {
t.Parallel()
src := newTranscript(`{"info":{},"messages":[]}`)
last, err := src.lastActivity(t.Context())
require.NoError(t, err)
assert.Less(t, time.Since(last), idleCompleteAfter)
})
}
func TestRunSync_RecordsOpenCodeMeta(t *testing.T) {
dir := t.TempDir()
t.Setenv("HOME", dir)
t.Setenv("GLAB_CONFIG_DIR", dir)
t.Setenv("CLAUDE_CODE_SESSION_ID", "")
t.Setenv("OPENCODE_SESSION_ID", "ses_meta")
installOpenCodePlugin(t)
ctrl := gomock.NewController(t)
tc := gitlabtesting.NewTestClientWithCtrl(ctrl, gitlab.WithBaseURL("https://"+testHost))
tc.MockProjects.EXPECT().
GetProject(gomock.Any(), gomock.Any(), gomock.Any()).
Return(nil, nil, errors.New("project not found"))
mExec := cmdtest.NewMockExecutor(ctrl)
mExec.EXPECT().LookPath("opencode").Return("/home/me/.opencode/bin/opencode", nil)
exec := cmdtest.SetupCmdForTest(
t,
NewCmd,
false,
cmdtest.WithApiClient(cmdtest.NewTestApiClient(t, nil, "test-token", testHost, api.WithGitLabClient(tc.Client))),
cmdtest.WithExecutor(mExec),
)
_, err := exec("--silent -R my-group/my-project")
require.Error(t, err)
meta, err := readSessionMeta("ses_meta")
require.NoError(t, err)
assert.Equal(t, "opencode", meta.AgentType)
assert.Equal(t, "/home/me/.opencode/bin/opencode", meta.Transcript)
}
func openCodeExportJSON(t *testing.T, updated time.Time, callIDs ...string) []byte {
t.Helper()
parts := []map[string]any{}
for _, id := range callIDs {
parts = append(parts, map[string]any{
"id": "prt_" + id,
"type": "tool",
"callID": id,
"tool": "bash",
"state": map[string]any{"status": "completed", "time": map[string]any{"start": updated.UnixMilli()}},
})
}
data, err := json.Marshal(map[string]any{
"info": map[string]any{
"id": "ses_1",
"version": "1.19.4",
"time": map[string]any{"created": updated.Add(-time.Hour).UnixMilli(), "updated": updated.UnixMilli()},
},
"messages": []map[string]any{
{
"info": map[string]any{"role": "user", "time": map[string]any{"created": updated.Add(-time.Hour).UnixMilli()}},
"parts": []map[string]any{{"id": "prt_goal", "type": "text", "text": "fix the flaky test"}},
},
{
"info": map[string]any{"role": "assistant", "time": map[string]any{"created": updated.UnixMilli()}},
"parts": parts,
},
},
})
require.NoError(t, err)
return data
}
func TestOpenCodeTranscript_Read(t *testing.T) {
t.Parallel()
updated := time.UnixMilli(time.Now().UnixMilli())
export := openCodeExportJSON(t, updated, "call_1", "call_2", "call_3")
ctrl := gomock.NewController(t)
mExec := cmdtest.NewMockExecutor(ctrl)
mExec.EXPECT().LookPath("opencode").Return("/usr/local/bin/opencode", nil)
// OpenCode 1 has no session export, so it prints its help and fails.
mExec.EXPECT().
ExecWithIO(gomock.Any(), "/usr/local/bin/opencode", []string{"session", "export", "--standalone", "ses_1"}, nil, nil, gomock.Any(), gomock.Any()).
DoAndReturn(func(_ context.Context, _ string, _, _ []string, _ io.Reader, _, stderr io.Writer) error {
_, _ = io.WriteString(stderr, "opencode session\n\nmanage sessions\n")
return errors.New("exit status 1")
}).
Times(1)
mExec.EXPECT().
ExecWithIO(gomock.Any(), "/usr/local/bin/opencode", []string{"export", "ses_1"}, nil, nil, gomock.Any(), gomock.Any()).
DoAndReturn(func(_ context.Context, _ string, _, _ []string, _ io.Reader, stdout, stderr io.Writer) error {
_, _ = io.WriteString(stderr, "Exporting session: ses_1\n")
_, err := stdout.Write(export)
return err
}).
Times(1)
src := &openCodeTranscript{sessionID: "ses_1", executor: mExec}
data, cursor, err := src.read(t.Context(), 0)
require.NoError(t, err)
assert.Equal(t, "fix the flaky test", data.Goal)
require.Len(t, data.ToolCalls, 3)
assert.Equal(t, "call_1", data.ToolCalls[0].ID)
assert.Equal(t, "bash", data.ToolCalls[0].Name)
assert.Equal(t, updated, data.ToolCalls[0].Timestamp)
assert.Equal(t, int64(3), cursor)
data, cursor, err = src.read(t.Context(), 2)
require.NoError(t, err)
assert.Empty(t, data.Goal)
require.Len(t, data.ToolCalls, 1)
assert.Equal(t, "call_3", data.ToolCalls[0].ID)
assert.Equal(t, int64(3), cursor)
last, err := src.lastActivity(t.Context())
require.NoError(t, err)
assert.Equal(t, updated, last)
sum, err := src.checksum(t.Context())
require.NoError(t, err)
assert.Len(t, sum, 64)
}
func TestOpenCodeTranscript_ExportFails(t *testing.T) {
t.Parallel()
export := func(t *testing.T, stderrText string, attempts int) error {
t.Helper()
mExec := cmdtest.NewMockExecutor(gomock.NewController(t))
mExec.EXPECT().
ExecWithIO(gomock.Any(), "/bin/opencode", gomock.Any(), nil, nil, gomock.Any(), gomock.Any()).
DoAndReturn(func(_ context.Context, _ string, _, _ []string, _ io.Reader, _, stderr io.Writer) error {
_, _ = io.WriteString(stderr, stderrText)
return errors.New("exit status 1")
}).
Times(attempts)
src := &openCodeTranscript{sessionID: "ses_1", binary: "/bin/opencode", executor: mExec}
_, cursor, err := src.read(t.Context(), 5)
assert.Equal(t, int64(5), cursor)
return err
}
t.Run("session not found", func(t *testing.T) {
t.Parallel()
err := export(t, "Error: Session not found: ses_1", 1)
require.ErrorIs(t, err, errAgentSessionNotFound)
require.NotErrorIs(t, err, errTranscriptNotFound, "the job may see a different OpenCode data directory, so this is not proof of deletion")
})
t.Run("other failure", func(t *testing.T) {
t.Parallel()
err := export(t, "Error: database is locked", len(openCodeExportCommands))
require.Error(t, err)
require.NotErrorIs(t, err, errTranscriptNotFound, "only a deleted session may make --all forget it")
assert.Contains(t, err.Error(), "database is locked")
})
}
func TestClaudeTranscript_Missing(t *testing.T) {
t.Parallel()
src := claudeTranscript{path: filepath.Join(t.TempDir(), "missing.jsonl")}
_, _, err := src.read(t.Context(), 0)
require.ErrorIs(t, err, errTranscriptNotFound)
}
func TestGoalFromText(t *testing.T) {
t.Parallel()
assert.Equal(t, "fix the bug", goalFromText("fix the bug"))
assert.Empty(t, goalFromText("ls"))
assert.Equal(t, strings.Repeat("a", 256)+"...", goalFromText(strings.Repeat("a", 300)))
assert.Empty(t, goalFromText(string(bytes.Repeat([]byte(" "), 2))+""))
}
// processExecutor runs commands the same way as the production executor in
// internal/cmdutils, so tests can observe real process and pipe behavior.
type processExecutor struct {
cmdutils.Executor
}
func (processExecutor) ExecWithIO(ctx context.Context, name string, args []string, env []string, stdin io.Reader, stdout, stderr io.Writer) error {
cmd := osexec.CommandContext(ctx, name, args...)
cmd.Env = env
cmd.Stdin = stdin
cmd.Stdout = stdout
cmd.Stderr = stderr
return cmd.Run()
}
// fakeOpenCode writes a shell script that stands in for opencode.
func fakeOpenCode(t *testing.T, script string) string {
t.Helper()
if runtime.GOOS == "windows" {
t.Skip("needs a POSIX shell")
}
path := filepath.Join(t.TempDir(), "opencode")
require.NoError(t, os.WriteFile(path, []byte("#!/bin/sh\n"+script+"\n"), 0o755))
return path
}
// openCodeV2ExportJSON returns an OpenCode 2 session export, shaped like a
// real one: a skipped first prompt, a completed shell call, a failed read, a
// call aborted before it ran, a call still streaming, and a block glab does not
// know.
func openCodeV2ExportJSON(t *testing.T, created time.Time) []byte {
t.Helper()
ms := func(d time.Duration) int64 { return created.Add(d).UnixMilli() }
data, err := json.Marshal(map[string]any{
"info": map[string]any{
"id": "ses_2",
"version": "2.0.0",
"location": map[string]any{"directory": "/home/me/project"},
"time": map[string]any{"created": ms(0), "updated": ms(10 * time.Second), "idle": ms(10 * time.Second)},
},
"messages": []map[string]any{
{"id": "msg_0", "type": "user", "time": map[string]any{"created": ms(0)}, "text": "/init"},
{"id": "msg_1", "type": "user", "time": map[string]any{"created": ms(0)}, "text": "explain each file", "files": []any{}, "agents": []any{}},
{
"id": "msg_2", "type": "assistant", "time": map[string]any{"created": ms(time.Second), "completed": ms(5 * time.Second)},
"content": []map[string]any{
{"type": "text", "text": "I'll look at the files."},
{
"type": "tool", "id": "call_ls", "name": "shell",
"state": map[string]any{"status": "completed", "input": map[string]any{"command": "ls -la"}, "content": []any{map[string]any{"type": "text"}}},
"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)},
},
{
"type": "tool", "id": "call_read", "name": "read",
"state": map[string]any{"status": "error", "input": map[string]any{"path": "missing.md"}, "error": map[string]any{"type": "unknown", "message": "File not found"}},
"time": map[string]any{"created": ms(3 * time.Second), "ran": ms(3 * time.Second), "completed": ms(3*time.Second + 50*time.Millisecond)},
},
{"type": "future-block", "content": "a shape glab does not know"},
{
"type": "tool", "id": "call_edit", "name": "edit",
"state": map[string]any{"status": "error", "input": map[string]any{}, "error": map[string]any{"type": "aborted"}},
"time": map[string]any{"created": ms(4 * time.Second)},
},
{
"type": "tool", "id": "call_write", "name": "write",
"state": map[string]any{"status": "streaming", "input": `{"path": "no`},
"time": map[string]any{"created": ms(5 * time.Second)},
},
},
},
{"id": "msg_4", "type": "idle", "time": map[string]any{"created": ms(9 * time.Second)}},
{"id": "msg_3", "type": "outcome", "outcome": map[string]any{"type": "completed"}, "time": map[string]any{"created": ms(10 * time.Second)}},
},
})
require.NoError(t, err)
return data
}
func TestOpenCodeTranscript_ReadOpenCode2(t *testing.T) {
t.Parallel()
created := time.UnixMilli(time.Now().Add(-time.Hour).UnixMilli())
export := openCodeV2ExportJSON(t, created)
mExec := cmdtest.NewMockExecutor(gomock.NewController(t))
mExec.EXPECT().
ExecWithIO(gomock.Any(), "/opt/opencode", []string{"session", "export", "--standalone", "ses_2"}, nil, nil, gomock.Any(), gomock.Any()).
DoAndReturn(func(_ context.Context, _ string, _, _ []string, _ io.Reader, stdout, _ io.Writer) error {
_, err := stdout.Write(export)
return err
}).
Times(1)
src := &openCodeTranscript{sessionID: "ses_2", binary: "/opt/opencode", executor: mExec}
data, cursor, err := src.read(t.Context(), 0)
require.NoError(t, err)
assert.Equal(t, "explain each file", data.Goal, "a command prompt is not the goal")
assert.Equal(t, created, data.StartedAt)
assert.Equal(t, "2.0.0", data.AgentVersion)
assert.Equal(t, int64(4), cursor)
require.Len(t, data.ToolCalls, 4)
assert.Equal(t, "call_ls", data.ToolCalls[0].ID)
assert.Equal(t, "shell", data.ToolCalls[0].Name)
assert.JSONEq(t, `{"command":"ls -la"}`, string(data.ToolCalls[0].Input))
assert.Equal(t, created.Add(2*time.Second+100*time.Millisecond), data.ToolCalls[0].Timestamp, "a call starts when it ran")
assert.Equal(t, created.Add(3*time.Second), data.ToolCalls[1].Timestamp)
assert.Equal(t, created.Add(4*time.Second), data.ToolCalls[2].Timestamp, "a call that never ran starts when it was created")
assert.Equal(t, "call_write", data.ToolCalls[3].ID)
assert.Nil(t, data.ToolCalls[3].Input, "a streaming call's partial input is not recorded")
require.Len(t, data.ToolResults, 3, "a streaming call has no result yet")
assert.False(t, data.ToolResults[0].IsError)
assert.Equal(t, 200*time.Millisecond, data.ToolResults[0].Duration)
assert.True(t, data.ToolResults[1].IsError)
assert.Equal(t, "File not found", data.ToolResults[1].Error)
assert.Equal(t, 50*time.Millisecond, data.ToolResults[1].Duration)
assert.Equal(t, "aborted", data.ToolResults[2].Error, "an error without a message reports its type")
data, cursor, err = src.read(t.Context(), 1)
require.NoError(t, err)
assert.Empty(t, data.Goal)
require.Len(t, data.ToolCalls, 3)
assert.Equal(t, "call_read", data.ToolCalls[0].ID)
assert.Equal(t, int64(4), cursor)
last, err := src.lastActivity(t.Context())
require.NoError(t, err)
assert.Equal(t, created.Add(10*time.Second), last)
}
func TestOpenCodeTranscript_SessionNotFoundStopsFallback(t *testing.T) {
t.Parallel()
mExec := cmdtest.NewMockExecutor(gomock.NewController(t))
mExec.EXPECT().
ExecWithIO(gomock.Any(), "/opt/opencode", []string{"session", "export", "--standalone", "ses_gone"}, nil, nil, gomock.Any(), gomock.Any()).
DoAndReturn(func(_ context.Context, _ string, _, _ []string, _ io.Reader, _, stderr io.Writer) error {
_, _ = io.WriteString(stderr, "Session not found: ses_gone\n")
return errors.New("exit status 1")
}).
Times(1)
src := &openCodeTranscript{sessionID: "ses_gone", binary: "/opt/opencode", executor: mExec}
_, _, err := src.read(t.Context(), 0)
require.ErrorIs(t, err, errAgentSessionNotFound)
}
func TestOpenCodeTranscript_ReportsBothExportFailures(t *testing.T) {
t.Parallel()
mExec := cmdtest.NewMockExecutor(gomock.NewController(t))
mExec.EXPECT().
ExecWithIO(gomock.Any(), "/opt/opencode", gomock.Any(), nil, nil, gomock.Any(), gomock.Any()).
DoAndReturn(func(_ context.Context, _ string, args []string, _ []string, _ io.Reader, _, stderr io.Writer) error {
_, _ = io.WriteString(stderr, "broken "+args[0])
return errors.New("exit status 2")
}).
Times(2)
src := &openCodeTranscript{sessionID: "ses_1", binary: "/opt/opencode", executor: mExec}
_, _, err := src.read(t.Context(), 0)
require.Error(t, err)
assert.Contains(t, err.Error(), "opencode session export --standalone ses_1: exit status 2: broken session")
assert.Contains(t, err.Error(), "opencode export ses_1: exit status 2: broken export")
}
func TestOpenCodeTranscript_ChildKeepingOutputOpen(t *testing.T) {
t.Parallel()
// The background sleep inherits stdout and outlives opencode. Reading
// stdout through a pipe would block until the sleep exits.
binary := fakeOpenCode(t, `sleep 30 &
printf '%s' '{"info":{"time":{"created":1000,"updated":2000}},"messages":[]}'`)
src := &openCodeTranscript{sessionID: "ses_1", binary: binary, executor: processExecutor{}}
start := time.Now()
last, err := src.lastActivity(t.Context())
require.NoError(t, err)
assert.Equal(t, time.UnixMilli(2000), last)
// Generous because process startup takes seconds under full-suite load on macOS.
assert.Less(t, time.Since(start), 15*time.Second, "export must not wait for opencode's child process")
}
func TestOpenCodeTranscript_ExportTimesOut(t *testing.T) {
t.Parallel()
binary := fakeOpenCode(t, `sleep 20 &
sleep 20`)
src := &openCodeTranscript{sessionID: "ses_1", binary: binary, executor: processExecutor{}, timeout: 300 * time.Millisecond}
start := time.Now()
_, _, err := src.read(t.Context(), 0)
require.Error(t, err)
assert.Contains(t, err.Error(), "timed out after 300ms")
assert.Less(t, time.Since(start), 5*time.Second, "a hung export must not block the run")
}
func TestOpenCodeTranscript_TimeoutStopsFallback(t *testing.T) {
t.Parallel()
mExec := cmdtest.NewMockExecutor(gomock.NewController(t))
mExec.EXPECT().
ExecWithIO(gomock.Any(), "/opt/opencode", gomock.Any(), nil, nil, gomock.Any(), gomock.Any()).
DoAndReturn(func(ctx context.Context, _ string, _, _ []string, _ io.Reader, _, _ io.Writer) error {
<-ctx.Done()
return ctx.Err()
}).
Times(1)
src := &openCodeTranscript{sessionID: "ses_1", binary: "/opt/opencode", executor: mExec, timeout: 50 * time.Millisecond}
_, _, err := src.read(t.Context(), 0)
require.ErrorIs(t, err, errOpenCodeExportTimedOut)
}
// A hook must finish quickly, so unlike a sync run directly it does not wait
// out GitLab's rate limit.
func TestSyncSession_ByCaller(t *testing.T) {
tests := []struct {
name string
silent bool
want string
wantPosted int
}{
{name: "hook", silent: true, want: "hook", wantPosted: 0},
{name: "run directly", silent: false, want: "manual", wantPosted: 1},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
dir := t.TempDir()
t.Setenv("HOME", dir)
t.Setenv("GLAB_CONFIG_DIR", dir)
fake := &fakeGitLab{projects: map[string]int64{}, projectLookups: map[string]int{}, rateLimited: 7}
server := httptest.NewServer(fake)
t.Cleanup(server.Close)
gl, err := gitlab.NewClient("test-token", gitlab.WithBaseURL(server.URL+"/api/v4"))
require.NoError(t, err)
client := cmdtest.NewTestApiClient(t, nil, "test-token", testHost, api.WithGitLabClient(gl))
line, err := json.Marshal(map[string]any{
"type": "assistant",
"sessionId": "sess-1",
"timestamp": time.Now().Format(time.RFC3339),
"message": map[string]any{
"content": []map[string]any{{"type": "tool_use", "id": "toolu_1", "name": "Bash"}},
},
})
require.NoError(t, err)
path := filepath.Join(dir, "sess-1.jsonl")
require.NoError(t, os.WriteFile(path, append(line, '\n'), 0o644))
ios, _, _, _ := cmdtest.TestIOStreams()
opts := &options{io: ios, silent: tt.silent, agentType: "claude-code"}
recordWaits(opts)
dest := target{client: client, project: &gitlab.Project{ID: 42}}
require.NoError(t, syncSession(t.Context(), dest, "sess-1", claudeTranscript{path: path}, opts))
assert.Equal(t, []string{tt.want}, fake.syncTypes)
assert.Equal(t, tt.wantPosted, fake.eventsPosted)
})
}
}
func TestAuditEventPoster_RateLimit(t *testing.T) {
tests := []struct {
name string
opts options
limited int
retryAfter string
wantErr bool
wantWaits int
}{
{name: "waits", opts: options{all: true}, limited: 2, wantWaits: 2},
{name: "gives up after the most waits", opts: options{all: true}, limited: 100, wantErr: true, wantWaits: maxRateLimitWaits},
{
name: "gives up when the run has waited enough",
opts: options{all: true, rateLimitWaited: maxRateLimitWaitPerRun - time.Second},
limited: 1, retryAfter: "60", wantErr: true,
},
{name: "hook does not wait", opts: options{silent: true}, limited: 1, wantErr: true},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
waits := recordWaits(&tt.opts)
fake := &fakeGitLab{rateLimited: tt.limited, retryAfter: tt.retryAfter}
poster := newTestPoster(t, fake, &tt.opts)
_, err := poster.post(t.Context(), []auditEventRequest{{EventName: eventToolInvoked}})
if tt.wantErr {
assert.Equal(t, http.StatusTooManyRequests, gitlab.StatusCode(err))
} else {
require.NoError(t, err)
}
assert.Len(t, *waits, tt.wantWaits)
})
}
}
func TestAuditEventPoster_SplitsOnlyOutsideHooks(t *testing.T) {
tests := []struct {
name string
opts options
fallbackInstalled bool
wantErr bool
wantRequests int
}{
{name: "fallback sync splits", opts: options{all: true}, fallbackInstalled: true, wantRequests: 3},
{name: "manual sync splits", fallbackInstalled: true, wantRequests: 3},
{name: "hook leaves the batch for the fallback sync", opts: options{silent: true}, fallbackInstalled: true, wantErr: true, wantRequests: 1},
{name: "hook splits without the fallback sync", opts: options{silent: true}, wantRequests: 3},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
home := t.TempDir()
t.Setenv("HOME", home)
if tt.fallbackInstalled {
installFakeFallbackSync(t, home)
}
fake := &fakeGitLab{maxElements: 30}
poster := newTestPoster(t, fake, &tt.opts)
events := make([]auditEventRequest, 4)
for i := range events {
events[i] = auditEventRequest{EventName: eventToolInvoked, CloudEventID: fmt.Sprintf("event-%d", i)}
}
tooLarge, err := poster.post(t.Context(), events)
if tt.wantErr {
assert.True(t, requestTooLarge(err), err)
} else {
require.NoError(t, err)
assert.Equal(t, 4, fake.eventsPosted)
}
assert.Zero(t, tooLarge)
assert.Equal(t, tt.wantRequests, fake.auditRequests)
})
}
}
func newTestPoster(t *testing.T, fake *fakeGitLab, opts *options) auditEventPoster {
t.Helper()
server := httptest.NewServer(fake)
t.Cleanup(server.Close)
// WithoutRetries alone does not stop api.WithSafeRetries' per-request retries.
gl, err := gitlab.NewClient("test-token", gitlab.WithBaseURL(server.URL+"/api/v4"), gitlab.WithoutRetries(), gitlab.WithCustomRetryMax(0))
require.NoError(t, err)
ios, _, _, _ := cmdtest.TestIOStreams()
opts.io = ios
client := cmdtest.NewTestApiClient(t, nil, "test-token", testHost, api.WithGitLabClient(gl))
return auditEventPoster{client: client, projectID: 42, sessionID: 99, opts: opts}
}
func installFakeFallbackSync(t *testing.T, home string) {
t.Helper()
units, err := fallbacksync.Units(runtime.GOOS, home, fallbacksync.Job{})
if errors.Is(err, fallbacksync.ErrUnsupportedOS) {
t.Skip("the fallback sync is not available on this OS")
}
require.NoError(t, err)
require.NoError(t, os.MkdirAll(filepath.Dir(units[0].Path), 0o755))
require.NoError(t, os.WriteFile(units[0].Path, nil, 0o644))
}
func TestWriteCursor_DoesNotMoveBack(t *testing.T) {
t.Setenv("GLAB_CONFIG_DIR", t.TempDir())
require.NoError(t, syncstate.WritePosition("sess-1", 200))
require.NoError(t, syncstate.WritePosition("sess-1", 100))
assertCursorAt(t, "sess-1", 200)
require.NoError(t, syncstate.WritePosition("sess-1", 300))
assertCursorAt(t, "sess-1", 300)
}
func TestOptionsWait_StopsWhenCanceled(t *testing.T) {
ctx, cancel := context.WithCancel(t.Context())
cancel()
assert.ErrorIs(t, (&options{}).wait(ctx, time.Hour), context.Canceled)
}
// writeSessionWithoutProject records a Claude Code session the way a hook does
// in a folder without a GitLab remote.
func (e *syncAllEnv) writeSessionWithoutProject(t *testing.T, sessionID string) {
t.Helper()
path := e.writeClaudeSession(t, sessionID, "my-group/my-project", "toolu_1")
require.NoError(t, writeSessionMeta(sessionID, sessionMeta{AgentType: "claude-code", Transcript: path}))
}
const notSyncedWithoutRemote = "claude-code sessions in a folder where glab could not identify a GitLab project"
func TestSyncAll_ReportsSessionWithoutGitLabRemote(t *testing.T) {
env := newSyncAllEnv(t, true)
env.writeSessionWithoutProject(t, "sess-1")
_, err := env.exec("--all")
require.NoError(t, err)
assert.Empty(t, env.fake.sessionsCreated)
status := readStatus(t)
assert.Empty(t, status.Errors)
assert.Equal(t, []string{notSyncedWithoutRemote}, status.Skipped)
meta, err := readSessionMeta("sess-1")
require.NoError(t, err)
assert.Nil(t, meta.CompletedAt, "an active session is kept, so later runs still report it")
}
func TestSyncAll_CompletesIdleSessionWithoutGitLabRemote(t *testing.T) {
env := newSyncAllEnv(t, true)
env.writeSessionWithoutProject(t, "sess-1")
path, err := metaPath("sess-1")
require.NoError(t, err)
idle := time.Now().Add(-2 * idleCompleteAfter)
require.NoError(t, os.Chtimes(path, idle, idle))
_, err = env.exec("--all")
require.NoError(t, err)
assert.Empty(t, env.fake.sessionsCreated)
assert.Empty(t, readStatus(t).Errors)
meta, err := readSessionMeta("sess-1")
require.NoError(t, err)
assert.NotNil(t, meta.CompletedAt, "the record is kept until the agent can no longer resume the session")
}
func TestSyncAll_SessionResumedInGitLabProjectAfterIdleCompletionSkipsEarlierActivity(t *testing.T) {
env := newSyncAllEnv(t, true)
env.writeSessionWithoutProject(t, "sess-2")
path, err := metaPath("sess-2")
require.NoError(t, err)
idle := time.Now().Add(-2 * idleCompleteAfter)
require.NoError(t, os.Chtimes(path, idle, idle))
_, err = env.exec("--all")
require.NoError(t, err)
meta, err := readSessionMeta("sess-2")
require.NoError(t, err)
require.NotNil(t, meta.CompletedAt)
content, err := os.ReadFile(meta.Transcript)
require.NoError(t, err)
opts := &options{agentType: "claude-code", baseRepo: func() (glrepo.Interface, error) {
return glrepo.NewWithHost("my-group", "my-project", testHost), nil
}}
require.NoError(t, recordSessionMeta(t.Context(), opts, claudeCode{}, "sess-2", meta.Transcript))
assertCursorAt(t, "sess-2", int64(len(content)))
meta, err = readSessionMeta("sess-2")
require.NoError(t, err)
assert.Equal(t, "my-group/my-project", meta.PathWithNamespace)
assert.Nil(t, meta.CompletedAt, "the resumed session syncs again")
}
func TestSyncAll_ReportsSessionWithoutGitLabRemoteWhoseTranscriptIsGone(t *testing.T) {
env := newSyncAllEnv(t, true)
env.writeSessionWithoutProject(t, "sess-1")
meta, err := readSessionMeta("sess-1")
require.NoError(t, err)
require.NoError(t, os.Remove(meta.Transcript))
_, err = env.exec("--all")
require.NoError(t, err)
status := readStatus(t)
assert.Empty(t, status.Errors)
assert.Equal(t, []string{notSyncedWithoutRemote}, status.Skipped)
_, err = readSessionMeta("sess-1")
assert.NoError(t, err, "unlike a session with a project, it is not forgotten when its transcript is gone")
}