refactor(zoo-code-auth): drop subscription-status helpers with telemetry

The only consumer of getCachedSubscriptionStatus / checkSubscriptionStatus
was zoo-telemetry.ts, which gated extension-side LLM observability events
on an active subscription. That telemetry was removed in the previous
commit, so the helpers (and the /api/subscription/status fetch they wrap)
now have no callers.

Drop the helpers, the module-level _cachedSubscriptionStatus state and
its 5-minute TTL, and the resets sprinkled through initZooCodeAuth /
setZooCodeToken / clearZooCodeToken / handleAuthCallback. Tests for the
removed surface are deleted; the unreachable / 5xx initZooCodeAuth tests
keep their token-and-user-info preservation assertions, just without the
subscription-status check.

Co-authored-by: Cursor <cursoragent@cursor.com>

Author: JamesRobert20

src/services/__tests__/zoo-code-auth.test.ts

@@ -2,11 +2,9 @@ import { afterEach, beforeEach, describe, expect, it, vi } from "vitest"
 import * as vscode from "vscode"
 
 import {
-	checkSubscriptionStatus,
 	clearZooCodeToken,
 	clearZooCodeUserInfo,
 	disconnectZooCode,
-	getCachedSubscriptionStatus,
 	getCachedZooCodeToken,
 	getCachedZooCodeUserInfo,
 	getZooCodeBaseUrl,
@@ -68,98 +66,6 @@ describe("zoo-code-auth", () => {
 		vi.restoreAllMocks()
 	})
 
-	describe("getCachedSubscriptionStatus", () => {
-		it("returns unknown initially", () => {
-			expect(getCachedSubscriptionStatus()).toBe("unknown")
-		})
-	})
-
-	describe("checkSubscriptionStatus", () => {
-		it("returns inactive when no token is present", async () => {
-			await initZooCodeAuth(mockContext)
-
-			const status = await checkSubscriptionStatus()
-
-			expect(status).toBe("inactive")
-			expect(mockFetch).not.toHaveBeenCalled()
-		})
-
-		it("returns active when the API reports an active subscriber", async () => {
-			await initZooCodeAuth(mockContext)
-			await setZooCodeToken("zoo_ext_test_token")
-
-			mockFetch.mockResolvedValueOnce({
-				ok: true,
-				json: async () => ({ isSubscriber: true, planId: "pro", status: "active" }),
-			})
-
-			const status = await checkSubscriptionStatus()
-
-			expect(status).toBe("active")
-			expect(mockFetch).toHaveBeenCalledWith(
-				expect.stringContaining("/api/subscription/status"),
-				expect.objectContaining({
-					headers: { Authorization: "Bearer zoo_ext_test_token" },
-				}),
-			)
-		})
-
-		it("returns inactive when the API reports a free user", async () => {
-			await initZooCodeAuth(mockContext)
-			await setZooCodeToken("zoo_ext_test_token")
-
-			mockFetch.mockResolvedValueOnce({
-				ok: true,
-				json: async () => ({ isSubscriber: false, planId: "free", status: "active" }),
-			})
-
-			await expect(checkSubscriptionStatus()).resolves.toBe("inactive")
-		})
-
-		it("returns unknown when the API request fails", async () => {
-			await initZooCodeAuth(mockContext)
-			await setZooCodeToken("zoo_ext_test_token")
-
-			mockFetch.mockResolvedValueOnce({
-				ok: false,
-				status: 500,
-				statusText: "Internal Server Error",
-			})
-
-			await expect(checkSubscriptionStatus()).resolves.toBe("unknown")
-		})
-
-		it("returns unknown when the API throws", async () => {
-			await initZooCodeAuth(mockContext)
-			await setZooCodeToken("zoo_ext_test_token")
-			mockFetch.mockRejectedValueOnce(new Error("Network error"))
-
-			await expect(checkSubscriptionStatus()).resolves.toBe("unknown")
-		})
-
-		it("reuses the cached status when it was checked recently", async () => {
-			await initZooCodeAuth(mockContext)
-			await setZooCodeToken("zoo_ext_test_token")
-
-			mockFetch.mockResolvedValueOnce({
-				ok: true,
-				json: async () => ({ isSubscriber: true, planId: "pro", status: "active" }),
-			})
-
-			expect(await checkSubscriptionStatus()).toBe("active")
-			expect(await checkSubscriptionStatus()).toBe("active")
-			expect(mockFetch).toHaveBeenCalledTimes(1)
-		})
-
-		it("handles AbortSignal timeouts", async () => {
-			await initZooCodeAuth(mockContext)
-			await setZooCodeToken("zoo_ext_test_token")
-			mockFetch.mockRejectedValueOnce(new DOMException("Aborted", "AbortError"))
-
-			await expect(checkSubscriptionStatus()).resolves.toBe("unknown")
-		})
-	})
-
 	describe("getCachedZooCodeToken", () => {
 		it("returns an empty string when no token is set", async () => {
 			await clearZooCodeToken()
@@ -169,15 +75,10 @@ describe("zoo-code-auth", () => {
 
 		it("preloads the cached token during initialization", async () => {
 			await mockSecrets.store("zoo-code-session-token", "zoo_ext_cached_token")
-			mockFetch
-				.mockResolvedValueOnce({
-					ok: true,
-					json: async () => ({ valid: true }),
-				})
-				.mockResolvedValueOnce({
-					ok: true,
-					json: async () => ({ isSubscriber: true }),
-				})
+			mockFetch.mockResolvedValueOnce({
+				ok: true,
+				json: async () => ({ valid: true }),
+			})
 
 			await initZooCodeAuth(mockContext)
 			await Promise.resolve()
@@ -237,10 +138,8 @@ describe("zoo-code-auth", () => {
 
 			await initZooCodeAuth(mockContext)
 
-			// Token and user info should be kept; subscription status should be unknown
 			expect(getCachedZooCodeToken()).toBe("zoo_ext_valid_token")
 			expect(getCachedZooCodeUserInfo().name).toBe("Jane Doe")
-			expect(getCachedSubscriptionStatus()).toBe("unknown")
 		})
 
 		it("preserves token and user info when verify returns 5xx (transient backend error)", async () => {
@@ -257,39 +156,16 @@ describe("zoo-code-auth", () => {
 
 			expect(getCachedZooCodeToken()).toBe("zoo_ext_valid_token")
 			expect(getCachedZooCodeUserInfo().name).toBe("Jane Doe")
-			expect(getCachedSubscriptionStatus()).toBe("unknown")
-		})
-	})
-
-	describe("setZooCodeToken", () => {
-		it("resets the cached subscription status when the token changes", async () => {
-			await initZooCodeAuth(mockContext)
-			await setZooCodeToken("zoo_ext_token1")
-			mockFetch.mockResolvedValueOnce({
-				ok: true,
-				json: async () => ({ isSubscriber: true, planId: "pro", status: "active" }),
-			})
-			await checkSubscriptionStatus()
-
-			await setZooCodeToken("zoo_ext_token2")
-
-			expect(getCachedSubscriptionStatus()).toBe("unknown")
 		})
 	})
 
 	describe("clearZooCodeToken", () => {
-		it("resets the cached subscription status when the token is cleared", async () => {
+		it("clears the cached token", async () => {
 			await initZooCodeAuth(mockContext)
 			await setZooCodeToken("zoo_ext_test_token")
-			mockFetch.mockResolvedValueOnce({
-				ok: true,
-				json: async () => ({ isSubscriber: true, planId: "pro", status: "active" }),
-			})
-			await checkSubscriptionStatus()
 
 			await clearZooCodeToken()
 
-			expect(getCachedSubscriptionStatus()).toBe("unknown")
 			expect(getCachedZooCodeToken()).toBe("")
 		})
 	})
@@ -337,15 +213,10 @@ describe("zoo-code-auth", () => {
 
 		it("persists a token only after backend verification succeeds", async () => {
 			await initZooCodeAuth(mockContext)
-			mockFetch
-				.mockResolvedValueOnce({
-					ok: true,
-					json: async () => ({ valid: true }),
-				})
-				.mockResolvedValueOnce({
-					ok: true,
-					json: async () => ({ isSubscriber: true }),
-				})
+			mockFetch.mockResolvedValueOnce({
+				ok: true,
+				json: async () => ({ valid: true }),
+			})
 
 			const success = await handleAuthCallback("zoo_ext_real_token")
 

src/services/zoo-code-auth.ts

@@ -15,9 +15,6 @@ let _sessionCleared = false
 let _cachedUserName: string | undefined = undefined
 let _cachedUserEmail: string | undefined = undefined
 let _cachedUserImage: string | undefined = undefined
-let _cachedSubscriptionStatus: "active" | "inactive" | "unknown" = "unknown"
-let _lastSubscriptionCheck: number = 0
-const SUBSCRIPTION_CHECK_INTERVAL_MS = 5 * 60 * 1000 // 5 minutes
 
 export async function initZooCodeAuth(context: vscode.ExtensionContext): Promise<void> {
 	if (!context.secrets) {
@@ -35,19 +32,13 @@ export async function initZooCodeAuth(context: vscode.ExtensionContext): Promise
 	_cachedUserImage = await secretStorage.get(ZOO_CODE_USER_IMAGE_KEY)
 
 	// Validate persisted auth state on init before reporting the user as connected.
+	// Network errors / 5xx ("unreachable") leave the cached session in place so a
+	// transient backend blip doesn't force users to sign in again.
 	if (_cachedToken) {
 		const result = await verifyZooCodeToken()
 		if (result === "invalid") {
-			// Token is definitively rejected by the backend — clear everything.
 			await clearZooCodeUserInfo()
 			await clearZooCodeToken()
-		} else if (result === "unreachable") {
-			// Network is temporarily down; keep the cached session but mark subscription
-			// status as unknown so callers know it hasn't been confirmed.
-			_cachedSubscriptionStatus = "unknown"
-		} else {
-			// result === "valid"
-			void checkSubscriptionStatus().catch(() => {})
 		}
 	}
 
@@ -56,12 +47,6 @@ export async function initZooCodeAuth(context: vscode.ExtensionContext): Promise
 		if (e.key === ZOO_CODE_TOKEN_KEY) {
 			secretStorage?.get(ZOO_CODE_TOKEN_KEY).then((token) => {
 				_cachedToken = token
-				// Reset subscription status when token changes
-				_cachedSubscriptionStatus = "unknown"
-				_lastSubscriptionCheck = 0
-				if (token) {
-					checkSubscriptionStatus().catch(() => {})
-				}
 			})
 		}
 		if (e.key === ZOO_CODE_USER_NAME_KEY) {
@@ -110,57 +95,6 @@ export function getCachedZooCodeUserInfo(): { name?: string; email?: string; ima
 	}
 }
 
-/**
- * Get the cached subscription status. This is a synchronous getter that returns
- * the last known subscription status. Call checkSubscriptionStatus() to refresh.
- */
-export function getCachedSubscriptionStatus(): "active" | "inactive" | "unknown" {
-	return _cachedSubscriptionStatus
-}
-
-/**
- * Check the subscription status from the backend API.
- * Updates the cached status and returns it.
- * Implements caching to avoid excessive API calls (5 minute cache).
- */
-export async function checkSubscriptionStatus(): Promise<"active" | "inactive" | "unknown"> {
-	const token = await getZooCodeToken()
-	if (!token) {
-		_cachedSubscriptionStatus = "inactive"
-		return "inactive"
-	}
-
-	// Return cached status if checked recently
-	const now = Date.now()
-	if (now - _lastSubscriptionCheck < SUBSCRIPTION_CHECK_INTERVAL_MS && _cachedSubscriptionStatus !== "unknown") {
-		return _cachedSubscriptionStatus
-	}
-
-	const baseUrl = getZooCodeBaseUrl()
-
-	try {
-		const response = await fetch(`${baseUrl}/api/subscription/status`, {
-			headers: { Authorization: `Bearer ${token}` },
-			signal: AbortSignal.timeout(10_000),
-		})
-
-		if (!response.ok) {
-			_cachedSubscriptionStatus = "unknown"
-			_lastSubscriptionCheck = now
-			return "unknown"
-		}
-
-		const data = (await response.json()) as { isSubscriber?: boolean }
-		_cachedSubscriptionStatus = data.isSubscriber ? "active" : "inactive"
-		_lastSubscriptionCheck = now
-		return _cachedSubscriptionStatus
-	} catch {
-		_cachedSubscriptionStatus = "unknown"
-		_lastSubscriptionCheck = now
-		return "unknown"
-	}
-}
-
 export async function getZooCodeToken(): Promise<string | undefined> {
 	if (!secretStorage) return undefined
 	return secretStorage.get(ZOO_CODE_TOKEN_KEY)
@@ -171,9 +105,6 @@ export async function setZooCodeToken(token: string): Promise<void> {
 	await secretStorage.store(ZOO_CODE_TOKEN_KEY, token)
 	_cachedToken = token
 	_sessionCleared = false
-	// Reset subscription status when token is set
-	_cachedSubscriptionStatus = "unknown"
-	_lastSubscriptionCheck = 0
 }
 
 export async function setZooCodeUserInfo(info: {
@@ -223,8 +154,6 @@ export async function clearZooCodeToken(): Promise<void> {
 	await secretStorage.delete(ZOO_CODE_TOKEN_KEY)
 	_cachedToken = undefined
 	_sessionCleared = true
-	_cachedSubscriptionStatus = "unknown"
-	_lastSubscriptionCheck = 0
 }
 
 export function getZooCodeBaseUrl(): string {
@@ -266,9 +195,6 @@ export async function handleAuthCallback(token: string): Promise<boolean> {
 
 	await setZooCodeToken(token)
 
-	// Check subscription status after successful auth
-	await checkSubscriptionStatus().catch(() => {})
-
 	vscode.window.showInformationMessage(t("common:zooAuth.info.connected"))
 	return true
 }