Cache OpenCode usage sessions

internal/opencodego/cache.go

@@ -0,0 +1,138 @@
+package opencodego
+
+import (
+	"encoding/json"
+	"errors"
+	"os"
+	"path/filepath"
+	"time"
+)
+
+const sessionCacheVersion = 1
+
+type cachedSessionFile struct {
+	Version  int             `json:"version"`
+	Sessions []cachedSession `json:"sessions"`
+}
+
+type cachedSession struct {
+	Label   string         `json:"label"`
+	Cookies []cachedCookie `json:"cookies"`
+}
+
+type cachedCookie struct {
+	Name      string    `json:"name"`
+	Value     string    `json:"value"`
+	ExpiresAt time.Time `json:"expires_at"`
+}
+
+func loadSessionCache(now time.Time) ([]browserSession, error) {
+	path, err := sessionCachePath()
+	if err != nil {
+		return nil, err
+	}
+	data, err := os.ReadFile(path)
+	if errors.Is(err, os.ErrNotExist) {
+		return nil, nil
+	}
+	if err != nil {
+		return nil, err
+	}
+	var cache cachedSessionFile
+	if err := json.Unmarshal(data, &cache); err != nil {
+		return nil, err
+	}
+	if cache.Version != sessionCacheVersion {
+		return nil, errors.New("unsupported OpenCode session cache version")
+	}
+
+	var sessions []browserSession
+	for _, cached := range cache.Sessions {
+		var cookies []browserCookie
+		for _, cookie := range cached.Cookies {
+			if cookie.Value == "" || cookie.ExpiresAt.IsZero() || !cookie.ExpiresAt.After(now) {
+				continue
+			}
+			if cookie.Name != "auth" && cookie.Name != "__Host-auth" {
+				continue
+			}
+			cookies = append(cookies, browserCookie{
+				name:      cookie.Name,
+				value:     cookie.Value,
+				expiresAt: cookie.ExpiresAt,
+			})
+		}
+		if len(cookies) > 0 {
+			sessions = append(sessions, browserSession{label: cached.Label, cookies: cookies})
+		}
+	}
+	return sessions, nil
+}
+
+func saveSessionCache(sessions []browserSession) error {
+	cache := cachedSessionFile{Version: sessionCacheVersion}
+	for _, session := range sessions {
+		var cookies []cachedCookie
+		for _, cookie := range session.cookies {
+			if cookie.value == "" || cookie.expiresAt.IsZero() {
+				continue
+			}
+			cookies = append(cookies, cachedCookie{
+				Name:      cookie.name,
+				Value:     cookie.value,
+				ExpiresAt: cookie.expiresAt,
+			})
+		}
+		if len(cookies) > 0 {
+			cache.Sessions = append(cache.Sessions, cachedSession{Label: session.label, Cookies: cookies})
+		}
+	}
+	if len(cache.Sessions) == 0 {
+		return nil
+	}
+
+	path, err := sessionCachePath()
+	if err != nil {
+		return err
+	}
+	if err := os.MkdirAll(filepath.Dir(path), 0o700); err != nil {
+		return err
+	}
+	if err := os.Chmod(filepath.Dir(path), 0o700); err != nil {
+		return err
+	}
+	temporary, err := os.CreateTemp(filepath.Dir(path), ".sessions-*.json")
+	if err != nil {
+		return err
+	}
+	temporaryPath := temporary.Name()
+	defer func() { _ = os.Remove(temporaryPath) }()
+	if err := temporary.Chmod(0o600); err != nil {
+		_ = temporary.Close()
+		return err
+	}
+	if err := json.NewEncoder(temporary).Encode(cache); err != nil {
+		_ = temporary.Close()
+		return err
+	}
+	if err := temporary.Sync(); err != nil {
+		_ = temporary.Close()
+		return err
+	}
+	if err := temporary.Close(); err != nil {
+		return err
+	}
+	return os.Rename(temporaryPath, path)
+}
+
+func sessionCachePath() (string, error) {
+	root := os.Getenv("XDG_CACHE_HOME")
+	if root == "" || !filepath.IsAbs(root) {
+		home, err := os.UserHomeDir()
+		if err != nil {
+			return "", err
+		}
+		root = filepath.Join(home, ".cache")
+	}
+	return filepath.Join(root, "prism", "opencode-go", "sessions.json"), nil
+}

internal/opencodego/cache_test.go

@@ -0,0 +1,181 @@
+package opencodego
+
+import (
+	"context"
+	"errors"
+	"os"
+	"path/filepath"
+	"testing"
+	"time"
+
+	"github.com/circlesac/prism-cli/internal/api"
+)
+
+func TestSessionCacheUsesXDGPathAndRestrictivePermissions(t *testing.T) {
+	root := t.TempDir()
+	t.Setenv("XDG_CACHE_HOME", root)
+	now := time.Date(2026, 8, 10, 0, 0, 0, 0, time.UTC)
+	sessions := []browserSession{{
+		label: "Chrome Default",
+		cookies: []browserCookie{{
+			name: "auth", value: "example-session", expiresAt: now.Add(time.Hour),
+		}},
+	}}
+	if err := saveSessionCache(sessions); err != nil {
+		t.Fatal(err)
+	}
+	path := filepath.Join(root, "prism", "opencode-go", "sessions.json")
+	fileInfo, err := os.Stat(path)
+	if err != nil {
+		t.Fatal(err)
+	}
+	directoryInfo, err := os.Stat(filepath.Dir(path))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if fileInfo.Mode().Perm() != 0o600 || directoryInfo.Mode().Perm() != 0o700 {
+		t.Fatalf("file mode = %o, directory mode = %o", fileInfo.Mode().Perm(), directoryInfo.Mode().Perm())
+	}
+	loaded, err := loadSessionCache(now)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(loaded) != 1 || loaded[0].label != "Chrome Default" || len(loaded[0].cookies) != 1 || loaded[0].cookies[0].value != "example-session" {
+		t.Fatalf("sessions = %#v", loaded)
+	}
+}
+
+func TestSessionCacheDropsExpiredAndNonPersistentCookies(t *testing.T) {
+	t.Setenv("XDG_CACHE_HOME", t.TempDir())
+	now := time.Date(2026, 8, 10, 0, 0, 0, 0, time.UTC)
+	if err := saveSessionCache([]browserSession{{
+		label: "Chrome Default",
+		cookies: []browserCookie{
+			{name: "auth", value: "expired", expiresAt: now.Add(-time.Minute)},
+			{name: "__Host-auth", value: "session-only"},
+		},
+	}}); err != nil {
+		t.Fatal(err)
+	}
+	loaded, err := loadSessionCache(now)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(loaded) != 0 {
+		t.Fatalf("sessions = %#v", loaded)
+	}
+}
+
+func TestFetchUsesCacheWithoutScanningBrowsers(t *testing.T) {
+	t.Setenv("XDG_CACHE_HOME", t.TempDir())
+	if err := saveSessionCache([]browserSession{{
+		label: "Chrome Default",
+		cookies: []browserCookie{{
+			name: "auth", value: "cached-session", expiresAt: time.Now().Add(time.Hour),
+		}},
+	}}); err != nil {
+		t.Fatal(err)
+	}
+
+	originalScan := scanBrowserSessions
+	originalFetch := fetchSessionUsage
+	defer func() {
+		scanBrowserSessions = originalScan
+		fetchSessionUsage = originalFetch
+	}()
+	scanBrowserSessions = func(time.Time) sessionScan {
+		t.Fatal("browser scan was called for a valid cached session")
+		return sessionScan{}
+	}
+	fetchSessionUsage = func(_ context.Context, _ time.Time, sessions []browserSession) (api.ProviderUsage, error) {
+		if len(sessions) != 1 || len(sessions[0].cookies) != 1 || sessions[0].cookies[0].value != "cached-session" {
+			t.Fatalf("sessions = %#v", sessions)
+		}
+		return api.ProviderUsage{Provider: "opencode-go"}, nil
+	}
+	if _, err := Fetch(context.Background()); err != nil {
+		t.Fatal(err)
+	}
+}
+
+func TestFetchReplacesRejectedCacheFromBrowser(t *testing.T) {
+	t.Setenv("XDG_CACHE_HOME", t.TempDir())
+	if err := saveSessionCache([]browserSession{{
+		label: "Chrome Default",
+		cookies: []browserCookie{{
+			name: "auth", value: "rejected-session", expiresAt: time.Now().Add(time.Hour),
+		}},
+	}}); err != nil {
+		t.Fatal(err)
+	}
+
+	originalScan := scanBrowserSessions
+	originalFetch := fetchSessionUsage
+	defer func() {
+		scanBrowserSessions = originalScan
+		fetchSessionUsage = originalFetch
+	}()
+	fresh := browserSession{
+		label: "Chrome Profile 1",
+		cookies: []browserCookie{{
+			name: "auth", value: "fresh-session", expiresAt: time.Now().Add(2 * time.Hour),
+		}},
+	}
+	scanBrowserSessions = func(time.Time) sessionScan {
+		return sessionScan{sessions: []browserSession{fresh}}
+	}
+	requests := 0
+	fetchSessionUsage = func(_ context.Context, _ time.Time, sessions []browserSession) (api.ProviderUsage, error) {
+		requests++
+		if sessions[0].cookies[0].value == "rejected-session" {
+			return api.ProviderUsage{}, errOpenCodeSessionInvalid
+		}
+		if sessions[0].cookies[0].value != "fresh-session" {
+			t.Fatalf("sessions = %#v", sessions)
+		}
+		return api.ProviderUsage{Provider: "opencode-go"}, nil
+	}
+	if _, err := Fetch(context.Background()); err != nil {
+		t.Fatal(err)
+	}
+	if requests != 2 {
+		t.Fatalf("requests = %d", requests)
+	}
+	loaded, err := loadSessionCache(time.Now())
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(loaded) != 1 || loaded[0].cookies[0].value != "fresh-session" {
+		t.Fatalf("sessions = %#v", loaded)
+	}
+}
+
+func TestFetchDoesNotScanBrowsersAfterCachedNetworkFailure(t *testing.T) {
+	t.Setenv("XDG_CACHE_HOME", t.TempDir())
+	if err := saveSessionCache([]browserSession{{
+		label: "Chrome Default",
+		cookies: []browserCookie{{
+			name: "auth", value: "cached-session", expiresAt: time.Now().Add(time.Hour),
+		}},
+	}}); err != nil {
+		t.Fatal(err)
+	}
+
+	originalScan := scanBrowserSessions
+	originalFetch := fetchSessionUsage
+	defer func() {
+		scanBrowserSessions = originalScan
+		fetchSessionUsage = originalFetch
+	}()
+	scanBrowserSessions = func(time.Time) sessionScan {
+		t.Fatal("browser scan was called after a network failure")
+		return sessionScan{}
+	}
+	fetchSessionUsage = func(context.Context, time.Time, []browserSession) (api.ProviderUsage, error) {
+		return api.ProviderUsage{}, errors.New("network unavailable")
+	}
+	_, err := Fetch(context.Background())
+	if err == nil || err.Error() != "network unavailable" {
+		t.Fatalf("error = %v", err)
+	}
+}