Make checks green: vet lock-copies + flaky binary test (#29)

* Fix vet: stop copying BackfillProgress's mutex in snapshots

snapshot() and GetBackfillProgress() copied the whole struct including
its sync.Mutex. Split the data fields into a mutex-free
BackfillSnapshot embedded in BackfillProgress, and return that from
snapshot paths. go vet ./... is now clean.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* Fix flaky pair-command binary test

The test killed the process after 3s and then treated "exited non-zero
with no output" as a crash — but the timer kill itself produces exactly
that signature whenever pairing is quiet for 3s (it contacts Google
before printing the QR, so slow or sandboxed networks hit this every
time). Distinguish self-exit from grace-period kill: surviving the
grace period now passes outright.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

---------

Co-authored-by: Claude Fable 5 <noreply@anthropic.com>

Author: MaxGhenis

cmd/binary_test.go

@@ -48,23 +48,29 @@ func TestBuiltBinaryAcceptsPairCommand(t *testing.T) {
 		t.Fatalf("failed to start binary: %v", err)
 	}
 
-	// Wait briefly then kill — we just want to confirm it doesn't crash immediately
-	timer := time.AfterFunc(3*time.Second, func() {
-		cmd.Process.Kill()
-	})
-	defer timer.Stop()
-
-	err := cmd.Wait()
-	output := out.String()
+	// We only want to confirm the binary doesn't crash on startup. Surviving
+	// the grace period is a pass in itself: pairing may legitimately produce
+	// no output for a while (it contacts Google before printing the QR), so
+	// a kill-then-inspect approach can't tell a quiet healthy process from a
+	// crashed one.
+	done := make(chan error, 1)
+	go func() { done <- cmd.Wait() }()
 
-	// The process should either still be running (killed by our timer) or
-	// have produced some output before failing. A zero-length output + immediate
-	// exit means the binary crashed.
-	if err != nil && len(output) == 0 {
-		t.Errorf("binary exited immediately with no output: %v", err)
+	select {
+	case err := <-done:
+		// Exited on its own — fine if it said something first (e.g. a
+		// pairing error without a phone), a crash if it was silent.
+		if err != nil && len(out.String()) == 0 {
+			t.Errorf("binary exited immediately with no output: %v", err)
+		}
+	case <-time.After(3 * time.Second):
+		// Still running after the grace period: startup succeeded.
+		_ = cmd.Process.Kill()
+		<-done
 	}
 
-	// Should not contain panic traces
+	// Should not contain panic traces in either outcome.
+	output := out.String()
 	if strings.Contains(output, "panic:") || strings.Contains(output, "runtime error") {
 		t.Errorf("binary panicked:\n%s", output)
 	}

internal/app/app.go

@@ -33,9 +33,9 @@ const (
 
 const maxErrorDetails = 100
 
-// BackfillProgress tracks the current state of a deep backfill operation.
-type BackfillProgress struct {
-	mu                 sync.Mutex
+// BackfillSnapshot is a point-in-time copy of backfill progress, safe to
+// pass and marshal by value.
+type BackfillSnapshot struct {
 	Running            bool          `json:"running"`
 	Phase              BackfillPhase `json:"phase"`
 	FoldersScanned     int           `json:"folders_scanned"`
@@ -46,6 +46,12 @@ type BackfillProgress struct {
 	ErrorDetails       []string      `json:"error_details,omitempty"`
 }
 
+// BackfillProgress tracks the current state of a deep backfill operation.
+type BackfillProgress struct {
+	mu sync.Mutex
+	BackfillSnapshot
+}
+
 // reset clears all fields for a fresh backfill run.
 func (p *BackfillProgress) reset() {
 	p.mu.Lock()
@@ -95,10 +101,10 @@ func (p *BackfillProgress) add(conversations, messages, contacts, folders int) {
 	p.FoldersScanned += folders
 }
 
-func (p *BackfillProgress) snapshot() BackfillProgress {
+func (p *BackfillProgress) snapshot() BackfillSnapshot {
 	p.mu.Lock()
 	defer p.mu.Unlock()
-	cp := *p
+	cp := p.BackfillSnapshot
 	if len(p.ErrorDetails) > 0 {
 		cp.ErrorDetails = append([]string(nil), p.ErrorDetails...)
 	}
@@ -576,7 +582,7 @@ func (a *App) IsDeepBackfillRunning() bool {
 }
 
 // GetBackfillProgress returns a snapshot of the current backfill progress.
-func (a *App) GetBackfillProgress() BackfillProgress {
+func (a *App) GetBackfillProgress() BackfillSnapshot {
 	snap := a.BackfillProgress.snapshot()
 	// A shallow Backfill (startup catch-up) holds the same mutual-exclusion
 	// guard (backfillRunning) without populating the deep-backfill progress