frontend/electron/main.ts

@@ -40,6 +40,7 @@ interface Account {
   cooldownExpiresAt?: string;
   authError?: boolean;
   notes?: string;
+  sharedWith?: any[];
 }
 
 interface ServerConfig {
@@ -48,6 +49,7 @@ interface ServerConfig {
   serverSteamId?: string;
   enabled: boolean;
   theme?: string;
+  isAdmin?: boolean;
 }
 
 // --- App State ---
@@ -94,44 +96,24 @@ const createTray = () => {
   const assetsDir = path.join(__dirname, '..', 'assets-build');
   const possibleIcons = ['icon.svg', 'icon.png'];
   let iconPath = '';
-
   for (const name of possibleIcons) {
     const fullPath = path.join(assetsDir, name);
-    if (fs.existsSync(fullPath)) {
+    if (fs.existsSync(fullPath)) { iconPath = fullPath; break; }
-      iconPath = fullPath;
-      break;
-    }
   }
-  
+  if (!iconPath) return;
-  console.log(`[Tray] Attempting to initialize with icon: ${iconPath || 'NONE FOUND'}`);
-  
-  if (!iconPath) {
-    console.warn(`[Tray] FAILED: No valid icon found in ${assetsDir}`);
-    return;
-  }
-  
   try {
     const icon = nativeImage.createFromPath(iconPath).resize({ width: 16, height: 16 });
     tray = new Tray(icon);
     tray.setToolTip('Ultimate Ban Tracker');
-    tray.on('click', () => {
+    tray.on('click', () => { if (mainWindow) { mainWindow.show(); mainWindow.focus(); } });
-      if (mainWindow) {
-        mainWindow.show();
-        mainWindow.focus();
-      }
-    });
     updateTrayMenu();
-    console.log(`[Tray] Successfully initialized`);
+  } catch (e) { }
-  } catch (e: any) {
-    console.error(`[Tray] Critical error during initialization: ${e.message}`);
-  }
 };
 
 const updateTrayMenu = () => {
   if (!tray) return;
   const accounts = store.get('accounts') as Account[];
   const config = store.get('serverConfig');
-
   const contextMenu = Menu.buildFromTemplate([
     { label: `Ultimate Ban Tracker v${app.getVersion()}`, enabled: false },
     { type: 'separator' },
@@ -143,16 +125,11 @@ const updateTrayMenu = () => {
         click: () => handleSwitchAccount(acc.loginName)
       })) : [{ label: 'No accounts found', enabled: false }]
     },
-    { 
+    { label: 'Sync Now', enabled: !!config?.enabled, click: () => syncAccounts(true) },
-      label: 'Sync Now', 
-      enabled: !!config?.enabled,
-      click: () => syncAccounts()
-    },
     { type: 'separator' },
     { label: 'Show Dashboard', click: () => { if (mainWindow) mainWindow.show(); } },
     { label: 'Quit', click: () => { (app as any).isQuitting = true; app.quit(); } }
   ]);
-
   tray.setContextMenu(contextMenu);
 };
 
@@ -192,29 +169,21 @@ const handleSwitchAccount = async (loginName: string) => {
 const scrapeAccountData = async (account: Account) => {
   const now = new Date();
   try {
-    // 1. Refresh Basic Profile & Bans
     const profile = await fetchProfileData(account.steamId, account.steamLoginSecure);
     const bans = await scrapeBanStatus(profile.profileUrl, account.steamLoginSecure);
-    
+    account.personaName = profile.personaName; account.profileUrl = profile.profileUrl;
-    account.personaName = profile.personaName;
+    account.vacBanned = bans.vacBanned; account.gameBans = bans.gameBans;
-    account.profileUrl = profile.profileUrl;
-    account.vacBanned = bans.vacBanned;
-    account.gameBans = bans.gameBans;
     account.status = (bans.vacBanned || bans.gameBans > 0) ? 'banned' : 'none';
     account.lastBanCheck = now.toISOString();
-
     if (profile.avatar && (!account.localAvatar || profile.avatar !== account.avatar)) {
       account.avatar = profile.avatar;
       const localPath = await downloadAvatar(account.steamId, profile.avatar);
       if (localPath) account.localAvatar = localPath;
     }
-
-    // 2. Refresh Cooldowns if session is active
     if (account.steamLoginSecure) {
       try {
         const result = await scrapeCooldown(account.steamId, account.steamLoginSecure);
-        account.authError = false;
+        account.authError = false; account.lastScrapeTime = now.toISOString();
-        account.lastScrapeTime = now.toISOString();
         if (result.isActive) {
           account.cooldownExpiresAt = result.expiresAt ? result.expiresAt.toISOString() : new Date(Date.now() + 86400000).toISOString();
           if (backend) await backend.pushCooldown(account.steamId, account.cooldownExpiresAt);
@@ -226,12 +195,9 @@ const scrapeAccountData = async (account: Account) => {
         if (e.message.includes('cookie') || e.message.includes('Sign In')) account.authError = true;
       }
     }
-
-    // 3. Share updated state with backend
     if (backend && !account._id.startsWith('shared_')) {
       await backend.shareAccount(account);
     }
-
     return true;
   } catch (e) {
     console.error(`[Scraper] Failed to scrape ${account.personaName}:`, e);
@@ -240,7 +206,8 @@ const scrapeAccountData = async (account: Account) => {
 };
 
 // --- Sync Worker ---
-const syncAccounts = async () => {
+const syncAccounts = async (isManual = false) => {
+  console.log(`[Sync] Phase 1: Pulling from server...`);
   initBackend();
   let accounts = store.get('accounts') as Account[];
   let hasChanges = false;
@@ -252,12 +219,13 @@ const syncAccounts = async () => {
         const exists = accounts.find(a => a.steamId === s.steamId);
         if (!exists) {
           accounts.push({
-            _id: `shared_${s.steamId}`,
+            _id: `shared_${s.steamId}`, steamId: s.steamId, personaName: s.personaName,
-            steamId: s.steamId, personaName: s.personaName, avatar: s.avatar, profileUrl: s.profileUrl,
+            avatar: s.avatar, profileUrl: s.profileUrl, vacBanned: s.vacBanned,
-            vacBanned: s.vacBanned, gameBans: s.gameBans, cooldownExpiresAt: s.cooldownExpiresAt,
+            gameBans: s.gameBans, cooldownExpiresAt: s.cooldownExpiresAt,
-            loginName: s.loginName || '', steamLoginSecure: s.steamLoginSecure, loginConfig: s.loginConfig,
+            loginName: s.loginName || '', steamLoginSecure: s.steamLoginSecure,
-            sessionUpdatedAt: s.sessionUpdatedAt, autoCheckCooldown: !!s.steamLoginSecure,
+            loginConfig: s.loginConfig, sessionUpdatedAt: s.sessionUpdatedAt,
-            status: (s.vacBanned || s.gameBans > 0) ? 'banned' : 'none', lastBanCheck: new Date().toISOString()
+            autoCheckCooldown: !!s.steamLoginSecure, status: (s.vacBanned || s.gameBans > 0) ? 'banned' : 'none',
+            lastBanCheck: new Date().toISOString(), sharedWith: s.sharedWith
           });
           hasChanges = true;
         } else {
@@ -274,6 +242,10 @@ const syncAccounts = async () => {
             exists.cooldownExpiresAt = s.cooldownExpiresAt;
             hasChanges = true;
           }
+          if (JSON.stringify(exists.sharedWith) !== JSON.stringify(s.sharedWith)) {
+            exists.sharedWith = s.sharedWith;
+            hasChanges = true;
+          }
         }
       }
     } catch (e) { }
@@ -285,47 +257,39 @@ const syncAccounts = async () => {
     updateTrayMenu();
   }
 
-  if (accounts.length === 0) return;
+  // Phase 2: Background Scrapes
-
+  const runScrapes = async () => {
-  const updatedAccounts = [...accounts];
+    console.log(`[Sync] Phase 2: Starting background checks for ${accounts.length} accounts...`);
-  let scrapeChanges = false;
+    const currentAccounts = [...store.get('accounts') as Account[]];
-
+    let scrapeChanges = false;
-  for (const account of updatedAccounts) {
+    for (const account of currentAccounts) {
-    try {
+      try {
-      const now = new Date();
+        const now = new Date();
-      
+        if (backend && !account._id.startsWith('shared_')) await backend.shareAccount(account);
-      // OPTIMIZATION: Ensure ALL authenticated accounts are shared with the server on every sync cycle
+        const lastCheck = account.lastBanCheck ? new Date(account.lastBanCheck) : new Date(0);
-      if (backend && !account._id.startsWith('shared_')) {
-        await backend.shareAccount(account);
-      }
-
-      const lastCheck = account.lastBanCheck ? new Date(account.lastBanCheck) : new Date(0);
-      if ((now.getTime() - lastCheck.getTime()) / 3600000 > 6 || !account.personaName) {
-        await scrapeAccountData(account);
-        scrapeChanges = true;
-      }
-
-      if (account.autoCheckCooldown && account.steamLoginSecure) {
-        if (account.cooldownExpiresAt && new Date(account.cooldownExpiresAt) > now) continue;
         const lastScrape = account.lastScrapeTime ? new Date(account.lastScrapeTime) : new Date(0);
-        if ((now.getTime() - lastScrape.getTime()) / 3600000 > 8) {
+        const needsMetadata = (now.getTime() - lastCheck.getTime()) / 3600000 > 6 || !account.personaName;
-          await new Promise(r => setTimeout(r, Math.floor(Math.random() * 60000) + 5000));
+        const needsCooldown = account.autoCheckCooldown && account.steamLoginSecure && (now.getTime() - lastScrape.getTime()) / 3600000 > 8;
-          await scrapeAccountData(account);
-          scrapeChanges = true;
-        }
-      }
-    } catch (error) { }
-  }
 
-  if (scrapeChanges) {
+        if (needsMetadata || needsCooldown || isManual) {
-    store.set('accounts', updatedAccounts);
+          if (!isManual && needsCooldown) await new Promise(r => setTimeout(r, Math.floor(Math.random() * 30000) + 5000));
-    if (mainWindow) mainWindow.webContents.send('accounts-updated', updatedAccounts);
+          if (await scrapeAccountData(account)) scrapeChanges = true;
-    updateTrayMenu();
+        }
-  }
+      } catch (error) { }
+    }
+    if (scrapeChanges) {
+      store.set('accounts', currentAccounts);
+      if (mainWindow) mainWindow.webContents.send('accounts-updated', currentAccounts);
+      updateTrayMenu();
+    }
+    console.log('[Sync] Sync cycle finished.');
+  };
+
+  if (isManual) await runScrapes(); else runScrapes();
 };
 
 const scheduleNextSync = () => {
-  setTimeout(async () => { await syncAccounts(); scheduleNextSync(); }, isDev ? 120000 : 1800000);
+  setTimeout(async () => { await syncAccounts(false); scheduleNextSync(); }, isDev ? 300000 : 1800000);
 };
 
 // --- Discovery ---
@@ -364,28 +328,21 @@ const handleLocalAccountsFound = async (localAccounts: LocalSteamAccount[]) => {
   }
 };
 
-// --- Main Window Creation ---
+// --- Main Window ---
 function createWindow() {
   mainWindow = new BrowserWindow({
     width: 1280, height: 800, title: "Ultimate Ban Tracker", backgroundColor: '#171a21', autoHideMenuBar: true,
     webPreferences: { preload: path.join(__dirname, 'preload.js'), nodeIntegration: false, contextIsolation: true }
   });
-  
   mainWindow.setMenu(null);
-  
   mainWindow.on('close', (event) => {
-    if (!(app as any).isQuitting) {
+    if (!(app as any).isQuitting) { event.preventDefault(); mainWindow?.hide(); }
-      event.preventDefault();
-      mainWindow?.hide();
-    }
     return false;
   });
-
   if (isDev) mainWindow.loadURL('http://localhost:5173');
   else mainWindow.loadFile(path.join(__dirname, '..', 'dist', 'index.html'));
 }
 
-// --- App Lifecycle ---
 app.whenReady().then(() => {
   protocol.handle('steam-resource', (request) => {
     let rawPath = decodeURIComponent(request.url.replace('steam-resource://', ''));
@@ -394,11 +351,10 @@ app.whenReady().then(() => {
     if (!fs.existsSync(absolutePath)) return new Response('Not Found', { status: 404 });
     try { return net.fetch(pathToFileURL(absolutePath).toString()); } catch (e) { return new Response('Error', { status: 500 }); }
   });
-
   createWindow();
   createTray();
   initBackend();
-  setTimeout(syncAccounts, 5000); 
+  setTimeout(() => syncAccounts(false), 5000); 
   scheduleNextSync();
   steamClient.startWatching(handleLocalAccountsFound);
 });
@@ -423,19 +379,17 @@ ipcMain.handle('login-to-server', async () => {
   if (!config.url) return false;
   return new Promise<boolean>((resolve) => {
     const authWindow = new BrowserWindow({
-      width: 800, height: 700, parent: mainWindow || undefined, modal: true, title: 'Login to Ban Tracker Server',
+      width: 800, height: 700, parent: mainWindow || undefined, modal: true, title: 'Login to Server',
       webPreferences: { nodeIntegration: false, contextIsolation: true }
     });
     authWindow.loadURL(`${config.url}/auth/steam`);
     let captured = false;
     const saveServerAuth = (token: string) => {
       if (captured) return; captured = true;
-      let serverSteamId = undefined;
+      let serverSteamId = undefined; let isAdmin = false;
-      let isAdmin = false;
       try { 
         const payload = JSON.parse(Buffer.from(token.split('.')[1]!, 'base64').toString()); 
-        serverSteamId = payload.steamId; 
+        serverSteamId = payload.steamId; isAdmin = !!payload.isAdmin;
-        isAdmin = !!payload.isAdmin;
       } catch (e) {}
       const current = store.get('serverConfig');
       store.set('serverConfig', { ...current, token, serverSteamId, isAdmin, enabled: true });
@@ -458,14 +412,12 @@ ipcMain.handle('login-to-server', async () => {
 });
 
 ipcMain.handle('get-server-user-info', () => ({ steamId: store.get('serverConfig').serverSteamId }));
-ipcMain.handle('sync-now', async () => { await syncAccounts(); return true; });
+ipcMain.handle('sync-now', async () => { await syncAccounts(true); return true; });
 
 ipcMain.handle('scrape-account', async (event, steamId: string) => {
   const accounts = store.get('accounts') as Account[];
   const account = accounts.find(a => a.steamId === steamId);
   if (!account) return false;
-  
-  console.log(`[Main] Manually triggering scrape for ${account.personaName}...`);
   const success = await scrapeAccountData(account);
   if (success) {
     store.set('accounts', accounts);
@@ -491,7 +443,7 @@ ipcMain.handle('add-account', async (event, { identifier }) => {
           loginName: existing.loginName || '', steamLoginSecure: existing.steamLoginSecure,
           loginConfig: existing.loginConfig, sessionUpdatedAt: existing.sessionUpdatedAt,
           autoCheckCooldown: !!existing.steamLoginSecure, status: (existing.vacBanned || existing.gameBans > 0) ? 'banned' : 'none',
-          lastBanCheck: new Date().toISOString()
+          lastBanCheck: new Date().toISOString(), sharedWith: existing.sharedWith
         };
         store.set('accounts', [...accounts, newAccount]);
         updateTrayMenu();
@@ -565,60 +517,35 @@ ipcMain.handle('switch-account', async (event, loginName: string) => await handl
 ipcMain.handle('open-external', (event, url: string) => shell.openExternal(url));
 
 ipcMain.handle('open-steam-app-login', async () => {
-  console.log('[SteamClient] Preparing for fresh login...');
   await killSteam();
-
   if (process.platform === 'win32') {
-    // Clear auto-login registry
     const clearReg = 'reg add "HKCU\\Software\\Valve\\Steam" /v AutoLoginUser /t REG_SZ /d "" /f';
     await new Promise<void>((res) => exec(clearReg, () => res()));
   } else if (process.platform === 'linux') {
-    // On Linux we can use the steamClient helper to set an empty user
     await steamClient.setAutoLoginUser("", undefined, "");
   }
-
   const command = process.platform === 'win32' ? 'start steam://open/login' : 'xdg-open steam://open/login';
   exec(command);
   return true;
 });
 
 ipcMain.handle('open-steam-login', async (event, expectedSteamId: string) => {
-  // Use a unique partition per account to prevent session bleeding
   const partitionId = expectedSteamId ? `persist:steam-login-${expectedSteamId}` : 'persist:steam-login-new';
   const loginSession = session.fromPartition(partitionId);
-
+  if (!expectedSteamId) await loginSession.clearStorageData({ storages: ['cookies', 'localstorage', 'indexdb'] });
-  // If adding a brand new account, explicitly clear previous trash
-  if (!expectedSteamId) {
-    console.log('[Auth] Clearing session for new account login...');
-    await loginSession.clearStorageData({ storages: ['cookies', 'localstorage', 'indexdb'] });
-  }
-
-  // If we have an existing cookie string for this account, pre-inject it
   if (expectedSteamId) {
     const accounts = store.get('accounts') as Account[];
     const account = accounts.find(a => a.steamId === expectedSteamId);
     if (account?.steamLoginSecure) {
-      console.log(`[Auth] Pre-injecting existing cookies for ${account.personaName}...`);
       const cookiePairs = account.steamLoginSecure.split(';').map(c => c.trim());
       for (const pair of cookiePairs) {
         const [name, value] = pair.split('=');
         if (name && value) {
-          try {
+          try { await loginSession.cookies.set({ url: 'https://steamcommunity.com', domain: 'steamcommunity.com', name, value, path: '/', secure: true, httpOnly: name.includes('Secure') }); } catch (e) {}
-            await loginSession.cookies.set({
-              url: 'https://steamcommunity.com',
-              domain: 'steamcommunity.com',
-              name: name,
-              value: value,
-              path: '/',
-              secure: true,
-              httpOnly: name.includes('Secure')
-            });
-          } catch (e) {}
         }
       }
     }
   }
-
   return new Promise<boolean>((resolve) => {
     const loginWindow = new BrowserWindow({
       width: 800, height: 700, parent: mainWindow || undefined, modal: true, title: 'Login to Steam',