feat: use hot prowser instance to improve stability

services/print/pod-print/src/browser.ts

@@ -0,0 +1,153 @@
+//
+// Copyright © 2026 Hardcore Engineering Inc.
+//
+
+import puppeteer, { type Browser, type BrowserContext, type Page } from 'puppeteer'
+
+import config from './config'
+
+const BROWSER_PAGE_INIT_TIMEOUT_MS = 2000
+
+export type BrowserStatus = 'not_started' | 'launching' | 'connected' | 'disconnected'
+
+export interface PrintBrowserPage {
+  context: BrowserContext
+  page: Page
+}
+
+function getLaunchOptions (): Parameters<typeof puppeteer.launch>[0] {
+  return {
+    headless: true,
+    args: [
+      '--no-sandbox',
+      '--disable-gpu',
+      '--disable-dev-shm-usage',
+      '--disable-extensions',
+      '--disable-setuid-sandbox',
+      ...config.PuppeteerArgs
+    ]
+  }
+}
+
+async function withTimeout<T> (promise: Promise<T>, timeoutMs: number): Promise<T> {
+  let timeout: NodeJS.Timeout | undefined
+  try {
+    return await Promise.race([
+      promise,
+      new Promise<T>((_resolve, reject) => {
+        timeout = setTimeout(() => {
+          reject(new Error('Browser page initialization timed out'))
+        }, timeoutMs)
+      })
+    ])
+  } finally {
+    if (timeout !== undefined) {
+      clearTimeout(timeout)
+    }
+  }
+}
+
+export class PrintBrowserManager {
+  private browser: Browser | undefined
+  private launchPromise: Promise<Browser> | undefined
+
+  getStatus (): BrowserStatus {
+    if (this.browser !== undefined) {
+      return this.browser.connected ? 'connected' : 'disconnected'
+    }
+
+    return this.launchPromise !== undefined ? 'launching' : 'not_started'
+  }
+
+  async getBrowser (): Promise<Browser> {
+    if (this.browser !== undefined && this.browser.connected) {
+      return this.browser
+    }
+
+    if (this.browser !== undefined) {
+      await this.resetBrowser(this.browser)
+    }
+
+    if (this.launchPromise === undefined) {
+      this.launchPromise = puppeteer
+        .launch(getLaunchOptions())
+        .then((launchedBrowser) => {
+          this.browser = launchedBrowser
+          launchedBrowser.on('disconnected', () => {
+            if (this.browser === launchedBrowser) {
+              this.browser = undefined
+              this.launchPromise = undefined
+            }
+          })
+          return launchedBrowser
+        })
+        .catch((err) => {
+          this.launchPromise = undefined
+          throw err
+        })
+    }
+
+    return await this.launchPromise
+  }
+
+  async createPage (): Promise<PrintBrowserPage> {
+    const browser = await this.getBrowser()
+
+    try {
+      return await this.createPageInBrowser(browser)
+    } catch (err) {
+      if (this.browser === browser) {
+        await this.resetBrowser(browser)
+        return await this.createPageInBrowser(await this.getBrowser())
+      }
+      throw err
+    }
+  }
+
+  async close (): Promise<void> {
+    const currentBrowser = this.browser
+    const currentLaunchPromise = this.launchPromise
+
+    this.browser = undefined
+    this.launchPromise = undefined
+
+    const launchedBrowser = currentBrowser ?? (await currentLaunchPromise?.catch(() => undefined))
+
+    if (this.browser === launchedBrowser) {
+      this.browser = undefined
+    }
+
+    if (launchedBrowser !== undefined) {
+      await this.closeBrowser(launchedBrowser)
+    }
+  }
+
+  private async createPageInBrowser (browser: Browser): Promise<PrintBrowserPage> {
+    let context: BrowserContext | undefined
+
+    try {
+      context = await withTimeout(browser.createBrowserContext(), BROWSER_PAGE_INIT_TIMEOUT_MS)
+      const page = await withTimeout(context.newPage(), BROWSER_PAGE_INIT_TIMEOUT_MS)
+      return { context, page }
+    } catch {
+      if (context !== undefined) {
+        await context.close().catch(() => {})
+      }
+      throw new Error('Failed to create browser page')
+    }
+  }
+
+  private async resetBrowser (browser: Browser): Promise<void> {
+    if (this.browser === browser) {
+      this.browser = undefined
+      this.launchPromise = undefined
+    }
+    await this.closeBrowser(browser)
+  }
+
+  private async closeBrowser (browser: Browser): Promise<void> {
+    if (browser.connected) {
+      await browser.close().catch(() => {})
+    }
+  }
+}

services/print/pod-print/src/config.ts

@@ -13,10 +13,19 @@ export interface Config {
   FrontUrl: string
   AllowedHostnames: string[]
   PuppeteerArgs: string[]
+  PrintConcurrency: number
 }
 
 const parseNumber = (str: string | undefined): number | undefined => (str !== undefined ? Number(str) : undefined)
 
+const parsePositiveInteger = (str: string | undefined, defaultValue: number): number => {
+  const value = parseNumber(str) ?? defaultValue
+  if (!Number.isInteger(value) || value <= 0) {
+    throw Error(`Invalid positive integer config value: ${str}`)
+  }
+  return value
+}
+
 const config: Config = (() => {
   const allowedHostnames = process.env.ALLOWED_HOSTNAMES
   const puppeteerArgs = process.env.PUPPETEER_ARGS ?? ''
@@ -27,7 +36,8 @@ const config: Config = (() => {
     AccountsUrl: process.env.ACCOUNTS_URL,
     FrontUrl: process.env.FRONT_URL,
     AllowedHostnames: allowedHostnames == null ? [] : allowedHostnames.split(','),
-    PuppeteerArgs: puppeteerArgs.split(',')
+    PuppeteerArgs: puppeteerArgs.split(','),
+    PrintConcurrency: parsePositiveInteger(process.env.PRINT_CONCURRENCY, 1)
   }
 
   const missingEnv = (Object.keys(params) as Array<keyof Config>).filter((key) => params[key] === undefined)

services/print/pod-print/src/main.ts

@@ -22,10 +22,22 @@ export const main = async (): Promise<void> => {
   const storageConfig = storageConfigFromEnv()
   const { app, close } = createServer(storageConfig, config.AllowedHostnames)
   const server = listen(app, config.Port)
+  let shuttingDown = false
 
   const shutdown = (): void => {
-    close()
-    server.close(() => process.exit())
+    if (shuttingDown) {
+      return
+    }
+    shuttingDown = true
+
+    server.close(() => {
+      void close()
+        .then(() => process.exit())
+        .catch((err) => {
+          console.error(err)
+          process.exit(1)
+        })
+    })
   }
 
   process.on('SIGINT', shutdown)