Merge pull request 'release/v1.3.1' (#8) from release/v1.3.1 into main

Reviewed-on: #8

frontend/dist-electron/main.js

@@ -60,23 +60,9 @@ const initBackend = () => {
 };
 // --- System Tray ---
 const createTray = () => {
-    // Try to find the icon in various standard locations
+    const assetsDir = path_1.default.join(__dirname, '..', 'assets-build');
-    const possiblePaths = [
+    const possibleIcons = ['icon.svg', 'icon.png'];
-        path_1.default.join(__dirname, '..', 'assets-build'), // Dev
-        path_1.default.join(process.resourcesPath, 'assets-build'), // Packaged (External)
-        path_1.default.join(electron_1.app.getAppPath(), 'dist', 'assets-build'), // Packaged (Internal dist)
-        path_1.default.join(electron_1.app.getAppPath(), 'assets-build') // Packaged (Internal root)
-    ];
-    let assetsDir = '';
-    for (const p of possiblePaths) {
-        if (fs_1.default.existsSync(p)) {
-            assetsDir = p;
-            break;
-        }
-    }
-    const possibleIcons = ['icon.png', 'icon.svg'];
     let iconPath = '';
-    if (assetsDir) {
     for (const name of possibleIcons) {
         const fullPath = path_1.default.join(assetsDir, name);
         if (fs_1.default.existsSync(fullPath)) {
@@ -84,13 +70,8 @@ const createTray = () => {
             break;
         }
     }
-    }
+    if (!iconPath)
-    console.log(`[Tray] Resolved assets directory: ${assetsDir || 'NOT FOUND'}`);
-    console.log(`[Tray] Attempting to initialize with icon: ${iconPath || 'NONE FOUND'}`);
-    if (!iconPath) {
-        console.warn(`[Tray] FAILED: No valid icon found in searched paths.`);
         return;
-    }
     try {
         const icon = electron_1.nativeImage.createFromPath(iconPath).resize({ width: 16, height: 16 });
         tray = new electron_1.Tray(icon);
@@ -188,12 +169,12 @@ const scrapeAccountData = async (account) => {
                 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, now.toISOString());
+                        await backend.pushCooldown(account.steamId, account.cooldownExpiresAt);
                 }
                 else {
                     account.cooldownExpiresAt = undefined;
                     if (backend)
-                        await backend.pushCooldown(account.steamId, undefined, now.toISOString());
+                        await backend.pushCooldown(account.steamId, undefined);
                 }
             }
             catch (e) {
@@ -250,24 +231,8 @@ const syncAccounts = async (isManual = false) => {
                         exists.sessionUpdatedAt = s.sessionUpdatedAt;
                         hasChanges = true;
                     }
-                    // Metadata Sync (Pull)
+                    if (s.cooldownExpiresAt && (!exists.cooldownExpiresAt || new Date(s.cooldownExpiresAt) > new Date(exists.cooldownExpiresAt))) {
-                    const sMetaDate = s.lastMetadataCheck ? new Date(s.lastMetadataCheck) : new Date(0);
-                    const lMetaDate = exists.lastBanCheck ? new Date(exists.lastBanCheck) : new Date(0);
-                    if (sMetaDate > lMetaDate) {
-                        exists.personaName = s.personaName;
-                        exists.avatar = s.avatar;
-                        exists.vacBanned = s.vacBanned;
-                        exists.gameBans = s.gameBans;
-                        exists.status = (s.vacBanned || s.gameBans > 0) ? 'banned' : 'none';
-                        exists.lastBanCheck = s.lastMetadataCheck;
-                        hasChanges = true;
-                    }
-                    // Cooldown Sync (Pull)
-                    const sScrapeDate = s.lastScrapeTime ? new Date(s.lastScrapeTime) : new Date(0);
-                    const lScrapeDate = exists.lastScrapeTime ? new Date(exists.lastScrapeTime) : new Date(0);
-                    if (sScrapeDate > lScrapeDate) {
                         exists.cooldownExpiresAt = s.cooldownExpiresAt;
-                        exists.lastScrapeTime = s.lastScrapeTime;
                         hasChanges = true;
                     }
                     if (JSON.stringify(exists.sharedWith) !== JSON.stringify(s.sharedWith)) {
@@ -345,20 +310,11 @@ const handleLocalAccountsFound = async (localAccounts) => {
                 const profile = await (0, steam_web_1.fetchProfileData)(local.steamId);
                 const bans = await (0, steam_web_1.scrapeBanStatus)(profile.profileUrl);
                 const localPath = await downloadAvatar(profile.steamId, profile.avatar);
-                // Wait and retry snagging the config (Steam takes time to write it)
-                let loginConfig = undefined;
-                for (let i = 0; i < 3; i++) {
-                    await new Promise(r => setTimeout(r, 2000));
-                    loginConfig = steam_client_1.steamClient.extractAccountConfig(local.accountName);
-                    if (loginConfig)
-                        break;
-                }
                 currentAccounts.push({
                     _id: Date.now().toString() + Math.random().toString().slice(2, 5),
                     steamId: local.steamId, personaName: profile.personaName || local.accountName,
                     loginName: local.accountName, autoCheckCooldown: false, avatar: profile.avatar,
                     localAvatar: localPath, profileUrl: profile.profileUrl,
-                    loginConfig, sessionUpdatedAt: loginConfig ? new Date().toISOString() : undefined,
                     status: (bans.vacBanned || bans.gameBans > 0) ? 'banned' : 'none',
                     vacBanned: bans.vacBanned, gameBans: bans.gameBans, lastBanCheck: new Date().toISOString()
                 });
@@ -588,46 +544,7 @@ electron_1.ipcMain.handle('admin-delete-user', async (event, userId) => { initBa
 electron_1.ipcMain.handle('admin-get-accounts', async () => { initBackend(); return backend ? await backend.getAdminAccounts() : []; });
 electron_1.ipcMain.handle('admin-remove-account', async (event, steamId) => { initBackend(); if (backend)
     await backend.forceRemoveAccount(steamId); return true; });
-electron_1.ipcMain.handle('switch-account', async (event, loginName) => {
+electron_1.ipcMain.handle('switch-account', async (event, loginName) => await handleSwitchAccount(loginName));
-    if (!loginName)
-        return false;
-    try {
-        // PROACTIVE SYNC: Try to snag the freshest token before we kill Steam
-        const accounts = store.get('accounts');
-        const account = accounts.find(a => a.loginName === loginName);
-        if (account && !account._id.startsWith('shared_')) {
-            const freshConfig = steam_client_1.steamClient.extractAccountConfig(loginName);
-            if (freshConfig) {
-                account.loginConfig = freshConfig;
-                account.sessionUpdatedAt = new Date().toISOString();
-                if (backend)
-                    await backend.shareAccount(account);
-                store.set('accounts', accounts);
-            }
-        }
-        await killSteam();
-        if (process.platform === 'win32') {
-            const regBase = 'reg add "HKCU\\Software\\Valve\\Steam"';
-            const commands = [
-                `${regBase} /v AutoLoginUser /t REG_SZ /d "${loginName}" /f`,
-                `${regBase} /v RememberPassword /t REG_DWORD /d 1 /f`,
-                `${regBase} /v AlreadyLoggedIn /t REG_DWORD /d 1 /f`,
-                `${regBase} /v WantsOfflineMode /t REG_DWORD /d 0 /f`
-            ];
-            await new Promise((res, rej) => (0, child_process_1.exec)(commands.join(' && '), (e) => e ? rej(e) : res()));
-            if (account && account.loginConfig)
-                steam_client_1.steamClient.injectAccountConfig(loginName, account.loginConfig);
-        }
-        else if (process.platform === 'linux') {
-            await steam_client_1.steamClient.setAutoLoginUser(loginName, account?.loginConfig, account?.steamId);
-        }
-        startSteam();
-        return true;
-    }
-    catch (e) {
-        return false;
-    }
-});
 electron_1.ipcMain.handle('open-external', (event, url) => electron_1.shell.openExternal(url));
 electron_1.ipcMain.handle('open-steam-app-login', async () => {
     await killSteam();

frontend/dist-electron/services/backend.js

@@ -68,23 +68,19 @@ class BackendService {
                 loginName: account.loginName,
                 steamLoginSecure: account.steamLoginSecure,
                 loginConfig: account.loginConfig,
-                sessionUpdatedAt: account.sessionUpdatedAt,
+                sessionUpdatedAt: account.sessionUpdatedAt
-                lastMetadataCheck: account.lastBanCheck,
-                lastScrapeTime: account.lastScrapeTime,
-                cooldownExpiresAt: account.cooldownExpiresAt
             }, { headers: this.headers });
         }
         catch (e) {
             console.error('[Backend] Failed to share account');
         }
     }
-    async pushCooldown(steamId, cooldownExpiresAt, lastScrapeTime) {
+    async pushCooldown(steamId, cooldownExpiresAt) {
         if (!this.token)
             return;
         try {
             await axios_1.default.patch(`${this.url}/api/sync/${steamId}/cooldown`, {
-                cooldownExpiresAt,
+                cooldownExpiresAt
-                lastScrapeTime
             }, { headers: this.headers });
         }
         catch (e) {

frontend/dist-electron/services/scraper.js

@@ -57,25 +57,19 @@ const scrapeCooldown = async (steamId, steamLoginSecure) => {
         let expirationDate = undefined;
         $('table').each((_, table) => {
             const headers = $(table).find('th').map((_, th) => $(th).text().trim()).get();
-            const expirationIndex = headers.findIndex(h => h.includes('Competitive Cooldown Expiration') || h.includes('Cooldown Expiration'));
+            const expirationIndex = headers.findIndex(h => h.includes('Competitive Cooldown Expiration'));
             if (expirationIndex !== -1) {
-                const rows = $(table).find('tr').not(':has(th)');
+                const firstRow = $(table).find('tr').not(':has(th)').first();
-                rows.each((_, row) => {
+                const dateText = firstRow.find('td').eq(expirationIndex).text().trim();
-                    const dateText = $(row).find('td').eq(expirationIndex).text().trim();
                 if (dateText && dateText !== '') {
-                        // Steam uses 'GMT' which some JS engines don't parse well, replace with 'UTC'
                     const cleanDateText = dateText.replace(' GMT', ' UTC');
                     const parsed = new Date(cleanDateText);
                     if (!isNaN(parsed.getTime())) {
-                            // We want the newest expiration date found
-                            if (!expirationDate || parsed > expirationDate) {
                         expirationDate = parsed;
                     }
                 }
             }
         });
-            }
-        });
         if (expirationDate && expirationDate.getTime() > Date.now()) {
             console.log(`[Scraper] Found active cooldown until: ${expirationDate.toISOString()}`);
             return {

frontend/dist-electron/services/steam-client.js

@@ -21,8 +21,7 @@ class SteamClientService {
         if (platform === 'win32') {
             const possiblePaths = [
                 'C:\\Program Files (x86)\\Steam',
-                'C:\\Program Files\\Steam',
+                'C:\\Program Files\\Steam'
-                path_1.default.join(process.env.APPDATA || '', 'Steam'),
             ];
             this.steamPath = possiblePaths.find(p => fs_1.default.existsSync(p)) || null;
         }
@@ -30,8 +29,7 @@ class SteamClientService {
             const possiblePaths = [
                 path_1.default.join(home, '.steam/steam'),
                 path_1.default.join(home, '.local/share/Steam'),
-                path_1.default.join(home, '.var/app/com.valvesoftware.Steam/.steam/steam'), // Flatpak
+                path_1.default.join(home, '.var/app/com.valvesoftware.Steam/.steam/steam')
-                path_1.default.join(home, 'snap/steam/common/.steam/steam'), // Snap
             ];
             this.steamPath = possiblePaths.find(p => fs_1.default.existsSync(p)) || null;
         }
@@ -49,35 +47,12 @@ class SteamClientService {
             return null;
         return path_1.default.join(this.steamPath, 'config', 'config.vdf');
     }
-    /**
-     * Safe Atomic Write: Writes to a temp file and renames it.
-     * This prevents file corruption if the app crashes during write.
-     */
-    safeWriteVdf(filePath, data) {
-        const tempPath = `${filePath}.tmp_${Date.now()}`;
-        const dir = path_1.default.dirname(filePath);
-        try {
-            if (!fs_1.default.existsSync(dir))
-                fs_1.default.mkdirSync(dir, { recursive: true });
-            const vdfContent = (0, simple_vdf_1.stringify)(data);
-            fs_1.default.writeFileSync(tempPath, vdfContent, 'utf-8');
-            // Atomic rename
-            fs_1.default.renameSync(tempPath, filePath);
-        }
-        catch (e) {
-            console.error(`[SteamClient] Atomic write failed for ${filePath}: ${e.message}`);
-            if (fs_1.default.existsSync(tempPath))
-                fs_1.default.unlinkSync(tempPath);
-            throw e;
-        }
-    }
     startWatching(callback) {
         this.onAccountsChanged = callback;
         const loginUsersPath = this.getLoginUsersPath();
         if (loginUsersPath && fs_1.default.existsSync(loginUsersPath)) {
             this.readLocalAccounts();
-            chokidar_1.default.watch(loginUsersPath, { persistent: true, ignoreInitial: true }).on('change', () => {
+            chokidar_1.default.watch(loginUsersPath, { persistent: true }).on('change', () => {
-                console.log(`[SteamClient] loginusers.vdf changed, re-scanning...`);
                 this.readLocalAccounts();
             });
         }
@@ -88,20 +63,16 @@ class SteamClientService {
             return;
         try {
             const content = fs_1.default.readFileSync(filePath, 'utf-8');
-            if (!content.trim())
-                return; // Empty file
             const data = (0, simple_vdf_1.parse)(content);
             if (!data || !data.users)
                 return;
             const accounts = [];
             for (const [steamId64, userData] of Object.entries(data.users)) {
                 const user = userData;
-                if (!user || !user.AccountName)
-                    continue;
                 accounts.push({
                     steamId: steamId64,
                     accountName: user.AccountName,
-                    personaName: user.PersonaName || user.AccountName,
+                    personaName: user.PersonaName,
                     timestamp: parseInt(user.Timestamp) || 0
                 });
             }
@@ -120,38 +91,32 @@ class SteamClientService {
             const content = fs_1.default.readFileSync(configPath, 'utf-8');
             const data = (0, simple_vdf_1.parse)(content);
             const accounts = data?.InstallConfigStore?.Software?.Valve?.Steam?.Accounts;
-            return (accounts && accounts[accountName]) ? accounts[accountName] : null;
+            if (accounts && accounts[accountName]) {
+                return accounts[accountName];
+            }
         }
         catch (e) {
             console.error('[SteamClient] Failed to extract config.vdf data');
-            return null;
         }
+        return null;
     }
     injectAccountConfig(accountName, accountData) {
         const configPath = this.getConfigVdfPath();
         if (!configPath)
             return;
-        let data = {
+        // Create directory if it doesn't exist
-            InstallConfigStore: {
+        const configDir = path_1.default.dirname(configPath);
-                Software: {
+        if (!fs_1.default.existsSync(configDir))
-                    Valve: {
+            fs_1.default.mkdirSync(configDir, { recursive: true });
-                        Steam: {
+        let data = { InstallConfigStore: { Software: { Valve: { Steam: { Accounts: {} } } } } };
-                            Accounts: {}
-                        }
-                    }
-                }
-            }
-        };
         if (fs_1.default.existsSync(configPath)) {
             try {
                 const content = fs_1.default.readFileSync(configPath, 'utf-8');
-                const parsed = (0, simple_vdf_1.parse)(content);
+                data = (0, simple_vdf_1.parse)(content);
-                if (parsed && typeof parsed === 'object')
-                    data = parsed;
             }
             catch (e) { }
         }
-        // Ensure safe nesting
+        // Ensure structure exists
         if (!data.InstallConfigStore)
             data.InstallConfigStore = {};
         if (!data.InstallConfigStore.Software)
@@ -164,22 +129,25 @@ class SteamClientService {
             data.InstallConfigStore.Software.Valve.Steam.Accounts = {};
         data.InstallConfigStore.Software.Valve.Steam.Accounts[accountName] = accountData;
         try {
-            this.safeWriteVdf(configPath, data);
+            fs_1.default.writeFileSync(configPath, (0, simple_vdf_1.stringify)(data));
-            console.log(`[SteamClient] Safely injected session for ${accountName}`);
+            console.log(`[SteamClient] Injected login config for ${accountName} into config.vdf`);
+        }
+        catch (e) {
+            console.error('[SteamClient] Failed to write config.vdf');
         }
-        catch (e) { }
     }
     async setAutoLoginUser(accountName, accountConfig, steamId) {
         const platform = os_1.default.platform();
         const loginUsersPath = this.getLoginUsersPath();
         if (loginUsersPath) {
+            const configDir = path_1.default.dirname(loginUsersPath);
+            if (!fs_1.default.existsSync(configDir))
+                fs_1.default.mkdirSync(configDir, { recursive: true });
             let data = { users: {} };
             if (fs_1.default.existsSync(loginUsersPath)) {
                 try {
                     const content = fs_1.default.readFileSync(loginUsersPath, 'utf-8');
-                    const parsed = (0, simple_vdf_1.parse)(content);
+                    data = (0, simple_vdf_1.parse)(content);
-                    if (parsed && parsed.users)
-                        data = parsed;
                 }
                 catch (e) { }
             }
@@ -188,7 +156,7 @@ class SteamClientService {
             let found = false;
             for (const [id, user] of Object.entries(data.users)) {
                 const u = user;
-                if (u.AccountName?.toLowerCase() === accountName.toLowerCase()) {
+                if (u.AccountName.toLowerCase() === accountName.toLowerCase()) {
                     u.mostrecent = "1";
                     u.RememberPassword = "1";
                     u.AllowAutoLogin = "1";
@@ -201,8 +169,8 @@ class SteamClientService {
                     u.mostrecent = "0";
                 }
             }
-            if (!found && steamId && accountName) {
+            if (!found && steamId) {
-                console.log(`[SteamClient] Provisioning new user profile for ${accountName}`);
+                console.log(`[SteamClient] Provisioning user ${accountName} into loginusers.vdf`);
                 data.users[steamId] = {
                     AccountName: accountName,
                     PersonaName: accountName,
@@ -216,53 +184,51 @@ class SteamClientService {
                 };
             }
             try {
-                this.safeWriteVdf(loginUsersPath, data);
+                fs_1.default.writeFileSync(loginUsersPath, (0, simple_vdf_1.stringify)(data));
             }
-            catch (e) { }
+            catch (e) {
+                console.error('[SteamClient] Failed to write loginusers.vdf');
             }
-        if (accountConfig && accountName) {
+        }
+        if (accountConfig) {
             this.injectAccountConfig(accountName, accountConfig);
         }
-        // --- Linux Registry / Registry.vdf Hardening ---
         if (platform === 'linux') {
             const regLocations = [
                 path_1.default.join(os_1.default.homedir(), '.steam', 'registry.vdf'),
                 path_1.default.join(os_1.default.homedir(), '.steam', 'steam', 'registry.vdf')
             ];
             for (const regPath of regLocations) {
-                if (!fs_1.default.existsSync(path_1.default.dirname(regPath)))
+                let regData = { Registry: { HKCU: { Software: { Valve: { Steam: {} } } } } };
-                    continue;
-                let regData = { Registry: { HKCU: { Software: { Valve: { Steam: {
-                                        AutoLoginUser: "",
-                                        RememberPassword: "1",
-                                        AlreadyLoggedIn: "1"
-                                    } } } } } };
                 if (fs_1.default.existsSync(regPath)) {
                     try {
                         const content = fs_1.default.readFileSync(regPath, 'utf-8');
-                        const parsed = (0, simple_vdf_1.parse)(content);
+                        regData = (0, simple_vdf_1.parse)(content);
-                        if (parsed && typeof parsed === 'object')
-                            regData = parsed;
                     }
                     catch (e) { }
                 }
-                // Deep merge helper
+                else {
-                const ensurePath = (obj, keys) => {
+                    const regDir = path_1.default.dirname(regPath);
-                    let curr = obj;
+                    if (!fs_1.default.existsSync(regDir))
-                    for (const key of keys) {
+                        fs_1.default.mkdirSync(regDir, { recursive: true });
-                        if (!curr[key] || typeof curr[key] !== 'object')
-                            curr[key] = {};
-                        curr = curr[key];
                 }
-                    return curr;
+                const setPath = (obj, keys, val) => {
+                    let curr = obj;
+                    for (let i = 0; i < keys.length - 1; i++) {
+                        if (!curr[keys[i]])
+                            curr[keys[i]] = {};
+                        curr = curr[keys[i]];
+                    }
+                    curr[keys[keys.length - 1]] = val;
                 };
-                const steamKey = ensurePath(regData, ['Registry', 'HKCU', 'Software', 'Valve', 'Steam']);
+                const steamReg = ['Registry', 'HKCU', 'Software', 'Valve', 'Steam'];
-                steamKey.AutoLoginUser = accountName;
+                setPath(regData, [...steamReg, 'AutoLoginUser'], accountName);
-                steamKey.RememberPassword = "1";
+                setPath(regData, [...steamReg, 'RememberPassword'], "1");
-                steamKey.AlreadyLoggedIn = "1";
+                setPath(regData, [...steamReg, 'AlreadyLoggedIn'], "1");
-                steamKey.WantsOfflineMode = "0";
+                setPath(regData, [...steamReg, 'WantsOfflineMode'], "0");
                 try {
-                    this.safeWriteVdf(regPath, regData);
+                    fs_1.default.writeFileSync(regPath, (0, simple_vdf_1.stringify)(regData));
+                    console.log(`[SteamClient] Registry updated: ${regPath}`);
                 }
                 catch (e) { }
             }

frontend/electron/main.ts

@@ -215,10 +215,10 @@ const scrapeAccountData = async (account: Account) => {
         account.authError = false; 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, now.toISOString());
+          if (backend) await backend.pushCooldown(account.steamId, account.cooldownExpiresAt);
         } else {
           account.cooldownExpiresAt = undefined;
-          if (backend) await backend.pushCooldown(account.steamId, undefined, now.toISOString());
+          if (backend) await backend.pushCooldown(account.steamId, undefined);
         }
       } catch (e: any) {
         if (e.message.includes('cookie') || e.message.includes('Sign In')) account.authError = true;
@@ -267,29 +267,10 @@ const syncAccounts = async (isManual = false) => {
             exists.sessionUpdatedAt = s.sessionUpdatedAt;
             hasChanges = true;
           }
-          
+          if (s.cooldownExpiresAt && (!exists.cooldownExpiresAt || new Date(s.cooldownExpiresAt) > new Date(exists.cooldownExpiresAt))) {
-          // Metadata Sync (Pull)
-          const sMetaDate = s.lastMetadataCheck ? new Date(s.lastMetadataCheck) : new Date(0);
-          const lMetaDate = exists.lastBanCheck ? new Date(exists.lastBanCheck) : new Date(0);
-          if (sMetaDate > lMetaDate) {
-            exists.personaName = s.personaName;
-            exists.avatar = s.avatar;
-            exists.vacBanned = s.vacBanned;
-            exists.gameBans = s.gameBans;
-            exists.status = (s.vacBanned || s.gameBans > 0) ? 'banned' : 'none';
-            exists.lastBanCheck = s.lastMetadataCheck;
-            hasChanges = true;
-          }
-
-          // Cooldown Sync (Pull)
-          const sScrapeDate = s.lastScrapeTime ? new Date(s.lastScrapeTime) : new Date(0);
-          const lScrapeDate = exists.lastScrapeTime ? new Date(exists.lastScrapeTime) : new Date(0);
-          if (sScrapeDate > lScrapeDate) {
             exists.cooldownExpiresAt = s.cooldownExpiresAt;
-            exists.lastScrapeTime = s.lastScrapeTime;
             hasChanges = true;
           }
-
           if (JSON.stringify(exists.sharedWith) !== JSON.stringify(s.sharedWith)) {
             exists.sharedWith = s.sharedWith;
             hasChanges = true;
@@ -356,21 +337,11 @@ const handleLocalAccountsFound = async (localAccounts: LocalSteamAccount[]) => {
         const profile = await fetchProfileData(local.steamId);
         const bans = await scrapeBanStatus(profile.profileUrl);
         const localPath = await downloadAvatar(profile.steamId, profile.avatar);
-        
-        // Wait and retry snagging the config (Steam takes time to write it)
-        let loginConfig = undefined;
-        for (let i = 0; i < 3; i++) {
-          await new Promise(r => setTimeout(r, 2000));
-          loginConfig = steamClient.extractAccountConfig(local.accountName);
-          if (loginConfig) break;
-        }
-
         currentAccounts.push({
           _id: Date.now().toString() + Math.random().toString().slice(2, 5),
           steamId: local.steamId, personaName: profile.personaName || local.accountName,
           loginName: local.accountName, autoCheckCooldown: false, avatar: profile.avatar,
           localAvatar: localPath, profileUrl: profile.profileUrl,
-          loginConfig, sessionUpdatedAt: loginConfig ? new Date().toISOString() : undefined,
           status: (bans.vacBanned || bans.gameBans > 0) ? 'banned' : 'none',
           vacBanned: bans.vacBanned, gameBans: bans.gameBans, lastBanCheck: new Date().toISOString()
         });
@@ -571,42 +542,7 @@ ipcMain.handle('admin-delete-user', async (event, userId: string) => { initBacke
 ipcMain.handle('admin-get-accounts', async () => { initBackend(); return backend ? await backend.getAdminAccounts() : []; });
 ipcMain.handle('admin-remove-account', async (event, steamId: string) => { initBackend(); if (backend) await backend.forceRemoveAccount(steamId); return true; });
 
-ipcMain.handle('switch-account', async (event, loginName: string) => {
+ipcMain.handle('switch-account', async (event, loginName: string) => await handleSwitchAccount(loginName));
-  if (!loginName) return false;
-  try {
-    // PROACTIVE SYNC: Try to snag the freshest token before we kill Steam
-    const accounts = store.get('accounts') as Account[];
-    const account = accounts.find(a => a.loginName === loginName);
-    if (account && !account._id.startsWith('shared_')) {
-      const freshConfig = steamClient.extractAccountConfig(loginName);
-      if (freshConfig) {
-        account.loginConfig = freshConfig;
-        account.sessionUpdatedAt = new Date().toISOString();
-        if (backend) await backend.shareAccount(account);
-        store.set('accounts', accounts);
-      }
-    }
-
-    await killSteam();
-    
-    if (process.platform === 'win32') {
-      const regBase = 'reg add "HKCU\\Software\\Valve\\Steam"';
-      const commands = [
-        `${regBase} /v AutoLoginUser /t REG_SZ /d "${loginName}" /f`,
-        `${regBase} /v RememberPassword /t REG_DWORD /d 1 /f`,
-        `${regBase} /v AlreadyLoggedIn /t REG_DWORD /d 1 /f`,
-        `${regBase} /v WantsOfflineMode /t REG_DWORD /d 0 /f`
-      ];
-      await new Promise<void>((res, rej) => exec(commands.join(' && '), (e) => e ? rej(e) : res()));
-      if (account && account.loginConfig) steamClient.injectAccountConfig(loginName, account.loginConfig);
-    } else if (process.platform === 'linux') {
-      await steamClient.setAutoLoginUser(loginName, account?.loginConfig, account?.steamId);
-    }
-    startSteam();
-    return true;
-  } catch (e) { return false; }
-});
-
 ipcMain.handle('open-external', (event, url: string) => shell.openExternal(url));
 
 ipcMain.handle('open-steam-app-login', async () => {

frontend/electron/services/backend.ts

@@ -62,22 +62,18 @@ export class BackendService {
         loginName: account.loginName,
         steamLoginSecure: account.steamLoginSecure,
         loginConfig: account.loginConfig,
-        sessionUpdatedAt: account.sessionUpdatedAt,
+        sessionUpdatedAt: account.sessionUpdatedAt
-        lastMetadataCheck: account.lastBanCheck,
-        lastScrapeTime: account.lastScrapeTime,
-        cooldownExpiresAt: account.cooldownExpiresAt
       }, { headers: this.headers });
     } catch (e) {
       console.error('[Backend] Failed to share account');
     }
   }
 
-  public async pushCooldown(steamId: string, cooldownExpiresAt?: string, lastScrapeTime?: string) {
+  public async pushCooldown(steamId: string, cooldownExpiresAt?: string) {
     if (!this.token) return;
     try {
       await axios.patch(`${this.url}/api/sync/${steamId}/cooldown`, {
-        cooldownExpiresAt,
+        cooldownExpiresAt
-        lastScrapeTime
       }, { headers: this.headers });
     } catch (e) {
       console.error(`[Backend] Failed to push cooldown for ${steamId}`);

frontend/electron/services/scraper.ts

@@ -29,27 +29,22 @@ export const scrapeCooldown = async (steamId: string, steamLoginSecure: string):
 
     $('table').each((_, table) => {
       const headers = $(table).find('th').map((_, th) => $(th).text().trim()).get();
-      const expirationIndex = headers.findIndex(h => h.includes('Competitive Cooldown Expiration') || h.includes('Cooldown Expiration'));
+      const expirationIndex = headers.findIndex(h => h.includes('Competitive Cooldown Expiration'));
 
       if (expirationIndex !== -1) {
-        const rows = $(table).find('tr').not(':has(th)');
+        const firstRow = $(table).find('tr').not(':has(th)').first();
-        rows.each((_, row) => {
+        const dateText = firstRow.find('td').eq(expirationIndex).text().trim();
-          const dateText = $(row).find('td').eq(expirationIndex).text().trim();
+
         if (dateText && dateText !== '') {
-            // Steam uses 'GMT' which some JS engines don't parse well, replace with 'UTC'
           const cleanDateText = dateText.replace(' GMT', ' UTC');
           const parsed = new Date(cleanDateText);
           
           if (!isNaN(parsed.getTime())) {
-              // We want the newest expiration date found
-              if (!expirationDate || parsed > (expirationDate as Date)) {
             expirationDate = parsed;
           }
         }
       }
     });
-      }
-    });
 
     if (expirationDate && (expirationDate as Date).getTime() > Date.now()) {
       console.log(`[Scraper] Found active cooldown until: ${(expirationDate as Date).toISOString()}`);

frontend/electron/services/steam-client.ts

@@ -26,16 +26,14 @@ class SteamClientService {
     if (platform === 'win32') {
       const possiblePaths = [
         'C:\\Program Files (x86)\\Steam',
-        'C:\\Program Files\\Steam',
+        'C:\\Program Files\\Steam'
-        path.join(process.env.APPDATA || '', 'Steam'),
       ];
       this.steamPath = possiblePaths.find(p => fs.existsSync(p)) || null;
     } else if (platform === 'linux') {
       const possiblePaths = [
         path.join(home, '.steam/steam'),
         path.join(home, '.local/share/Steam'),
-        path.join(home, '.var/app/com.valvesoftware.Steam/.steam/steam'), // Flatpak
+        path.join(home, '.var/app/com.valvesoftware.Steam/.steam/steam')
-        path.join(home, 'snap/steam/common/.steam/steam'), // Snap
       ];
       this.steamPath = possiblePaths.find(p => fs.existsSync(p)) || null;
     }
@@ -55,36 +53,13 @@ class SteamClientService {
     return path.join(this.steamPath, 'config', 'config.vdf');
   }
 
-  /**
-   * Safe Atomic Write: Writes to a temp file and renames it.
-   * This prevents file corruption if the app crashes during write.
-   */
-  private safeWriteVdf(filePath: string, data: any) {
-    const tempPath = `${filePath}.tmp_${Date.now()}`;
-    const dir = path.dirname(filePath);
-    
-    try {
-      if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
-      const vdfContent = stringify(data);
-      fs.writeFileSync(tempPath, vdfContent, 'utf-8');
-      
-      // Atomic rename
-      fs.renameSync(tempPath, filePath);
-    } catch (e: any) {
-      console.error(`[SteamClient] Atomic write failed for ${filePath}: ${e.message}`);
-      if (fs.existsSync(tempPath)) fs.unlinkSync(tempPath);
-      throw e;
-    }
-  }
-
   public startWatching(callback: (accounts: LocalSteamAccount[]) => void) {
     this.onAccountsChanged = callback;
     const loginUsersPath = this.getLoginUsersPath();
 
     if (loginUsersPath && fs.existsSync(loginUsersPath)) {
       this.readLocalAccounts();
-      chokidar.watch(loginUsersPath, { persistent: true, ignoreInitial: true }).on('change', () => {
+      chokidar.watch(loginUsersPath, { persistent: true }).on('change', () => {
-        console.log(`[SteamClient] loginusers.vdf changed, re-scanning...`);
         this.readLocalAccounts();
       });
     }
@@ -96,20 +71,16 @@ class SteamClientService {
 
     try {
       const content = fs.readFileSync(filePath, 'utf-8');
-      if (!content.trim()) return; // Empty file
-
       const data = parse(content) as any;
       if (!data || !data.users) return;
 
       const accounts: LocalSteamAccount[] = [];
       for (const [steamId64, userData] of Object.entries(data.users)) {
         const user = userData as any;
-        if (!user || !user.AccountName) continue;
-        
         accounts.push({
           steamId: steamId64,
           accountName: user.AccountName,
-          personaName: user.PersonaName || user.AccountName,
+          personaName: user.PersonaName,
           timestamp: parseInt(user.Timestamp) || 0
         });
       }
@@ -127,39 +98,35 @@ class SteamClientService {
     try {
       const content = fs.readFileSync(configPath, 'utf-8');
       const data = parse(content) as any;
+      
       const accounts = data?.InstallConfigStore?.Software?.Valve?.Steam?.Accounts;
-      return (accounts && accounts[accountName]) ? accounts[accountName] : null;
+      if (accounts && accounts[accountName]) {
+        return accounts[accountName];
+      }
     } catch (e) {
       console.error('[SteamClient] Failed to extract config.vdf data');
-      return null;
     }
+    return null;
   }
 
   public injectAccountConfig(accountName: string, accountData: any) {
     const configPath = this.getConfigVdfPath();
     if (!configPath) return;
 
-    let data: any = { 
+    // Create directory if it doesn't exist
-      InstallConfigStore: { 
+    const configDir = path.dirname(configPath);
-        Software: { 
+    if (!fs.existsSync(configDir)) fs.mkdirSync(configDir, { recursive: true });
-          Valve: { 
+
-            Steam: { 
+    let data: any = { InstallConfigStore: { Software: { Valve: { Steam: { Accounts: {} } } } } };
-              Accounts: {} 
-            } 
-          } 
-        } 
-      } 
-    };
 
     if (fs.existsSync(configPath)) {
       try {
         const content = fs.readFileSync(configPath, 'utf-8');
-        const parsed = parse(content) as any;
+        data = parse(content) as any;
-        if (parsed && typeof parsed === 'object') data = parsed;
       } catch (e) { }
     }
 
-    // Ensure safe nesting
+    // Ensure structure exists
     if (!data.InstallConfigStore) data.InstallConfigStore = {};
     if (!data.InstallConfigStore.Software) data.InstallConfigStore.Software = {};
     if (!data.InstallConfigStore.Software.Valve) data.InstallConfigStore.Software.Valve = {};
@@ -169,9 +136,11 @@ class SteamClientService {
     data.InstallConfigStore.Software.Valve.Steam.Accounts[accountName] = accountData;
 
     try {
-      this.safeWriteVdf(configPath, data);
+      fs.writeFileSync(configPath, stringify(data));
-      console.log(`[SteamClient] Safely injected session for ${accountName}`);
+      console.log(`[SteamClient] Injected login config for ${accountName} into config.vdf`);
-    } catch (e) { }
+    } catch (e) {
+      console.error('[SteamClient] Failed to write config.vdf');
+    }
   }
 
   public async setAutoLoginUser(accountName: string, accountConfig?: any, steamId?: string): Promise<boolean> {
@@ -179,12 +148,14 @@ class SteamClientService {
     const loginUsersPath = this.getLoginUsersPath();
 
     if (loginUsersPath) {
+      const configDir = path.dirname(loginUsersPath);
+      if (!fs.existsSync(configDir)) fs.mkdirSync(configDir, { recursive: true });
+
       let data: any = { users: {} };
       if (fs.existsSync(loginUsersPath)) {
         try {
           const content = fs.readFileSync(loginUsersPath, 'utf-8');
-          const parsed = parse(content) as any;
+          data = parse(content) as any;
-          if (parsed && parsed.users) data = parsed;
         } catch (e) { }
       }
 
@@ -193,7 +164,7 @@ class SteamClientService {
       let found = false;
       for (const [id, user] of Object.entries(data.users)) {
         const u = user as any;
-        if (u.AccountName?.toLowerCase() === accountName.toLowerCase()) {
+        if (u.AccountName.toLowerCase() === accountName.toLowerCase()) {
           u.mostrecent = "1";
           u.RememberPassword = "1";
           u.AllowAutoLogin = "1";
@@ -206,8 +177,8 @@ class SteamClientService {
         }
       }
 
-      if (!found && steamId && accountName) {
+      if (!found && steamId) {
-        console.log(`[SteamClient] Provisioning new user profile for ${accountName}`);
+        console.log(`[SteamClient] Provisioning user ${accountName} into loginusers.vdf`);
         data.users[steamId] = {
           AccountName: accountName,
           PersonaName: accountName,
@@ -222,15 +193,16 @@ class SteamClientService {
       }
 
       try {
-        this.safeWriteVdf(loginUsersPath, data);
+        fs.writeFileSync(loginUsersPath, stringify(data));
-      } catch (e) { }
+      } catch (e) {
+        console.error('[SteamClient] Failed to write loginusers.vdf');
+      }
     }
 
-    if (accountConfig && accountName) {
+    if (accountConfig) {
       this.injectAccountConfig(accountName, accountConfig);
     }
 
-    // --- Linux Registry / Registry.vdf Hardening ---
     if (platform === 'linux') {
       const regLocations = [
         path.join(os.homedir(), '.steam', 'registry.vdf'),
@@ -238,40 +210,36 @@ class SteamClientService {
       ];
 
       for (const regPath of regLocations) {
-        if (!fs.existsSync(path.dirname(regPath))) continue;
+        let regData: any = { Registry: { HKCU: { Software: { Valve: { Steam: {} } } } } };
-
-        let regData: any = { Registry: { HKCU: { Software: { Valve: { Steam: { 
-          AutoLoginUser: "",
-          RememberPassword: "1",
-          AlreadyLoggedIn: "1"
-        } } } } } };
         
         if (fs.existsSync(regPath)) {
           try {
             const content = fs.readFileSync(regPath, 'utf-8');
-            const parsed = parse(content) as any;
+            regData = parse(content) as any;
-            if (parsed && typeof parsed === 'object') regData = parsed;
           } catch (e) { }
+        } else {
+          const regDir = path.dirname(regPath);
+          if (!fs.existsSync(regDir)) fs.mkdirSync(regDir, { recursive: true });
         }
 
-        // Deep merge helper
+        const setPath = (obj: any, keys: string[], val: string) => {
-        const ensurePath = (obj: any, keys: string[]) => {
           let curr = obj;
-          for (const key of keys) {
+          for (let i = 0; i < keys.length - 1; i++) {
-            if (!curr[key] || typeof curr[key] !== 'object') curr[key] = {};
+            if (!curr[keys[i]!]) curr[keys[i]!] = {};
-            curr = curr[key];
+            curr = curr[keys[i]!];
           }
-          return curr;
+          curr[keys[keys.length - 1]!] = val;
         };
 
-        const steamKey = ensurePath(regData, ['Registry', 'HKCU', 'Software', 'Valve', 'Steam']);
+        const steamReg = ['Registry', 'HKCU', 'Software', 'Valve', 'Steam'];
-        steamKey.AutoLoginUser = accountName;
+        setPath(regData, [...steamReg, 'AutoLoginUser'], accountName);
-        steamKey.RememberPassword = "1";
+        setPath(regData, [...steamReg, 'RememberPassword'], "1");
-        steamKey.AlreadyLoggedIn = "1";
+        setPath(regData, [...steamReg, 'AlreadyLoggedIn'], "1");
-        steamKey.WantsOfflineMode = "0";
+        setPath(regData, [...steamReg, 'WantsOfflineMode'], "0");
 
         try {
-          this.safeWriteVdf(regPath, regData);
+          fs.writeFileSync(regPath, stringify(regData));
+          console.log(`[SteamClient] Registry updated: ${regPath}`);
         } catch (e) { }
       }
     }

frontend/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "ultimate-ban-tracker-desktop",
-  "version": "1.3.2",
+  "version": "1.3.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "ultimate-ban-tracker-desktop",
-      "version": "1.3.2",
+      "version": "1.3.0",
       "license": "SEE LICENSE IN LICENSE",
       "dependencies": {
         "@emotion/react": "^11.14.0",

frontend/package.json

@@ -1,7 +1,7 @@
 {
   "name": "ultimate-ban-tracker-desktop",
   "description": "Professional Steam Account Manager & Ban Tracker",
-  "version": "1.3.2",
+  "version": "1.3.0",
   "author": "Nils Pukropp <nils@narl.io>",
   "homepage": "https://narl.io",
   "license": "SEE LICENSE IN LICENSE",