TOS & Subscription Info

public/js/auth.js

@@ -108,31 +108,43 @@ export async function logout() {
 // ── Session handling ──────────────────────────────────────────────────────
 
 async function handleSupabaseSession(data) {
+  console.log('[Frontend Auth] handleSupabaseSession called with token:', data.access_token?.slice(0, 20) + '...');
   if (!data.access_token) throw new Error('No access token');
   saveAuth({ access_token: data.access_token, refresh_token: data.refresh_token, user: data.user });
 
   return new Promise((resolve, reject) => {
     const tempId   = getTempId();
     const clientId = getClientId();
+    console.log('[Frontend Auth] Sending auth:login to backend with token:', data.access_token?.slice(0, 20) + '...');
     send({ type: 'auth:login', accessToken: data.access_token, refreshToken: data.refresh_token,
       tempId, clientId });
 
-    const unsubOk  = on('auth:ok',    (msg) => { unsubOk(); unsubErr(); applyAuthOk(msg); resolve(msg); });
-    const unsubErr = on('auth:error', (msg) => { unsubOk(); unsubErr(); reject(new Error(msg.message)); });
+    const unsubOk  = on('auth:ok',    (msg) => {
+      console.log('[Frontend Auth] Received auth:ok response');
+      unsubOk(); unsubErr(); applyAuthOk(msg); resolve(msg);
+    });
+    const unsubErr = on('auth:error', (msg) => { 
+      console.error('[Frontend Auth] Received auth:error:', msg.message);
+      unsubOk(); unsubErr(); reject(new Error(msg.message));
+    });
 
     setTimeout(() => { unsubOk(); unsubErr(); reject(new Error('Auth timeout')); }, 12000);
   });
 }
 
 function applyAuthOk(msg) {
+  console.log('[Frontend Auth] applyAuthOk called with msg:', msg);
   currentUser  = { id: msg.userId, email: msg.email };
   userProfile  = msg.profile;
   userSettings = msg.settings;
   subscriptionInfo = msg.subscription || null;
-  console.log('Auth OK - subscription info:', subscriptionInfo);
+  console.log('[Frontend Auth] Subscription info set to:', subscriptionInfo);
+  console.log('[Frontend Auth] subscriptionInfo?.planKey:', subscriptionInfo?.planKey);
+  console.log('[Frontend Auth] subscriptionInfo?.planName:', subscriptionInfo?.planName);
   const auth = loadAuth() || {};
   saveAuth({ ...auth, userId: msg.userId, deviceToken: msg.deviceToken });
   notifyListeners();
+  console.log('[Frontend Auth] Calling updateSidebarProfile...');
   updateSidebarProfile();
   // Apply saved theme
   if (msg.settings?.theme) {
@@ -174,11 +186,21 @@ on('settings:updated', (msg) => {
 // ── Reconnect on WS connect ────────────────────────────────────────────────
 
 on('ws:connected', async () => {
+  console.log('[Frontend Auth] WS connected event');
   const auth = loadAuth();
+  console.log('[Frontend Auth] Loaded auth:', auth ? 'exists' : 'null');
   if (auth?.access_token) {
-    try { await handleSupabaseSession(auth); }
-    catch { clearAuth(); initAsGuest(); }
+    try {
+      console.log('[Frontend Auth] Attempting to resume session with existing token');
+      await handleSupabaseSession(auth);
+    }
+    catch (err) {
+      console.error('[Frontend Auth] Failed to resume session:', err);
+      clearAuth();
+      initAsGuest();
+    }
   } else {
+    console.log('[Frontend Auth] No stored auth, initializing as guest');
     initAsGuest();
   }
 });
@@ -191,16 +213,25 @@ on('ws:connected', async () => {
 
 window.addEventListener('storage', async (e) => {
   if (e.key !== OAUTH_PENDING_KEY || !e.newValue) return;
+  console.log('[Frontend Auth] OAuth pending key detected in localStorage');
   // Consume immediately so other tabs don't also try to log in
   localStorage.removeItem(OAUTH_PENDING_KEY);
   let tokens;
-  try { tokens = JSON.parse(e.newValue); } catch { return; }
-  if (!tokens?.access_token) return;
+  try { tokens = JSON.parse(e.newValue); } catch { 
+    console.error('[Frontend Auth] Failed to parse OAuth tokens');
+    return;
+  }
+  if (!tokens?.access_token) {
+    console.warn('[Frontend Auth] No access token in OAuth response');
+    return;
+  }
+  console.log('[Frontend Auth] Processing OAuth tokens:', tokens.access_token?.slice(0, 20) + '...');
   try {
     await handleSupabaseSession(tokens);
     import('./ui.js').then(({ showNotification }) =>
       showNotification({ type: 'success', message: 'Signed in!', duration: 2500 }));
   } catch (err) {
+    console.error('[Frontend Auth] OAuth sign-in error:', err);
     import('./ui.js').then(({ showNotification }) =>
       showNotification({ type: 'error', message: `Sign-in failed: ${err.message}`, duration: 4000 }));
   }
@@ -210,9 +241,13 @@ window.addEventListener('storage', async (e) => {
 (function checkOAuthRedirect() {
   const params = new URLSearchParams(location.search);
   const t = params.get('t'), r = params.get('r');
+  console.log('[Frontend Auth] Checking for OAuth redirect params:', t ? 'found token' : 'no token');
   if (params.get('oauth') === '1' && t) {
+    console.log('[Frontend Auth] Processing OAuth redirect with token:', t.slice(0, 20) + '...');
     history.replaceState({}, '', '/');
-    handleSupabaseSession({ access_token: t, refresh_token: r || '' }).catch(() => {});
+    handleSupabaseSession({ access_token: t, refresh_token: r || '' }).catch((err) => {
+      console.error('[Frontend Auth] OAuth redirect failed:', err);
+    });
   }
 })();
 
@@ -220,10 +255,16 @@ window.addEventListener('storage', async (e) => {
 window.addEventListener('message', async (e) => {
   if (e.origin !== location.origin) return;
   if (e.data?.type !== 'oauth:callback') return;
+  console.log('[Frontend Auth] postMessage oauth:callback received');
   const { access_token, refresh_token } = e.data;
-  if (!access_token) return;
+  if (!access_token) {
+    console.warn('[Frontend Auth] No access_token in postMessage oauth:callback');
+    return;
+  }
+  console.log('[Frontend Auth] Processing postMessage tokens:', access_token?.slice(0, 20) + '...');
   try { await handleSupabaseSession({ access_token, refresh_token }); }
   catch (err) {
+    console.error('[Frontend Auth] postMessage sign-in error:', err);
     import('./ui.js').then(({ showNotification }) =>
       showNotification({ type: 'error', message: `Sign-in failed: ${err.message}`, duration: 4000 }));
   }
@@ -232,6 +273,7 @@ window.addEventListener('message', async (e) => {
 // ── Sidebar profile ───────────────────────────────────────────────────────
 
 export function updateSidebarProfile() {
+  console.log('[Frontend Auth] updateSidebarProfile called - currentUser:', currentUser);
   const guestEl = document.getElementById('guest-section');
   const userEl  = document.getElementById('user-section');
   const nameEl  = document.getElementById('user-name-display');
@@ -239,6 +281,7 @@ export function updateSidebarProfile() {
   const avatarEl= document.getElementById('user-avatar');
 
   if (!currentUser) {
+    console.log('[Frontend Auth] Not logged in, showing guest section');
     guestEl?.classList.remove('hidden');
     userEl?.classList.add('hidden');
     return;
@@ -252,6 +295,7 @@ export function updateSidebarProfile() {
 
   const plan     = subscriptionInfo?.planKey || 'free';
   const planName = subscriptionInfo?.planName || 'Free';
+  console.log('[Frontend Auth] Setting plan display - plan:', plan, 'planName:', planName, 'subscriptionInfo:', subscriptionInfo);
   if (planEl) { planEl.textContent = planName; planEl.setAttribute('data-plan', plan); }
 }
 

public/js/settings.js

@@ -250,11 +250,15 @@ function setupAccountSettings(b) {
 
   const subHandler = (msg) => {
     off('account:subscription', subHandler);
+    console.log('[Settings] Received account:subscription:', msg);
     const planEl = b.querySelector('#plan-name-display');
     if (planEl && msg.info) {
       const pKey = msg.info.planKey || 'free';
       const pName = msg.info.planName || 'Free Tier';
+      console.log('[Settings] Updating plan display - key:', pKey, 'name:', pName);
       planEl.innerHTML = `<span style="color:var(--plan-${pKey})">${escHtml(pName)}</span>`;
+    } else {
+      console.warn('[Settings] No plan info available:', msg.info);
     }
   };
   on('account:subscription', subHandler);

server/auth.js

@@ -62,11 +62,22 @@ export async function setUsername(userId, accessToken, username) {
 
 export async function getSubscriptionInfo(accessToken) {
   try {
+    console.log('[Subscription] Fetching subscription info for token:', accessToken?.slice(0, 20) + '...');
     const r = await fetch('https://sharktide-lightning.hf.space/subscription', {
       headers: { Authorization: `Bearer ${accessToken}`, Accept: 'application/json' },
     });
-    return r.ok ? r.json() : null;
-  } catch { return null; }
+    console.log('[Subscription] Response status:', r.status);
+    if (!r.ok) {
+      console.warn(`[Subscription] Failed: HTTP ${r.status}`);
+      return null;
+    }
+    const data = await r.json();
+    console.log('[Subscription] Response data:', data);
+    return data;
+  } catch (err) {
+    console.error('[Subscription] Error fetching subscription info:', err.message);
+    return null;
+  }
 }
 
 export async function getTierConfig() {

server/wsHandler.js

@@ -78,9 +78,11 @@ const handlers = {
 
   'auth:login': async (ws, msg, client, wsClients) => {
     const { accessToken, tempId: clientTempId } = msg;
+    console.log('[Auth] Login request received, token:', accessToken?.slice(0, 20) + '...');
     if (!accessToken) return safeSend(ws, { type: 'auth:error', message: 'Missing token' });
     const user = await verifySupabaseToken(accessToken);
     if (!user) return safeSend(ws, { type: 'auth:error', message: 'Invalid token' });
+    console.log('[Auth] User verified:', user.id);
 
     client.userId = user.id; client.accessToken = accessToken; client.authenticated = true;
     client.deviceToken = deviceSessionStore.create(user.id, client.ip, client.userAgent);
@@ -90,15 +92,19 @@ const handlers = {
     const tId = client.tempId;
     await sessionStore.transferTempToUser(tId, user.id, accessToken);
 
+    console.log('[Auth] Fetching user data...');
     const [sessions, settings, profile, subscription] = await Promise.all([
       sessionStore.loadUserSessions(user.id, accessToken),
       getUserSettings(user.id, accessToken),
       getUserProfile(user.id, accessToken),
       getSubscriptionInfo(accessToken),
     ]);
+    console.log('[Auth] User data fetched - subscription:', subscription);
 
-    safeSend(ws, { type: 'auth:ok', userId: user.id, email: user.email,
-      deviceToken: client.deviceToken, sessions: sessions.map(ser), settings, profile, subscription });
+    const authOkMsg = { type: 'auth:ok', userId: user.id, email: user.email,
+      deviceToken: client.deviceToken, sessions: sessions.map(ser), settings, profile, subscription };
+    console.log('[Auth] Sending auth:ok with subscription:', subscription);
+    safeSend(ws, authOkMsg);
 
     bcast(wsClients, user.id, { type: 'auth:newLogin', message: 'New login on your account.',
       ip: client.ip, userAgent: client.userAgent, timestamp: new Date().toISOString() }, ws);
@@ -381,7 +387,13 @@ const handlers = {
 
   'account:getProfile':      async (ws, msg, c) => { if (!c.userId) return; safeSend(ws, { type: 'account:profile', profile: await getUserProfile(c.userId, c.accessToken) }); },
   'account:setUsername':     async (ws, msg, c) => { if (!c.userId) return; safeSend(ws, { type: 'account:usernameResult', ...await setUsername(c.userId, c.accessToken, msg.username) }); },
-  'account:getSubscription': async (ws, msg, c) => { if (!c.userId) return; safeSend(ws, { type: 'account:subscription', info: await getSubscriptionInfo(c.accessToken) }); },
+  'account:getSubscription': async (ws, msg, c) => { 
+    if (!c.userId) return console.warn('[Account] getSubscription called without userId');
+    console.log('[Account] getSubscription request for user:', c.userId);
+    const subInfo = await getSubscriptionInfo(c.accessToken);
+    console.log('[Account] getSubscription response:', subInfo);
+    safeSend(ws, { type: 'account:subscription', info: subInfo });
+  },
   'account:getUsage':        async (ws, msg, c) => { safeSend(ws, { type: 'account:usage', usage: await getUsageInfo(c.accessToken) }); },
   'account:getTierConfig':   async (ws)          => { safeSend(ws, { type: 'account:tierConfig', config: await getTierConfig() }); },
   'account:getSessions':     (ws, msg, c)         => { if (!c.userId) return; safeSend(ws, { type: 'account:deviceSessions', sessions: deviceSessionStore.getForUser(c.userId), currentToken: c.deviceToken }); },