create and close browser for each action to clear ram

src/browser.ts

@@ -1,27 +1,29 @@
 import type { Browser, BrowserContext, Page } from 'playwright'
 import { chromium } from 'playwright-extra'
+import StealthPlugin from 'puppeteer-extra-plugin-stealth'
 
-export let glBrowser: Browser | null = null
-export let glContext: BrowserContext | null = null
-export let glPage: Page | null = null
+chromium.use(StealthPlugin())
 
-export async function ensureBrowser() {
-   if (glBrowser && glBrowser.isConnected() && glPage && !glPage.isClosed()) return
-
-   // launch browser
-   if (glBrowser) await glBrowser.close() // if not connected - close and create new one
-   glBrowser = await chromium.launch({
+export async function createInstance() {
+   console.log(`-> Launching browser`)
+   const browser = await chromium.launch({
       headless: true,
-      args: ['--disable-dev-shm-usage', '--disable-gpu', '--mute-audio', '--no-sandbox'],
+      args: [
+         '--disable-dev-shm-usage',
+         '--no-sandbox',
+         '--disable-setuid-sandbox',
+         '--disable-gpu',
+         '--no-first-run',
+         '--single-process',
+         '--mute-audio',
+      ],
    })
-
-   // create context
-   glContext = await glBrowser.newContext({
+   const context = await browser.newContext({
       locale: 'en-US',
       timezoneId: 'America/New_York',
       bypassCSP: true,
    })
-   await glContext.addCookies([
+   await context.addCookies([
       {
          name: 'sp_dc',
          value: process.env.SP_DC!,
@@ -41,21 +43,19 @@ export async function ensureBrowser() {
          sameSite: 'None',
       },
    ])
-
-   // open page
-   glPage = await glContext.newPage()
-   await glPage.route('**/*.{png,jpg,jpeg,gif,woff,woff2,sentry}', (r) => r.abort())
+   const page = await context.newPage()
+   await page.route('**/*.{png,jpg,jpeg,gif,woff,woff2,sentry}', (r) => r.abort())
+   return { browser, context, page }
 }
 
-export async function handleBrowserError(error: unknown) {
-   // close and clear browser
-   if (glBrowser) {
-      await glBrowser.close().catch(() => {})
-      glBrowser = null
-   }
-
-   // handle error
+export async function handleError(error: unknown) {
    const details = error instanceof Error ? error.message : 'Unknown error'
-   console.error('Error:', details)
+   console.error('💥 Error:', details)
    return details
 }
+
+export async function killBrowser(browser: Browser | null) {
+   console.log(`<- Closing browser`)
+   if (browser) await browser.close().catch(() => {})
+   if (global.gc) global.gc() // force garbage collection to free RAM
+}

src/hashHandlers.ts

@@ -1,5 +1,5 @@
 import { addToPlaylistAction } from './actions.js'
-import { ensureBrowser, glPage, handleBrowserError } from './browser.js'
+import { createInstance, killBrowser, handleError } from './browser.js'
 import { type Operation, store } from './storage.js'
 import { delay } from './utils.js'
 
@@ -17,37 +17,49 @@ export const operations: Operation[] = [
 ]
 
 export async function updateHash(op: Operation) {
-   try {
-      await ensureBrowser()
-      const page = glPage!
+   const { browser, page } = await createInstance()
 
-      // catch hashes from any graphql request
+   try {
       const hashPromise = page
          .waitForResponse(
             async (res) => {
                const url = res.url()
                if (url.includes('query') || (url.includes('graphql') && res.status() === 200)) {
-                  const body = res.request().postDataJSON()
-                  if (!body) return false
-                  const hash = body.extensions?.persistedQuery?.sha256Hash
-                  if (hash) store.hashes[body.operationName] = hash
-                  return body.operationName === op.name
+                  try {
+                     const body = res.request().postDataJSON()
+                     if (!body) return false
+                     const hash = body.extensions?.persistedQuery?.sha256Hash
+                     if (hash) store.hashes[body.operationName] = hash
+                     return body.operationName === op.name
+                  } catch {
+                     return false
+                  }
                }
                return false
             },
             { timeout: 60000 },
          )
          .then((res) => (res.request().postDataJSON()?.extensions?.persistedQuery?.sha256Hash || null) as string | null)
+         .catch((err) => {
+            console.warn(`⚠️ [${op.name}] Hash listener ended: ${err.message}`)
+            return null
+         })
 
-      // load the page
       await page.goto(op.url, { waitUntil: 'domcontentloaded', timeout: 60000 })
 
-      // perform action and listen for side hashes
-      const [hash] = await Promise.all([hashPromise, op.action ? op.action(page) : Promise.resolve()])
+      const actionPromise = op.action
+         ? op.action(page).catch((e) => {
+              throw new Error(`Action failed: ${e.message}`)
+           })
+         : Promise.resolve()
+
+      const [hash] = await Promise.all([hashPromise, actionPromise])
       return hash
    } catch (err) {
-      handleBrowserError(err)
+      handleError(err)
       return null
+   } finally {
+      await killBrowser(browser)
    }
 }
 

src/index.ts

@@ -1,17 +1,15 @@
 import express from 'express'
-import { chromium } from 'playwright-extra'
 import 'dotenv/config'
-import StealthPlugin from 'puppeteer-extra-plugin-stealth'
 import PQueue from 'p-queue'
 import cron from 'node-cron'
 import { store, type AccessTokenResponse, type TokenResponse } from './storage.js'
-import { ensureBrowser, glPage, handleBrowserError } from './browser.js'
+import { createInstance, killBrowser, handleError } from './browser.js'
 import { delay } from './utils.js'
 import { updateAllHashes, operations, updateHash } from './hashHandlers.js'
+import type { Browser } from 'playwright'
 
 const app = express()
 const PORT = process.env.PORT || 3000
-chromium.use(StealthPlugin())
 const queue = new PQueue({ concurrency: 1 })
 
 // Health check - must be before auth middleware
@@ -44,6 +42,7 @@ function isTokenValid(): boolean {
 }
 
 app.get('/token', async (req, res) => {
+   let exBrowser: Browser | null = null
    try {
       // return token if valid
       if (isTokenValid()) {
@@ -58,8 +57,8 @@ app.get('/token', async (req, res) => {
             return { access: store.access!, client: store.client! } satisfies TokenResponse
          }
 
-         await ensureBrowser()
-         const page = glPage!
+         const { browser, page } = await createInstance()
+         exBrowser = browser
 
          // access token
          const accessTokenPromise = page
@@ -99,9 +98,12 @@ app.get('/token', async (req, res) => {
          }
          return { access: store.access!, client: store.client! } satisfies TokenResponse
       })
+
+      killBrowser(exBrowser)
       res.json(result)
-   } catch (error) {
-      const details = handleBrowserError(error)
+   } catch (err) {
+      const details = handleError(err)
+      killBrowser(exBrowser)
       res.status(500).json({ error: 'Failed to get token', details })
    }
 })
@@ -138,12 +140,10 @@ app.put('/hashes', async (req, res) => {
          return res.status(400).json({ error: 'No valid operation names provided' })
       }
       if (hashes.length !== names.length) {
-         return res
-            .status(404)
-            .json({
-               error: 'Some operation names were invalid',
-               details: { raw, hashes: Object.fromEntries(hashes.map((i) => [i.name, i.hash])) },
-            })
+         return res.status(404).json({
+            error: 'Some operation names were invalid',
+            details: { raw, hashes: Object.fromEntries(hashes.map((i) => [i.name, i.hash])) },
+         })
       }
    }