Files
karaoke-gen/frontend/lib/auth.ts
T
Andrew Beveridge ☄️andClaude Opus 4.6 42a7793681 AI-powered credit gating with Gemini evaluation (#584)
## Summary
- Replace automatic welcome/feedback credit grants with AI-powered abuse
evaluation using Gemini 3.1 Pro
- **Fail-closed**: errors/uncertainty → credits withheld, admin notified
via email with user admin link
- Clean users (no correlations) get instant grant with no AI call
latency
- Frontend verify page shows preparing account →
celebratory/denied/pending interstitial
- Comprehensive docs at `docs/AI-CREDIT-GATING.md`

## Changes
| File | What |
|------|------|
| `backend/services/credit_evaluation_service.py` | **New**: Signal
collection, Gemini prompt, response parsing, Firestore audit |
| `backend/config.py` | `CREDIT_EVAL_ENABLED`, `CREDIT_EVAL_MODEL`
config |
| `backend/services/user_service.py` | Welcome credit flow integration
(returns tuple) |
| `backend/api/routes/users.py` | Feedback credit + verify response
integration |
| `backend/services/email_service.py` | `send_credit_denied_email()`,
`send_credit_review_needed_email()` |
| `backend/models/user.py` | `credit_status` field on verify response |
| `frontend/app/auth/verify/page.tsx` | 5-state interstitial flow |
| `frontend/lib/types.ts` + `auth.ts` | Type + state updates |
| `backend/tests/test_credit_evaluation.py` | **New**: 17 tests |
| `backend/tests/test_anti_abuse.py` | Updated for new return type |
| `docs/AI-CREDIT-GATING.md` | **New**: Comprehensive documentation |
| `pyproject.toml` | `google-generativeai` dep, version bump |

## Test plan
- [x] 50 backend tests pass (17 new + 33 updated)
- [ ] Manual: test with new account signup in prod (see docs for
expected flow)
- [ ] Manual: verify admin review email received for error cases

## Rollback
Set `CREDIT_EVAL_ENABLED=false` in Cloud Run env vars → instant revert
to auto-grant.

@coderabbitai ignore

🤖 Generated with [Claude Code](https://claude.com/claude-code)

---------

Co-authored-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
2026-03-23 21:57:46 -04:00

301 lines
9.1 KiB
TypeScript

"use client"
import { create } from "zustand"
import { persist } from "zustand/middleware"
import type { User, UserPublic } from "./types"
import { api, adminApi, setAccessToken, clearAccessToken, getAccessToken } from "./api"
interface AuthStore {
user: User | null
isLoading: boolean
error: string | null
// Hydration state - true once zustand has loaded persisted data
hasHydrated: boolean
// Impersonation state (not persisted)
isImpersonating: boolean
originalAdminToken: string | null
impersonatedUserEmail: string | null
// Actions
sendMagicLink: (email: string) => Promise<boolean>
verifyMagicLink: (token: string) => Promise<boolean>
fetchUser: () => Promise<boolean>
logout: () => Promise<void>
updateCredits: (credits: number) => void
clearError: () => void
setHasHydrated: (state: boolean) => void
// For legacy token-based auth (admin tokens)
loginWithToken: (token: string) => Promise<boolean>
// Impersonation actions
startImpersonation: (email: string) => Promise<boolean>
endImpersonation: () => void
}
export const useAuth = create<AuthStore>()(
persist(
(set, get) => ({
user: null,
isLoading: false,
error: null,
hasHydrated: false,
// Impersonation state
isImpersonating: false,
originalAdminToken: null,
impersonatedUserEmail: null,
setHasHydrated: (state: boolean) => set({ hasHydrated: state }),
sendMagicLink: async (email: string) => {
set({ isLoading: true, error: null })
try {
// Get device fingerprint for anti-abuse rate limiting
const { getDeviceFingerprint } = await import('./fingerprint')
const fingerprint = await getDeviceFingerprint()
await api.sendMagicLink(email, fingerprint)
set({ isLoading: false })
return true
} catch (err) {
set({
isLoading: false,
error: err instanceof Error ? err.message : 'Failed to send magic link'
})
return false
}
},
verifyMagicLink: async (token: string) => {
set({ isLoading: true, error: null })
try {
const response = await api.verifyMagicLink(token)
// Store the session token
setAccessToken(response.session_token)
// Store verify response data for cross-domain redirect and welcome credits
if (typeof window !== 'undefined') {
(window as any).__LAST_VERIFY_RESPONSE__ = {
tenant_subdomain: response.tenant_subdomain,
credits_granted: response.credits_granted || 0,
credit_status: response.credit_status || "not_applicable",
}
}
// Create user from response
const user: User = {
token: response.session_token,
email: response.user.email,
role: response.user.role,
credits: response.user.credits,
display_name: response.user.display_name,
total_jobs_created: response.user.total_jobs_created,
total_jobs_completed: response.user.total_jobs_completed,
feedback_eligible: response.user.feedback_eligible,
}
set({ user, isLoading: false })
return true
} catch (err) {
set({
isLoading: false,
error: err instanceof Error ? err.message : 'Invalid or expired link'
})
return false
}
},
fetchUser: async () => {
const token = getAccessToken()
if (!token) {
set({ user: null })
return false
}
set({ isLoading: true })
try {
const response = await api.getCurrentUser()
const user: User = {
token,
email: response.user.email,
role: response.user.role,
credits: response.user.credits,
display_name: response.user.display_name,
total_jobs_created: response.user.total_jobs_created,
total_jobs_completed: response.user.total_jobs_completed,
feedback_eligible: response.user.feedback_eligible,
}
set({ user, isLoading: false })
return true
} catch {
// Session may have expired
clearAccessToken()
set({ user: null, isLoading: false })
return false
}
},
logout: async () => {
try {
await api.logout()
} catch {
// Ignore errors, just clear local state
}
clearAccessToken()
set({ user: null, error: null })
},
updateCredits: (credits: number) =>
set((state) => ({
user: state.user ? { ...state.user, credits } : null,
})),
clearError: () => set({ error: null }),
// Legacy token-based auth for admin tokens
loginWithToken: async (token: string) => {
set({ isLoading: true, error: null })
try {
// Store the token
setAccessToken(token)
// Try to fetch user profile
const response = await api.getCurrentUser()
const user: User = {
token,
email: response.user.email,
role: response.user.role,
credits: response.user.credits,
display_name: response.user.display_name,
total_jobs_created: response.user.total_jobs_created,
total_jobs_completed: response.user.total_jobs_completed,
feedback_eligible: response.user.feedback_eligible,
}
set({ user, isLoading: false })
return true
} catch {
// Token validation failed - clear token and reject
clearAccessToken()
set({
user: null,
isLoading: false,
error: 'Invalid token or server unavailable'
})
return false
}
},
// Start impersonating a user (admin only)
startImpersonation: async (email: string) => {
// Prevent nested impersonation - must end current impersonation first
const currentState = get()
if (currentState.isImpersonating) {
set({
error: 'Already impersonating a user. End current impersonation first.'
})
return false
}
set({ isLoading: true, error: null })
const originalToken = getAccessToken()
try {
// Store original admin token before switching
if (!originalToken) {
throw new Error('No active session to preserve')
}
// Call API to get impersonation token
const response = await adminApi.impersonateUser(email)
// Switch to impersonation token
setAccessToken(response.session_token)
// Fetch the impersonated user's profile
// If this fails, we need to restore the original token
let userResponse
try {
userResponse = await api.getCurrentUser()
} catch (profileErr) {
// Restore original admin token if profile fetch fails
setAccessToken(originalToken)
throw profileErr
}
const user: User = {
token: response.session_token,
email: userResponse.user.email,
role: userResponse.user.role,
credits: userResponse.user.credits,
display_name: userResponse.user.display_name,
total_jobs_created: userResponse.user.total_jobs_created,
total_jobs_completed: userResponse.user.total_jobs_completed,
feedback_eligible: userResponse.user.feedback_eligible,
}
set({
user,
isLoading: false,
isImpersonating: true,
originalAdminToken: originalToken,
impersonatedUserEmail: email,
})
return true
} catch (err) {
set({
isLoading: false,
error: err instanceof Error ? err.message : 'Failed to impersonate user'
})
return false
}
},
// End impersonation and return to admin session
endImpersonation: () => {
const { originalAdminToken } = get()
if (originalAdminToken) {
// Restore original admin token
setAccessToken(originalAdminToken)
// Clear impersonation state and refetch admin user
set({
isImpersonating: false,
originalAdminToken: null,
impersonatedUserEmail: null,
})
// Fetch the admin user profile
get().fetchUser()
}
},
}),
{
name: "nomad-karaoke-auth",
// Only persist user, not impersonation state (impersonation should not survive page refresh)
partialize: (state) => ({ user: state.user }),
onRehydrateStorage: () => (state) => {
// Called when hydration is complete
state?.setHasHydrated(true)
},
},
),
)
// Initialize auth state on page load
if (typeof window !== 'undefined') {
const token = getAccessToken()
if (token) {
// Fetch fresh user data on page load
useAuth.getState().fetchUser()
}
}