@ulpi/browse 0.10.0 → 1.0.1

package/src/session-manager.ts

@@ -1,240 +0,0 @@
-/**
- * Session manager — multiplexes multiple agents on a single Chromium instance
- *
- * Each session gets its own BrowserManager (tabs, refs, cookies, storage)
- * backed by an isolated BrowserContext on the shared Browser.
- * Sessions are identified by string IDs (from X-Browse-Session header).
- */
-
-import type { Browser } from 'playwright';
-import { BrowserManager } from './browser-manager';
-import { SessionBuffers } from './buffers';
-import { DomainFilter } from './domain-filter';
-import { sanitizeName } from './sanitize';
-import { saveSessionState, loadSessionState, hasPersistedState } from './session-persist';
-import { resolveEncryptionKey } from './encryption';
-import * as fs from 'fs';
-import * as path from 'path';
-
-export interface RecordedStep {
-  command: string;
-  args: string[];
-  timestamp: number;
-}
-
-export interface Session {
-  id: string;
-  manager: BrowserManager;
-  buffers: SessionBuffers;
-  domainFilter: DomainFilter | null;
-  recording: RecordedStep[] | null;
-  outputDir: string;
-  lastActivity: number;
-  createdAt: number;
-}
-
-export class SessionManager {
-  private sessions = new Map<string, Session>();
-  private browser: Browser;
-  private localDir: string;
-  private encryptionKey: Buffer | undefined;
-
-  constructor(browser: Browser, localDir: string = '/tmp') {
-    this.browser = browser;
-    this.localDir = localDir;
-    try {
-      this.encryptionKey = resolveEncryptionKey(localDir);
-    } catch {
-      // Encryption not available — persist unencrypted
-    }
-  }
-
-  /**
-   * Get an existing session or create a new one.
-   * Creating a session launches a new BrowserContext on the shared Chromium.
-   */
-  async getOrCreate(sessionId: string, allowedDomains?: string): Promise<Session> {
-    let session = this.sessions.get(sessionId);
-    if (session) {
-      session.lastActivity = Date.now();
-      // Update domain filter if provided and session doesn't already have one
-      if (allowedDomains && !session.domainFilter) {
-        const domains = allowedDomains.split(',').map(d => d.trim()).filter(Boolean);
-        if (domains.length > 0) {
-          const domainFilter = new DomainFilter(domains);
-          session.manager.setDomainFilter(domainFilter);
-          const context = session.manager.getContext();
-          if (context) {
-            await context.route('**/*', (route) => {
-              const url = route.request().url();
-              if (domainFilter.isAllowed(url)) {
-                route.fallback();
-              } else {
-                route.abort('blockedbyclient');
-              }
-            });
-            const initScript = domainFilter.generateInitScript();
-            await context.addInitScript(initScript);
-            session.manager.setInitScript(initScript);
-            // Inject filter script into ALL open tabs immediately
-            for (const tab of session.manager.getTabList()) {
-              try {
-                const page = session.manager.getPageById(tab.id);
-                if (page) await page.evaluate(initScript);
-              } catch {}
-            }
-          }
-          session.domainFilter = domainFilter;
-        }
-      }
-      return session;
-    }
-
-    // Create per-session output directory
-    const outputDir = path.join(this.localDir, 'sessions', sanitizeName(sessionId));
-    fs.mkdirSync(outputDir, { recursive: true });
-
-    const buffers = new SessionBuffers();
-    const manager = new BrowserManager(buffers);
-    await manager.launchWithBrowser(this.browser);
-
-    // Apply domain filter if allowed domains are specified
-    let domainFilter: DomainFilter | null = null;
-    if (allowedDomains) {
-      const domains = allowedDomains.split(',').map(d => d.trim()).filter(Boolean);
-      if (domains.length > 0) {
-        domainFilter = new DomainFilter(domains);
-        manager.setDomainFilter(domainFilter);
-        const context = manager.getContext();
-        if (context) {
-          // Block disallowed domains at the network level via Playwright route()
-          await context.route('**/*', (route) => {
-            const url = route.request().url();
-            if (domainFilter!.isAllowed(url)) {
-              route.fallback();
-            } else {
-              route.abort('blockedbyclient');
-            }
-          });
-          // Block WebSocket, EventSource, sendBeacon via JS injection
-          const initScript = domainFilter.generateInitScript();
-          await context.addInitScript(initScript);
-          manager.setInitScript(initScript);
-        }
-      }
-    }
-
-    session = {
-      id: sessionId,
-      manager,
-      buffers,
-      domainFilter,
-      recording: null,
-      outputDir,
-      lastActivity: Date.now(),
-      createdAt: Date.now(),
-    };
-    this.sessions.set(sessionId, session);
-    console.log(`[browse] Session "${sessionId}" created`);
-
-    // Auto-restore persisted state for named sessions (not "default")
-    if (sessionId !== 'default' && hasPersistedState(outputDir)) {
-      const context = manager.getContext();
-      if (context) {
-        await loadSessionState(outputDir, context, this.encryptionKey);
-        console.log(`[browse] Session "${sessionId}" state restored`);
-      }
-    }
-
-    return session;
-  }
-
-  /**
-   * Close and remove a specific session.
-   */
-  async closeSession(sessionId: string): Promise<void> {
-    const session = this.sessions.get(sessionId);
-    if (!session) throw new Error(`Session "${sessionId}" not found`);
-
-    // Auto-save state for named sessions (not "default")
-    if (sessionId !== 'default') {
-      const context = session.manager.getContext();
-      if (context) {
-        await saveSessionState(session.outputDir, context, this.encryptionKey);
-      }
-    }
-
-    await session.manager.close();
-    this.sessions.delete(sessionId);
-    console.log(`[browse] Session "${sessionId}" closed`);
-  }
-
-  /**
-   * Close sessions idle longer than maxIdleMs.
-   * Returns list of closed session IDs.
-   */
-  async closeIdleSessions(maxIdleMs: number, flushFn?: (session: Session) => void): Promise<string[]> {
-    const now = Date.now();
-    const closed: string[] = [];
-
-    for (const [id, session] of this.sessions) {
-      if (now - session.lastActivity > maxIdleMs) {
-        if (flushFn) flushFn(session);
-        // Auto-save state for named sessions (not "default")
-        if (id !== 'default') {
-          const context = session.manager.getContext();
-          if (context) {
-            await saveSessionState(session.outputDir, context, this.encryptionKey).catch(() => {});
-          }
-        }
-        await session.manager.close().catch(() => {});
-        this.sessions.delete(id);
-        closed.push(id);
-      }
-    }
-
-    return closed;
-  }
-
-  /**
-   * List all active sessions (for status/sessions commands).
-   */
-  listSessions(): Array<{ id: string; tabs: number; url: string; idleSeconds: number; active: boolean }> {
-    const now = Date.now();
-    return [...this.sessions.entries()].map(([id, session]) => ({
-      id,
-      tabs: session.manager.getTabCount(),
-      url: session.manager.getCurrentUrl(),
-      idleSeconds: Math.floor((now - session.lastActivity) / 1000),
-      active: true,
-    }));
-  }
-
-  /**
-   * Get all sessions (for buffer flush iteration).
-   */
-  getAllSessions(): Session[] {
-    return [...this.sessions.values()];
-  }
-
-  getSessionCount(): number {
-    return this.sessions.size;
-  }
-
-  /**
-   * Close all sessions (for server shutdown).
-   */
-  async closeAll(): Promise<void> {
-    for (const [id, session] of this.sessions) {
-      // Auto-save state for named sessions (not "default")
-      if (id !== 'default') {
-        const context = session.manager.getContext();
-        if (context) {
-          await saveSessionState(session.outputDir, context, this.encryptionKey).catch(() => {});
-        }
-      }
-      await session.manager.close().catch(() => {});
-    }
-    this.sessions.clear();
-  }
-}

package/src/session-persist.ts

@@ -1,192 +0,0 @@
-import * as fs from 'fs';
-import * as path from 'path';
-import type { BrowserContext } from 'playwright';
-import { encrypt, decrypt } from './encryption';
-
-const STATE_FILENAME = 'state.json';
-
-/**
- * Save session state (cookies + localStorage) to disk.
- * Calls context.storageState(), optionally encrypts, writes state.json.
- * Graceful: catches errors (context already closed, etc.) and logs warning.
- */
-export async function saveSessionState(
-  sessionDir: string,
-  context: BrowserContext,
-  encryptionKey?: Buffer,
-): Promise<void> {
-  try {
-    const state = await context.storageState();
-    const json = JSON.stringify(state, null, 2);
-
-    let content: string;
-    if (encryptionKey) {
-      const { ciphertext, iv, authTag } = encrypt(json, encryptionKey);
-      content = JSON.stringify({ encrypted: true, iv, authTag, data: ciphertext }, null, 2);
-    } else {
-      content = json;
-    }
-
-    fs.mkdirSync(sessionDir, { recursive: true });
-    fs.writeFileSync(path.join(sessionDir, STATE_FILENAME), content, { mode: 0o600 });
-  } catch (err: any) {
-    console.log(`[session-persist] Warning: failed to save state: ${err.message}`);
-  }
-}
-
-/**
- * Load session state from disk into a browser context.
- * Reads state.json, optionally decrypts, applies cookies via context.addCookies().
- * Restores localStorage by navigating to each origin with 3s timeout per origin.
- * Returns true if state was loaded, false if no file/corrupted (logs warning).
- * Does NOT throw on failure.
- */
-export async function loadSessionState(
-  sessionDir: string,
-  context: BrowserContext,
-  encryptionKey?: Buffer,
-): Promise<boolean> {
-  const statePath = path.join(sessionDir, STATE_FILENAME);
-
-  if (!fs.existsSync(statePath)) {
-    return false;
-  }
-
-  let stateData: any;
-  try {
-    const raw = fs.readFileSync(statePath, 'utf-8');
-    const parsed = JSON.parse(raw);
-
-    if (parsed.encrypted) {
-      if (!encryptionKey) {
-        console.log('[session-persist] Warning: state file is encrypted but no encryption key provided');
-        return false;
-      }
-      const decrypted = decrypt(parsed.data, parsed.iv, parsed.authTag, encryptionKey);
-      stateData = JSON.parse(decrypted);
-    } else {
-      stateData = parsed;
-    }
-  } catch (err: any) {
-    console.log(`[session-persist] Warning: failed to read/decrypt state file: ${err.message}`);
-    return false;
-  }
-
-  try {
-    if (stateData.cookies?.length) {
-      try {
-        await context.addCookies(stateData.cookies);
-      } catch (err: any) {
-        console.log(`[session-persist] Warning: failed to restore cookies: ${err.message}`);
-      }
-    }
-
-    if (stateData.origins?.length) {
-      for (const origin of stateData.origins) {
-        if (!origin.localStorage?.length) continue;
-        let page: any = null;
-        try {
-          page = await context.newPage();
-          await page.goto(origin.origin, { waitUntil: 'domcontentloaded', timeout: 3000 });
-          for (const item of origin.localStorage) {
-            await page.evaluate(
-              ([k, v]: [string, string]) => localStorage.setItem(k, v),
-              [item.name, item.value],
-            );
-          }
-        } catch (err: any) {
-          console.log(`[session-persist] Warning: failed to restore localStorage for ${origin.origin}: ${err.message}`);
-        } finally {
-          if (page) {
-            try {
-              await page.close();
-            } catch (_) {
-              // page may already be closed
-            }
-          }
-        }
-      }
-    }
-
-    return true;
-  } catch (err: any) {
-    console.log(`[session-persist] Warning: failed to load state: ${err.message}`);
-    return false;
-  }
-}
-
-/**
- * Check if a persisted state file exists.
- */
-export function hasPersistedState(sessionDir: string): boolean {
-  return fs.existsSync(path.join(sessionDir, STATE_FILENAME));
-}
-
-/**
- * Delete state files older than maxAgeDays from both directories:
- * - localDir/states/ (all .json files)
- * - localDir/sessions/<id>/state.json (auto-persisted)
- */
-export function cleanOldStates(
-  localDir: string,
-  maxAgeDays: number,
-): { deleted: number } {
-  const maxAgeMs = maxAgeDays * 24 * 60 * 60 * 1000;
-  const now = Date.now();
-  let deleted = 0;
-
-  // Clean localDir/states/*.json
-  const statesDir = path.join(localDir, 'states');
-  if (fs.existsSync(statesDir)) {
-    try {
-      const entries = fs.readdirSync(statesDir);
-      for (const entry of entries) {
-        if (!entry.endsWith('.json')) continue;
-        const filePath = path.join(statesDir, entry);
-        try {
-          const stat = fs.statSync(filePath);
-          if (!stat.isFile()) continue;
-          if (now - stat.mtimeMs > maxAgeMs) {
-            fs.unlinkSync(filePath);
-            deleted++;
-          }
-        } catch (_) {
-          // stat or unlink failed, skip
-        }
-      }
-    } catch (_) {
-      // readdirSync failed, skip
-    }
-  }
-
-  // Clean localDir/sessions/*/state.json
-  const sessionsDir = path.join(localDir, 'sessions');
-  if (fs.existsSync(sessionsDir)) {
-    try {
-      const sessionDirs = fs.readdirSync(sessionsDir);
-      for (const dir of sessionDirs) {
-        const dirPath = path.join(sessionsDir, dir);
-        try {
-          const dirStat = fs.statSync(dirPath);
-          if (!dirStat.isDirectory()) continue;
-        } catch (_) {
-          continue;
-        }
-        const statePath = path.join(dirPath, STATE_FILENAME);
-        try {
-          const stat = fs.statSync(statePath);
-          if (now - stat.mtimeMs > maxAgeMs) {
-            fs.unlinkSync(statePath);
-            deleted++;
-          }
-        } catch (_) {
-          // file doesn't exist or stat/unlink failed, skip
-        }
-      }
-    } catch (_) {
-      // readdirSync failed, skip
-    }
-  }
-
-  return { deleted };
-}