- create and register named browser sessions on open/exec when missing - align scenario step DTO/entity/service by removing sessionName usage - update MCP scenario-step schemas to use optional title fields
213 lines
6.4 KiB
TypeScript
213 lines
6.4 KiB
TypeScript
import {
|
|
Injectable,
|
|
HttpException,
|
|
InternalServerErrorException,
|
|
} from "@nestjs/common";
|
|
import { TraceLogger } from "../common/trace-logger";
|
|
import { chromium } from "playwright";
|
|
import type { BrowserContext } from "playwright";
|
|
import { Readability } from "@mozilla/readability";
|
|
import { JSDOM } from "jsdom";
|
|
import { SessionContextService } from "../session/session-context.service";
|
|
import { SessionService } from "../session/session.service";
|
|
import { CodeExecutorService } from "../code-executor/code-executor.service";
|
|
import type { ExecResult } from "../code-executor/code-executor.service";
|
|
import type { Cookie } from "playwright";
|
|
|
|
export type { ExecResult } from "../code-executor/code-executor.service";
|
|
|
|
export interface OpenResult {
|
|
url: string;
|
|
title: string;
|
|
content: string;
|
|
}
|
|
|
|
@Injectable()
|
|
export class BrowserService {
|
|
private readonly logger = new TraceLogger(BrowserService.name);
|
|
|
|
constructor(
|
|
private readonly sessionContextService: SessionContextService,
|
|
private readonly sessionService: SessionService,
|
|
private readonly codeExecutor: CodeExecutorService,
|
|
) {}
|
|
|
|
private parseCookies(raw: string | null | undefined): Cookie[] {
|
|
if (!raw) return [];
|
|
try {
|
|
const parsed = JSON.parse(raw) as unknown;
|
|
return Array.isArray(parsed) ? (parsed as Cookie[]) : [];
|
|
} catch {
|
|
return [];
|
|
}
|
|
}
|
|
|
|
private async getOrCreateNamedHandle(sessionName: string) {
|
|
try {
|
|
return await this.sessionContextService.getHandle(sessionName);
|
|
} catch {
|
|
this.logger.log(
|
|
`[${sessionName}] creating session context automatically`,
|
|
);
|
|
|
|
const browser = await chromium.launch({
|
|
headless: true,
|
|
executablePath: process.env.PLAYWRIGHT_CHROMIUM_EXECUTABLE_PATH,
|
|
});
|
|
const context = await browser.newContext();
|
|
const page = await context.newPage();
|
|
|
|
const existing = await this.sessionService.findBySessionName(sessionName);
|
|
const cookies = this.parseCookies(existing?.cookies);
|
|
if (cookies.length > 0) {
|
|
await context.addCookies(cookies);
|
|
}
|
|
|
|
this.sessionContextService.register(sessionName, browser, context, page);
|
|
|
|
await this.sessionService.upsert(
|
|
sessionName,
|
|
existing?.token ?? `auto:${sessionName}`,
|
|
await context.cookies(),
|
|
{},
|
|
);
|
|
|
|
return { browser, context, page };
|
|
}
|
|
}
|
|
|
|
private rethrow(err: unknown, label: string, operation: string): never {
|
|
if (err instanceof HttpException) {
|
|
throw err;
|
|
}
|
|
throw new InternalServerErrorException(
|
|
`[${label}] Browser ${operation} failed: ${(err as Error).message}`,
|
|
{ cause: err },
|
|
);
|
|
}
|
|
|
|
private async extractContent(
|
|
context: BrowserContext,
|
|
url: string,
|
|
readerMode: boolean,
|
|
selector?: string,
|
|
): Promise<OpenResult> {
|
|
const page = await context.newPage();
|
|
try {
|
|
this.logger.log(`Opening ${url}`);
|
|
await page.goto(url, { waitUntil: "networkidle" });
|
|
|
|
const finalUrl = page.url();
|
|
const title = await page.title();
|
|
const rawHtml = await page.content();
|
|
|
|
let content: string;
|
|
if (selector) {
|
|
const dom = new JSDOM(rawHtml, { url: finalUrl });
|
|
const el = dom.window.document.querySelector(selector);
|
|
content = readerMode
|
|
? (el?.textContent?.replace(/\s+/g, " ").trim() ?? "")
|
|
: (el?.outerHTML ?? "");
|
|
} else if (readerMode) {
|
|
const dom = new JSDOM(rawHtml, { url: finalUrl });
|
|
const article = new Readability(dom.window.document).parse();
|
|
content = article
|
|
? article.textContent.replace(/\s+/g, " ").trim()
|
|
: rawHtml;
|
|
} else {
|
|
content = rawHtml;
|
|
}
|
|
|
|
this.logger.log(
|
|
`Loaded: ${finalUrl} — "${title}"${readerMode ? " (reader mode)" : ""}${selector ? ` (selector: ${selector})` : ""}`,
|
|
);
|
|
return { url: finalUrl, title, content };
|
|
} finally {
|
|
await page.close();
|
|
}
|
|
}
|
|
|
|
async open(
|
|
sessionName: string | undefined,
|
|
url: string,
|
|
readerMode = false,
|
|
selector?: string,
|
|
): Promise<OpenResult> {
|
|
const label = sessionName ?? "anonymous";
|
|
this.logger.log(`[${label}] open: ${url}`);
|
|
|
|
if (sessionName) {
|
|
const { context } = await this.getOrCreateNamedHandle(sessionName);
|
|
try {
|
|
return await this.extractContent(context, url, readerMode, selector);
|
|
} catch (err) {
|
|
this.rethrow(err, label, "open");
|
|
}
|
|
}
|
|
|
|
// Anonymous — ephemeral browser
|
|
const browser = await chromium.launch({
|
|
headless: true,
|
|
executablePath: process.env.PLAYWRIGHT_CHROMIUM_EXECUTABLE_PATH,
|
|
});
|
|
try {
|
|
const context = await browser.newContext();
|
|
return await this.extractContent(context, url, readerMode, selector);
|
|
} catch (err) {
|
|
this.rethrow(err, label, "open");
|
|
} finally {
|
|
await browser.close();
|
|
}
|
|
}
|
|
|
|
async exec(
|
|
sessionName: string | undefined,
|
|
code: string,
|
|
url?: string,
|
|
): Promise<ExecResult> {
|
|
const label = sessionName ?? "anonymous";
|
|
|
|
if (sessionName) {
|
|
const { page, context } =
|
|
await this.getOrCreateNamedHandle(sessionName);
|
|
this.logger.log(`[${label}] exec: using persistent context`);
|
|
try {
|
|
if (url) {
|
|
this.logger.log(`[${label}] exec: navigating to ${url}`);
|
|
await page.goto(url, { waitUntil: "networkidle" });
|
|
}
|
|
this.logger.log(`[${label}] exec: running user code`);
|
|
const result = await this.codeExecutor.execute(page, context, code);
|
|
this.logger.log(`[${label}] exec: done`);
|
|
return result;
|
|
} catch (err) {
|
|
this.rethrow(err, label, "exec");
|
|
}
|
|
}
|
|
|
|
// Anonymous — ephemeral browser
|
|
const browser = await chromium.launch({
|
|
headless: true,
|
|
executablePath: process.env.PLAYWRIGHT_CHROMIUM_EXECUTABLE_PATH,
|
|
});
|
|
try {
|
|
const context = await browser.newContext();
|
|
const page = await context.newPage();
|
|
|
|
if (url) {
|
|
this.logger.log(`[${label}] exec: navigating to ${url}`);
|
|
await page.goto(url, { waitUntil: "networkidle" });
|
|
}
|
|
|
|
this.logger.log(`[${label}] exec: running user code`);
|
|
const result = await this.codeExecutor.execute(page, context, code);
|
|
this.logger.log(`[${label}] exec: done`);
|
|
return result;
|
|
} catch (err) {
|
|
this.rethrow(err, label, "exec");
|
|
} finally {
|
|
await browser.close();
|
|
}
|
|
}
|
|
}
|