Use backend API to check and accept EULA

Author: claabs

src/common/config/classes.ts

@@ -981,6 +981,16 @@ export class AppConfig {
   @IsString()
   errorsDir = process.env.ERRORS_DIR || path.join(CONFIG_DIR, 'errors');
 
+  /**
+   * If false, EULA updates will be automatically accepted. If true, the user will receive a notification to accept the EULA.
+   * @example true
+   * @default false
+   * @env NOTIFY_EULA
+   */
+  @IsBoolean()
+  @IsOptional()
+  notifyEula = process.env.NOTIFY_EULA?.toLowerCase() === 'true' || false;
+
   /**
    * @hidden
    */

src/common/constants.ts

@@ -45,5 +45,6 @@ export const ACCOUNT_OAUTH_TOKEN =
 export const ACCOUNT_OAUTH_DEVICE_AUTH =
   'https://account-public-service-prod.ol.epicgames.com/account/api/oauth/deviceAuthorization';
 export const ID_LOGIN_ENDPOINT = 'https://www.epicgames.com/id/login';
-export const ACCOUNT_EULA_HISTORY_ENDPOINT =
-  'https://www.epicgames.com/account/v2/eula/acceptance-history';
+export const EULA_AGREEMENTS_ENDPOINT =
+  'https://eulatracking-public-service-prod-m.ol.epicgames.com/eulatracking/api/public/agreements';
+export const REQUIRED_EULAS = ['epicgames_privacy_policy_no_table', 'egstore'];

src/eula-manager.ts

@@ -0,0 +1,105 @@
+import axios from 'axios';
+import { Logger } from 'pino';
+import { EULA_AGREEMENTS_ENDPOINT, REQUIRED_EULAS, STORE_HOMEPAGE } from './common/constants.js';
+import logger from './common/logger.js';
+import { getAccountAuth } from './common/device-auths.js';
+import { config } from './common/config/setup.js';
+import { generateLoginRedirect } from './purchase.js';
+import { sendNotification } from './notify.js';
+import { NotificationReason } from './interfaces/notification-reason.js';
+
+export interface EulaVersion {
+  key: string;
+  version: number;
+  locale: string;
+}
+
+export interface EulaAgreementResponse {
+  key: string;
+  version: number;
+  revision: number;
+  title: string;
+  body: string;
+  locale: string;
+  createdTimestamp: string;
+  lastModifiedTimestamp: string;
+  status: string;
+  description: string;
+  custom: boolean;
+  url: string;
+  wasDeclined: boolean;
+  operatorId: string;
+  notes: string;
+  hasResponse: boolean;
+}
+
+export class EulaManager {
+  private accountId: string;
+
+  private accessToken: string;
+
+  private email: string;
+
+  private L: Logger;
+
+  constructor(email: string) {
+    this.L = logger.child({ user: email });
+    const deviceAuth = getAccountAuth(email);
+    if (!deviceAuth) throw new Error('Device auth not found');
+    this.accountId = deviceAuth.account_id;
+    this.accessToken = deviceAuth.access_token;
+    this.email = email;
+  }
+
+  public async checkEulaStatus(): Promise<void> {
+    const pendingEulas = await this.fetchPendingEulas();
+
+    if (pendingEulas.length) {
+      if (config.notifyEula) {
+        this.L.error('User needs to log in an accept an updated EULA');
+        const actionUrl = generateLoginRedirect(STORE_HOMEPAGE);
+        await sendNotification(this.email, NotificationReason.PRIVACY_POLICY_ACCEPTANCE, actionUrl);
+        throw new Error(`${this.email} needs to accept an updated EULA`);
+      } else {
+        this.L.info({ pendingEulas }, 'Accepting EULAs');
+        await this.acceptEulas(pendingEulas);
+      }
+    }
+  }
+
+  private async fetchPendingEulas() {
+    const eulaStatuses: (EulaVersion | undefined)[] = await Promise.all(
+      REQUIRED_EULAS.map(async (key) => {
+        const url = `${EULA_AGREEMENTS_ENDPOINT}/${key}/account/${this.accountId}`;
+        this.L.trace({ url }, 'Checking EULA status');
+        const response = await axios.get<EulaAgreementResponse | undefined>(url, {
+          headers: { Authorization: `Bearer ${this.accessToken}` },
+        });
+        if (!response.data) return undefined;
+        this.L.debug({ key }, 'EULA is not accepted');
+        return {
+          key,
+          version: response.data.version,
+          locale: response.data.locale,
+        };
+      }),
+    );
+    const pendingEulas = eulaStatuses.filter((eula): eula is EulaVersion => eula !== undefined);
+    this.L.trace({ pendingEulas }, 'Pending EULAs');
+    return pendingEulas;
+  }
+
+  private async acceptEulas(eulaVersions: EulaVersion[]): Promise<void> {
+    await Promise.all(
+      eulaVersions.map(async (eulaVersion) => {
+        const url = `${EULA_AGREEMENTS_ENDPOINT}/${eulaVersion.key}/version/${eulaVersion.version}/account/${this.accountId}/accept`;
+        this.L.trace({ url }, 'Accepting EULA');
+        await axios.post(url, undefined, {
+          params: { locale: eulaVersion.locale },
+          headers: { Authorization: `Bearer ${this.accessToken}` },
+        });
+        this.L.debug({ key: eulaVersion.key }, 'EULA accepted');
+      }),
+    );
+  }
+}

src/index.ts

@@ -12,6 +12,7 @@ import { convertImportCookies } from './common/cookie.js';
 import { DeviceLogin } from './device-login.js';
 import { generateCheckoutUrl } from './purchase.js';
 import { NotificationReason } from './interfaces/notification-reason.js';
+import { EulaManager } from './eula-manager.js';
 
 export async function redeemAccount(account: AccountConfig): Promise<void> {
   const L = logger.child({ user: account.email });
@@ -32,14 +33,22 @@ export async function redeemAccount(account: AccountConfig): Promise<void> {
     });
 
     // Login
+    let usedDeviceAuth = false;
     let successfulLogin = await cookieLogin.refreshCookieLogin();
     if (!successfulLogin) {
       // attempt token refresh
       successfulLogin = await deviceLogin.refreshDeviceAuth();
+      usedDeviceAuth = true;
     }
     if (!successfulLogin) {
       // get new device auth
       await deviceLogin.newDeviceAuthLogin();
+      usedDeviceAuth = true;
+    }
+
+    if (usedDeviceAuth) {
+      const eulaManager = new EulaManager(account.email);
+      await eulaManager.checkEulaStatus();
     }
 
     // Get purchasable offers

src/interfaces/accounts.ts

@@ -11,15 +11,7 @@ import {
 import { getCookiesRaw, setPuppeteerCookies, userHasValidCookie } from '../common/cookie.js';
 import { config } from '../common/config/index.js';
 import { getAccountAuth } from '../common/device-auths.js';
-import {
-  ACCOUNT_EULA_HISTORY_ENDPOINT,
-  STORE_CART_EN,
-  STORE_HOMEPAGE,
-} from '../common/constants.js';
-import { generateLoginRedirect } from '../purchase.js';
-import { sendNotification } from '../notify.js';
-import { NotificationReason } from '../interfaces/notification-reason.js';
-import { EulaResponse } from '../interfaces/accounts.js';
+import { STORE_CART_EN } from '../common/constants.js';
 
 export interface PuppetBaseProps {
   browser: Browser;
@@ -100,34 +92,11 @@ export default class PuppetBase {
     return resp;
   }
 
-  private async checkEula(): Promise<void> {
-    const REQUIRED_EULAS = ['epicgames_privacy_policy_no_table', 'egstore'];
-    this.L.trace(
-      { url: ACCOUNT_EULA_HISTORY_ENDPOINT, requiredEulas: REQUIRED_EULAS },
-      'Checking acount EULA history',
-    );
-    const resp = await this.request<EulaResponse>('GET', ACCOUNT_EULA_HISTORY_ENDPOINT);
-    this.L.debug({ resp }, 'Eula history response');
-    const acceptedEulaKeys = resp.data
-      .filter((eulaEntry) => eulaEntry.accepted)
-      .map((eulaEntry) => eulaEntry.key);
-    const hasRequiredEulas = REQUIRED_EULAS.every((requiredKey) =>
-      acceptedEulaKeys.includes(requiredKey),
-    );
-
-    if (!hasRequiredEulas) {
-      this.L.error('User needs to log in an accept an updated EULA');
-      const actionUrl = generateLoginRedirect(STORE_HOMEPAGE);
-      sendNotification(this.email, NotificationReason.PRIVACY_POLICY_ACCEPTANCE, actionUrl);
-      throw new Error(`${this.email} needs to accept an updated EULA`);
-    }
-  }
-
   protected async setupPage(): Promise<Page> {
     // Get cookies or latest access_token cookies
     let puppeteerCookies: Cookie[] = [];
     if (userHasValidCookie(this.email, 'EPIC_BEARER_TOKEN')) {
-      this.L.debug('Setting auth from cookies');
+      this.L.debug('Setting auth from bearer token cookies');
       const userCookies = await getCookiesRaw(this.email);
       puppeteerCookies = toughCookieFileStoreToPuppeteerCookie(userCookies);
     } else {
@@ -162,9 +131,8 @@ export default class PuppetBase {
     this.page = await safeNewPage(this.browser, this.L);
     try {
       this.L.trace(getDevtoolsUrl(this.page));
-      await this.page.goto(STORE_CART_EN, { waitUntil: 'networkidle0' });
-      await this.browser.setCookie(...puppeteerCookies); // must happen **after** navigating
-      await this.checkEula();
+      await this.browser.setCookie(...puppeteerCookies);
+      await this.page.goto(STORE_CART_EN, { waitUntil: 'networkidle0' }); // Get EG1 cookie
       return this.page;
     } catch (err) {
       await this.handlePageError(err);
@@ -179,15 +147,15 @@ export default class PuppetBase {
       const currentCookies = await this.browser.cookies();
       setPuppeteerCookies(this.email, currentCookies);
       this.L.trace('Saved cookies, closing browser');
-      await this.page.close();
+      // await this.page.close(); // Getting `Protocol error (Target.createTarget): Target closed` with this for some reason
       this.page = undefined;
     } catch (err) {
       await this.handlePageError(err);
     }
   }
 
   protected async handlePageError(err: unknown) {
-    if (this.page) {
+    if (this.page && !this.page.isClosed()) {
       const errorFile = `error-${new Date().toISOString()}.png`;
       await ensureDir(config.errorsDir);
       await this.page.screenshot({
@@ -198,8 +166,8 @@ export default class PuppetBase {
         'Encountered an error during browser automation. Saved a screenshot for debugging purposes.',
       );
       await this.page.close();
-      this.page = undefined;
     }
+    this.page = undefined;
     throw err;
   }
 }

src/puppet/base.ts

@@ -17,6 +17,11 @@ export default class PuppetLogin extends PuppetBase {
     if (!userHasValidCookie(this.email, 'EPIC_SSO_RM')) return false;
     try {
       if (!this.page) this.page = await this.setupPage();
+      const url = generateLoginRedirect(STORE_CART_EN);
+      this.L.trace({ url }, 'Visiting login cart redirect');
+      await this.page.goto(url, {
+        waitUntil: 'networkidle0',
+      });
       const currentCookies = await this.browser.cookies();
       if (currentCookies.find((c) => c.name === 'EPIC_BEARER_TOKEN')) {
         this.L.debug('Successfully refreshed cookie auth');
@@ -39,11 +44,6 @@ export default class PuppetLogin extends PuppetBase {
     this.page = await safeNewPage(this.browser, this.L);
     try {
       this.L.trace(getDevtoolsUrl(this.page));
-      const url = generateLoginRedirect(STORE_CART_EN);
-      this.L.trace({ url }, 'Visiting login cart redirect');
-      await this.page.goto(url, {
-        waitUntil: 'networkidle0',
-      });
       await this.browser.setCookie(...puppeteerCookies);
       return this.page;
     } catch (err) {