init

2026-02-21 01:48:48 +01:00
commit 64fe49e58e
47 changed files with 13695 additions and 0 deletions
--- a/frontend/electron/services/backend.ts
+++ b/frontend/electron/services/backend.ts
@@ -0,0 +1,94 @@
+import axios from 'axios';
+
+export class BackendService {
+  private url: string;
+  private token?: string;
+
+  constructor(url: string, token?: string) {
+    this.url = url;
+    this.token = token;
+  }
+
+  private get headers() {
+    return {
+      Authorization: `Bearer ${this.token}`,
+      'Content-Type': 'application/json'
+    };
+  }
+
+  public async getSharedAccounts() {
+    if (!this.token) return [];
+    try {
+      const response = await axios.get(`${this.url}/api/sync`, { headers: this.headers });
+      return response.data;
+    } catch (e) {
+      console.error('[Backend] Failed to fetch shared accounts');
+      return [];
+    }
+  }
+
+  public async getCommunityAccounts() {
+    if (!this.token) return [];
+    try {
+      const response = await axios.get(`${this.url}/api/sync/community`, { headers: this.headers });
+      return response.data;
+    } catch (e) {
+      console.error('[Backend] Failed to fetch community accounts');
+      return [];
+    }
+  }
+
+  public async getServerUsers() {
+    if (!this.token) return [];
+    try {
+      const response = await axios.get(`${this.url}/api/sync/users`, { headers: this.headers });
+      return response.data;
+    } catch (e) {
+      console.error('[Backend] Failed to fetch server users');
+      return [];
+    }
+  }
+
+  public async shareAccount(account: any) {
+    if (!this.token) return;
+    try {
+      await axios.post(`${this.url}/api/sync`, {
+        steamId: account.steamId,
+        personaName: account.personaName,
+        avatar: account.avatar,
+        profileUrl: account.profileUrl,
+        vacBanned: account.vacBanned,
+        gameBans: account.gameBans,
+        loginName: account.loginName,
+        steamLoginSecure: account.steamLoginSecure,
+        loginConfig: account.loginConfig
+      }, { headers: this.headers });
+    } catch (e) {
+      console.error('[Backend] Failed to share account');
+    }
+  }
+
+  public async pushCooldown(steamId: string, cooldownExpiresAt?: string) {
+    if (!this.token) return;
+    try {
+      await axios.patch(`${this.url}/api/sync/${steamId}/cooldown`, {
+        cooldownExpiresAt
+      }, { headers: this.headers });
+    } catch (e) {
+      console.error(`[Backend] Failed to push cooldown for ${steamId}`);
+    }
+  }
+
+  public async shareWithUser(steamId: string, targetSteamId: string) {
+    if (!this.token) return;
+    try {
+      const response = await axios.post(`${this.url}/api/sync/${steamId}/share`, {
+        targetSteamId
+      }, { headers: this.headers });
+      return response.data;
+    } catch (e: any) {
+      console.error(`[Backend] Failed to share account ${steamId} with ${targetSteamId}`);
+      throw new Error(e.response?.data?.message || 'Failed to share account');
+    }
+  }
+}
--- a/frontend/electron/services/scraper.ts
+++ b/frontend/electron/services/scraper.ts
@@ -0,0 +1,67 @@
+import axios from 'axios';
+import * as cheerio from 'cheerio';
+
+export interface CooldownData {
+  isActive: boolean;
+  expiresAt?: Date;
+}
+
+export const scrapeCooldown = async (steamId: string, steamLoginSecure: string): Promise<CooldownData> => {
+  const url = `https://steamcommunity.com/profiles/${steamId}/gcpd/730?tab=matchmaking`;
+  
+  try {
+    const response = await axios.get(url, {
+      headers: {
+        'Cookie': steamLoginSecure,
+        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36'
+      },
+      timeout: 10000
+    });
+
+    const $ = cheerio.load(response.data);
+    
+    if (response.data.includes('Sign In') || !response.data.includes('Personal Game Data')) {
+      throw new Error('Invalid or expired steamLoginSecure cookie');
+    }
+
+    // 1. Locate the specific table containing cooldown info
+    let expirationDate: Date | undefined = 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'));
+
+      if (expirationIndex !== -1) {
+        const firstRow = $(table).find('tr').not(':has(th)').first();
+        const dateText = firstRow.find('td').eq(expirationIndex).text().trim();
+
+        if (dateText && dateText !== '') {
+          const cleanDateText = dateText.replace(' GMT', ' UTC');
+          const parsed = new Date(cleanDateText);
+          
+          if (!isNaN(parsed.getTime())) {
+            expirationDate = parsed;
+          }
+        }
+      }
+    });
+
+    if (expirationDate && (expirationDate as Date).getTime() > Date.now()) {
+      console.log(`[Scraper] Found active cooldown until: ${(expirationDate as Date).toISOString()}`);
+      return {
+        isActive: true,
+        expiresAt: expirationDate
+      };
+    }
+
+    const content = $('#personal_game_data_content').text();
+    if (content.includes('Competitive Cooldown') || content.includes('Your account is currently')) {
+        return { isActive: true };
+    }
+
+    return { isActive: false };
+  } catch (error: any) {
+    console.error(`[Scraper] Error for ${steamId}:`, error.message);
+    throw error;
+  }
+};
--- a/frontend/electron/services/steam-client.ts
+++ b/frontend/electron/services/steam-client.ts
@@ -0,0 +1,251 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { parse, stringify } from 'simple-vdf';
+import chokidar from 'chokidar';
+
+export interface LocalSteamAccount {
+  steamId: string;
+  accountName: string;
+  personaName: string;
+  timestamp: number;
+}
+
+class SteamClientService {
+  private steamPath: string | null = null;
+  private onAccountsChanged: ((accounts: LocalSteamAccount[]) => void) | null = null;
+
+  constructor() {
+    this.detectSteamPath();
+  }
+
+  private detectSteamPath() {
+    const platform = os.platform();
+    const home = os.homedir();
+
+    if (platform === 'win32') {
+      const possiblePaths = [
+        'C:\\Program Files (x86)\\Steam',
+        'C:\\Program Files\\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')
+      ];
+      this.steamPath = possiblePaths.find(p => fs.existsSync(p)) || null;
+    }
+
+    if (this.steamPath) {
+      console.log(`[SteamClient] Detected Steam path: ${this.steamPath}`);
+    }
+  }
+
+  public getLoginUsersPath(): string | null {
+    if (!this.steamPath) return null;
+    return path.join(this.steamPath, 'config', 'loginusers.vdf');
+  }
+
+  public getConfigVdfPath(): string | null {
+    if (!this.steamPath) return null;
+    return path.join(this.steamPath, 'config', 'config.vdf');
+  }
+
+  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 }).on('change', () => {
+        this.readLocalAccounts();
+      });
+    }
+  }
+
+  private readLocalAccounts() {
+    const filePath = this.getLoginUsersPath();
+    if (!filePath || !fs.existsSync(filePath)) return;
+
+    try {
+      const content = fs.readFileSync(filePath, 'utf-8');
+      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;
+        accounts.push({
+          steamId: steamId64,
+          accountName: user.AccountName,
+          personaName: user.PersonaName,
+          timestamp: parseInt(user.Timestamp) || 0
+        });
+      }
+
+      if (this.onAccountsChanged) this.onAccountsChanged(accounts);
+    } catch (error) {
+      console.error('[SteamClient] Error parsing loginusers.vdf:', error);
+    }
+  }
+
+  public extractAccountConfig(accountName: string): any | null {
+    const configPath = this.getConfigVdfPath();
+    if (!configPath || !fs.existsSync(configPath)) return null;
+
+    try {
+      const content = fs.readFileSync(configPath, 'utf-8');
+      const data = parse(content) as any;
+      
+      const accounts = data?.InstallConfigStore?.Software?.Valve?.Steam?.Accounts;
+      if (accounts && accounts[accountName]) {
+        return accounts[accountName];
+      }
+    } catch (e) {
+      console.error('[SteamClient] Failed to extract config.vdf data');
+    }
+    return null;
+  }
+
+  public injectAccountConfig(accountName: string, accountData: any) {
+    const configPath = this.getConfigVdfPath();
+    if (!configPath) return;
+
+    // Create directory if it doesn't exist
+    const configDir = path.dirname(configPath);
+    if (!fs.existsSync(configDir)) fs.mkdirSync(configDir, { recursive: true });
+
+    let data: any = { InstallConfigStore: { Software: { Valve: { Steam: { Accounts: {} } } } } };
+
+    if (fs.existsSync(configPath)) {
+      try {
+        const content = fs.readFileSync(configPath, 'utf-8');
+        data = parse(content) as any;
+      } catch (e) { }
+    }
+
+    // Ensure structure exists
+    if (!data.InstallConfigStore) data.InstallConfigStore = {};
+    if (!data.InstallConfigStore.Software) data.InstallConfigStore.Software = {};
+    if (!data.InstallConfigStore.Software.Valve) data.InstallConfigStore.Software.Valve = {};
+    if (!data.InstallConfigStore.Software.Valve.Steam) data.InstallConfigStore.Software.Valve.Steam = {};
+    if (!data.InstallConfigStore.Software.Valve.Steam.Accounts) data.InstallConfigStore.Software.Valve.Steam.Accounts = {};
+
+    data.InstallConfigStore.Software.Valve.Steam.Accounts[accountName] = accountData;
+
+    try {
+      fs.writeFileSync(configPath, stringify(data));
+      console.log(`[SteamClient] Injected login config for ${accountName} into config.vdf`);
+    } catch (e) {
+      console.error('[SteamClient] Failed to write config.vdf');
+    }
+  }
+
+  public async setAutoLoginUser(accountName: string, accountConfig?: any, steamId?: string): Promise<boolean> {
+    const platform = os.platform();
+    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');
+          data = parse(content) as any;
+        } catch (e) { }
+      }
+
+      if (!data.users) data.users = {};
+      
+      let found = false;
+      for (const [id, user] of Object.entries(data.users)) {
+        const u = user as any;
+        if (u.AccountName.toLowerCase() === accountName.toLowerCase()) {
+          u.mostrecent = "1";
+          u.RememberPassword = "1";
+          u.AllowAutoLogin = "1";
+          u.WantsOfflineMode = "0";
+          u.SkipOfflineModeWarning = "1";
+          u.WasNonInteractive = "0";
+          found = true;
+        } else {
+          u.mostrecent = "0";
+        }
+      }
+
+      if (!found && steamId) {
+        console.log(`[SteamClient] Provisioning user ${accountName} into loginusers.vdf`);
+        data.users[steamId] = {
+          AccountName: accountName,
+          PersonaName: accountName,
+          RememberPassword: "1",
+          mostrecent: "1",
+          AllowAutoLogin: "1",
+          WantsOfflineMode: "0",
+          SkipOfflineModeWarning: "1",
+          WasNonInteractive: "0",
+          Timestamp: Math.floor(Date.now() / 1000).toString()
+        };
+      }
+
+      try {
+        fs.writeFileSync(loginUsersPath, stringify(data));
+      } catch (e) {
+        console.error('[SteamClient] Failed to write loginusers.vdf');
+      }
+    }
+
+    if (accountConfig) {
+      this.injectAccountConfig(accountName, accountConfig);
+    }
+
+    if (platform === 'linux') {
+      const regLocations = [
+        path.join(os.homedir(), '.steam', 'registry.vdf'),
+        path.join(os.homedir(), '.steam', 'steam', 'registry.vdf')
+      ];
+
+      for (const regPath of regLocations) {
+        let regData: any = { Registry: { HKCU: { Software: { Valve: { Steam: {} } } } } };
+        
+        if (fs.existsSync(regPath)) {
+          try {
+            const content = fs.readFileSync(regPath, 'utf-8');
+            regData = parse(content) as any;
+          } catch (e) { }
+        } else {
+          const regDir = path.dirname(regPath);
+          if (!fs.existsSync(regDir)) fs.mkdirSync(regDir, { recursive: true });
+        }
+
+        const setPath = (obj: any, keys: string[], val: string) => {
+          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 steamReg = ['Registry', 'HKCU', 'Software', 'Valve', 'Steam'];
+        setPath(regData, [...steamReg, 'AutoLoginUser'], accountName);
+        setPath(regData, [...steamReg, 'RememberPassword'], "1");
+        setPath(regData, [...steamReg, 'AlreadyLoggedIn'], "1");
+        setPath(regData, [...steamReg, 'WantsOfflineMode'], "0");
+
+        try {
+          fs.writeFileSync(regPath, stringify(regData));
+          console.log(`[SteamClient] Registry updated: ${regPath}`);
+        } catch (e) { }
+      }
+    }
+    
+    return true;
+  }
+}
+
+export const steamClient = new SteamClientService();
--- a/frontend/electron/services/steam-web.ts
+++ b/frontend/electron/services/steam-web.ts
@@ -0,0 +1,88 @@
+import axios from 'axios';
+import * as cheerio from 'cheerio';
+
+export interface SteamWebProfile {
+  steamId: string;
+  personaName: string;
+  avatar: string;
+  profileUrl: string;
+}
+
+const AXIOS_CONFIG = {
+  timeout: 10000,
+  headers: {
+    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36'
+  }
+};
+
+export const fetchProfileData = async (identifier: string, steamLoginSecure?: string): Promise<SteamWebProfile> => {
+  let url = '';
+  // Clean identifier
+  const cleanId = identifier.replace(/https?:\/\/steamcommunity\.com\/(profiles|id)\//, '').replace(/\/$/, '');
+  
+  if (cleanId.match(/^\d+$/)) {
+    url = `https://steamcommunity.com/profiles/${cleanId}?xml=1`;
+  } else {
+    url = `https://steamcommunity.com/id/${cleanId}?xml=1`;
+  }
+
+  const headers = { ...AXIOS_CONFIG.headers } as any;
+  if (steamLoginSecure) {
+    headers['Cookie'] = steamLoginSecure;
+  }
+
+  try {
+    const response = await axios.get(url, { ...AXIOS_CONFIG, headers });
+    const $ = cheerio.load(response.data, { xmlMode: true });
+
+    const steamId = $('steamID64').first().text().trim();
+    const personaName = $('steamID').first().text().trim();
+    const avatarRaw = $('avatarFull').first().text().trim();
+    
+    // Robustly extract the first URL if concatenated
+    let avatar = avatarRaw;
+    const urls = avatarRaw.match(/https?:\/\/[^\s"'<>]+/g);
+    if (urls && urls.length > 0) {
+      avatar = urls[0]!;
+    }
+    
+    // Ensure https
+    if (avatar && avatar.startsWith('http:')) {
+      avatar = avatar.replace('http:', 'https:');
+    }
+
+    const profileUrl = steamId 
+      ? `https://steamcommunity.com/profiles/${steamId}`
+      : (cleanId.match(/^\d+$/) ? `https://steamcommunity.com/profiles/${cleanId}` : `https://steamcommunity.com/id/${cleanId}`);
+    
+    return {
+      steamId: steamId || cleanId,
+      personaName: personaName || 'Unknown',
+      avatar: avatar || 'https://avatars.akamai.steamstatic.com/fef49e7fa7e1997310d705b2a6158ff8dc1cdfeb_full.jpg',
+      profileUrl
+    };
+  } catch (error: any) {
+    throw new Error(`Failed to fetch profile: ${error.message}`);
+  }
+};
+
+export const scrapeBanStatus = async (profileUrl: string, steamLoginSecure?: string): Promise<{ vacBanned: boolean, gameBans: number }> => {
+  try {
+    const headers = { ...AXIOS_CONFIG.headers } as any;
+    if (steamLoginSecure) {
+      headers['Cookie'] = steamLoginSecure;
+    }
+
+    const response = await axios.get(profileUrl, { ...AXIOS_CONFIG, headers });
+    const $ = cheerio.load(response.data);
+
+    const banText = $('.profile_ban').text().toLowerCase();
+    const vacBanned = banText.includes('vac ban');
+    const gameBansMatch = banText.match(/(\d+)\s+game\s+ban/);
+    const gameBans = gameBansMatch ? parseInt(gameBansMatch[1]!) : 0;
+
+    return { vacBanned, gameBans };
+  } catch (error) {
+    return { vacBanned: false, gameBans: 0 };
+  }
+};