@thoughtflow/browser 0.2.0 → 0.3.1

package/package.json

@@ -1,13 +1,14 @@
 {
   "name": "@thoughtflow/browser",
-  "version": "0.2.0",
+  "version": "0.3.1",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "scripts": {
     "build": "tsc -p tsconfig.build.json"
   },
   "dependencies": {
-    "@thoughtflow/core": "0.2.0",
-    "playwright": "^1.59.1"
+    "@thoughtflow/core": "*",
+    "playwright": "^1.59.1",
+    "zod": "^3.24.3"
   }
 }

package/src/tools/workspace/browser-session-pool.ts

@@ -0,0 +1,376 @@
+/**
+ * BrowserSessionPool — manages multiple headless browser sessions with
+ * isolated pages, console logs, and network activity per session.
+ *
+ * Auto-cleans up sessions after 5 minutes of inactivity.
+ */
+
+interface ConsoleEntry {
+  type: string
+  text: string
+  location: string
+  timestamp: number
+}
+
+interface NetworkEntry {
+  idx: number
+  method: string
+  url: string
+  status?: number
+  statusText?: string
+  duration?: number
+  error?: string
+  reqHeaders?: Record<string, string>
+  reqBody?: string
+  resHeaders?: Record<string, string>
+  resBody?: string
+  timestamp: number
+}
+
+interface BrowserPage {
+  id: string
+  page: import("playwright").Page
+  consoleEntries: ConsoleEntry[]
+  networkEntries: NetworkEntry[]
+  netIdx: number
+}
+
+interface BrowserSession {
+  browser: import("playwright").Browser
+  pages: BrowserPage[]
+  activePageId: string
+  initUrl: string
+  createdAt: number
+  lastActivity: number
+}
+
+const SESSION_TTL_MS = 5 * 60 * 1000 // 5 minutes
+
+export class BrowserSessionPool {
+  private sessions = new Map<string, BrowserSession>()
+  private cleanupTimer: ReturnType<typeof setInterval> | null = null
+
+  /** Create or retrieve a session. If sessionId is empty, creates a new one. */
+  async getOrCreate(sessionId?: string): Promise<{ sessionId: string; page: import("playwright").Page }> {
+    if (sessionId && this.sessions.has(sessionId)) {
+      const session = this.sessions.get(sessionId)!
+      session.lastActivity = Date.now()
+      const activePage = session.pages.find(p => p.id === session.activePageId)
+      if (activePage && !activePage.page.isClosed()) {
+        return { sessionId, page: activePage.page }
+      }
+      // Active page closed — create a new one
+      return this.newPage(sessionId)
+    }
+
+    // Create new session
+    const id = sessionId ?? `br_${Date.now()}_${Math.random().toString(36).slice(2, 6)}`
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const { chromium } = require("playwright") as typeof import("playwright")
+    const browser = await chromium.launch({ headless: true })
+    const page = await browser.newPage()
+
+    const browserPage: BrowserPage = {
+      id: `pg_${Date.now()}`,
+      page,
+      consoleEntries: [],
+      networkEntries: [],
+      netIdx: 0,
+    }
+
+    const session: BrowserSession = {
+      browser,
+      pages: [browserPage],
+      activePageId: browserPage.id,
+      initUrl: "",
+      createdAt: Date.now(),
+      lastActivity: Date.now(),
+    }
+
+    this.sessions.set(id, session)
+    this.startCleanup()
+
+    // Attach listeners
+    this.attachListeners(browserPage)
+
+    return { sessionId: id, page }
+  }
+
+  /** Navigate the active page of a session. */
+  async getPage(sessionId: string): Promise<import("playwright").Page | null> {
+    const session = this.sessions.get(sessionId)
+    if (!session) return null
+    session.lastActivity = Date.now()
+    const active = session.pages.find(p => p.id === session.activePageId)
+    if (!active || active.page.isClosed()) return null
+    return active.page
+  }
+
+  /** Open a new tab in an existing session. */
+  async newPage(sessionId: string): Promise<{ sessionId: string; page: import("playwright").Page }> {
+    const session = this.sessions.get(sessionId)
+    if (!session) throw new Error(`Session ${sessionId} not found`)
+
+    session.lastActivity = Date.now()
+    const page = await session.browser.newPage()
+
+    const browserPage: BrowserPage = {
+      id: `pg_${Date.now()}`,
+      page,
+      consoleEntries: [],
+      networkEntries: [],
+      netIdx: 0,
+    }
+
+    session.pages.push(browserPage)
+    session.activePageId = browserPage.id
+    this.attachListeners(browserPage)
+
+    return { sessionId, page }
+  }
+
+  /** Switch active tab. */
+  switchPage(sessionId: string, pageId: string): boolean {
+    const session = this.sessions.get(sessionId)
+    if (!session) return false
+    const exists = session.pages.find(p => p.id === pageId && !p.page.isClosed())
+    if (!exists) return false
+    session.activePageId = pageId
+    session.lastActivity = Date.now()
+    return true
+  }
+
+  /** Close a tab (or the active one if pageId omitted). */
+  async closePage(sessionId: string, pageId?: string): Promise<boolean> {
+    const session = this.sessions.get(sessionId)
+    if (!session) return false
+    session.lastActivity = Date.now()
+
+    const targetId = pageId ?? session.activePageId
+    const idx = session.pages.findIndex(p => p.id === targetId)
+    if (idx === -1) return false
+
+    const bp = session.pages[idx]!
+    await bp.page.close().catch(() => {})
+    session.pages.splice(idx, 1)
+
+    // If we closed the active page, switch to another
+    if (session.activePageId === targetId && session.pages.length > 0) {
+      session.activePageId = session.pages[0]!.id
+    }
+
+    return true
+  }
+
+  /** Destroy a session completely. */
+  async destroy(sessionId: string): Promise<void> {
+    const session = this.sessions.get(sessionId)
+    if (!session) return
+
+    for (const bp of session.pages) {
+      await bp.page.close().catch(() => {})
+    }
+    await session.browser.close().catch(() => {})
+    this.sessions.delete(sessionId)
+  }
+
+  /** Destroy all sessions. */
+  async destroyAll(): Promise<number> {
+    let count = 0
+    for (const [id, session] of this.sessions) {
+      for (const bp of session.pages) {
+        await bp.page.close().catch(() => {})
+      }
+      await session.browser.close().catch(() => {})
+      this.sessions.delete(id)
+      count++
+    }
+    if (this.cleanupTimer) {
+      clearInterval(this.cleanupTimer)
+      this.cleanupTimer = null
+    }
+    return count
+  }
+
+  /** Set the initial navigation URL for a session. */
+  setInitUrl(sessionId: string, url: string): void {
+    const session = this.sessions.get(sessionId)
+    if (session && !session.initUrl) {
+      session.initUrl = url
+    }
+  }
+
+  /** List all active sessions with metadata. */
+  list(): Array<{
+    sessionId: string
+    initUrl: string
+    currentUrl: string
+    pageCount: number
+    activePageId: string
+    createdAt: number
+    lastActivity: number
+    status: "active" | "idle"
+  }> {
+    const now = Date.now()
+    const result: Array<{
+      sessionId: string
+      initUrl: string
+      currentUrl: string
+      pageCount: number
+      activePageId: string
+      createdAt: number
+      lastActivity: number
+      status: "active" | "idle"
+    }> = []
+
+    for (const [id, session] of this.sessions) {
+      const active = session.pages.find(p => p.id === session.activePageId && !p.page.isClosed())
+      const idleMs = now - session.lastActivity
+      result.push({
+        sessionId: id,
+        initUrl: session.initUrl || "(no navigation yet)",
+        currentUrl: active ? active.page.url() : "(closed)",
+        pageCount: session.pages.filter(p => !p.page.isClosed()).length,
+        activePageId: session.activePageId,
+        createdAt: session.createdAt,
+        lastActivity: session.lastActivity,
+        status: idleMs > 60_000 ? "idle" : "active",
+      })
+    }
+    return result
+  }
+
+  /** Get console logs for active page. */
+  getConsole(sessionId: string): ConsoleEntry[] {
+    return this.getActivePageData(sessionId)?.consoleEntries ?? []
+  }
+
+  /** Get network entries for active page. */
+  getNetwork(sessionId: string): NetworkEntry[] {
+    return this.getActivePageData(sessionId)?.networkEntries ?? []
+  }
+
+  /** Clear console logs for active page. */
+  clearConsole(sessionId: string): void {
+    const bp = this.getActivePageData(sessionId)
+    if (bp) bp.consoleEntries = []
+  }
+
+  /** Clear network entries for active page. */
+  clearNetwork(sessionId: string): void {
+    const bp = this.getActivePageData(sessionId)
+    if (bp) bp.networkEntries = []
+  }
+
+  /** Cache a screenshot base64 string for the session. */
+  cacheScreenshot(sessionId: string, base64: string): void {
+    const session = this.sessions.get(sessionId)
+    if (session) (session as any).cachedScreenshot = base64
+  }
+
+  /** Get cached screenshot base64 string. */
+  getCachedScreenshot(sessionId: string): string | null {
+    const session = this.sessions.get(sessionId)
+    return (session as any).cachedScreenshot ?? null
+  }
+
+  /** List all open tabs in a session. */
+  listPages(sessionId: string): Array<{ id: string; url: string; title: string }> {
+    const session = this.sessions.get(sessionId)
+    if (!session) return []
+    return session.pages
+      .filter(p => !p.page.isClosed())
+      .map(p => ({
+        id: p.id,
+        url: p.page.url(),
+        title: "", // Will be filled by caller if needed
+        active: p.id === session.activePageId,
+      }))
+  }
+
+  // ── Private ────────────────────────────────────────────────────────────────
+
+  private getActivePageData(sessionId: string): BrowserPage | null {
+    const session = this.sessions.get(sessionId)
+    if (!session) return null
+    session.lastActivity = Date.now()
+    return session.pages.find(p => p.id === session.activePageId && !p.page.isClosed()) ?? null
+  }
+
+  private attachListeners(bp: BrowserPage): void {
+    // Console
+    bp.page.on("console", (msg) => {
+      bp.consoleEntries.push({
+        type: msg.type(),
+        text: msg.text(),
+        location: msg.location().url ? `${msg.location().url}:${msg.location().lineNumber}` : "",
+        timestamp: Date.now(),
+      })
+    })
+
+    // Network
+    const timings = new Map<string, number>()
+    bp.page.on("request", (req) => {
+      const idx = ++bp.netIdx
+      timings.set(req.url() + req.method(), Date.now())
+      let reqBody: string | undefined
+      try { reqBody = req.postData() ?? undefined } catch {}
+      bp.networkEntries.push({
+        idx, method: req.method(), url: req.url(),
+        reqHeaders: req.headers() as Record<string, string>,
+        reqBody, timestamp: Date.now(),
+      })
+    })
+    bp.page.on("response", async (resp) => {
+      const key = resp.url() + resp.request().method()
+      const start = timings.get(key)
+      const duration = start ? Date.now() - start : undefined
+      let entry = bp.networkEntries.find(e => e.url === resp.url() && e.method === resp.request().method())
+      if (!entry) {
+        entry = { idx: ++bp.netIdx, method: resp.request().method(), url: resp.url(), timestamp: Date.now() }
+        bp.networkEntries.push(entry)
+      }
+      entry.status = resp.status()
+      entry.statusText = resp.statusText()
+      entry.duration = duration
+      entry.resHeaders = resp.headers() as Record<string, string>
+      try {
+        const ct = resp.headers()["content-type"] ?? ""
+        if (ct.includes("json") || ct.includes("text") || ct.includes("xml") || ct.includes("javascript")) {
+          entry.resBody = await resp.text().catch(() => undefined)
+        }
+      } catch {}
+    })
+    bp.page.on("requestfailed", (req) => {
+      bp.networkEntries.push({
+        idx: ++bp.netIdx, method: req.method(), url: req.url(),
+        error: req.failure()?.errorText ?? "Unknown error",
+        reqHeaders: req.headers() as Record<string, string>,
+        timestamp: Date.now(),
+      })
+    })
+  }
+
+  private startCleanup(): void {
+    if (this.cleanupTimer) return
+    this.cleanupTimer = setInterval(() => {
+      const now = Date.now()
+      for (const [id, session] of this.sessions) {
+        if (now - session.lastActivity > SESSION_TTL_MS) {
+          for (const bp of session.pages) {
+            bp.page.close().catch(() => {})
+          }
+          session.browser.close().catch(() => {})
+          this.sessions.delete(id)
+        }
+      }
+      if (this.sessions.size === 0 && this.cleanupTimer) {
+        clearInterval(this.cleanupTimer)
+        this.cleanupTimer = null
+      }
+    }, 60_000).unref()
+  }
+}
+
+/** Singleton instance */
+export const browserPool = new BrowserSessionPool()