browse-agent-cli 0.0.1

package/dist/config.js

@@ -0,0 +1,218 @@
+import { execSync } from "node:child_process";
+import { cpSync, existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+//#region src/scripts/config.ts
+const CLI_RUNTIME_DIR = dirname(fileURLToPath(import.meta.url));
+const HOME = process.env.HOME || process.env.USERPROFILE || "";
+const BROWSER_PATHS = {
+	chrome: {
+		darwin: ["/Applications/Google Chrome.app/Contents/MacOS/Google Chrome"],
+		linux: ["google-chrome", "google-chrome-stable"],
+		win32: [
+			`${process.env.PROGRAMFILES}\\Google\\Chrome\\Application\\chrome.exe`,
+			`${process.env["PROGRAMFILES(X86)"]}\\Google\\Chrome\\Application\\chrome.exe`,
+			`${process.env.LOCALAPPDATA}\\Google\\Chrome\\Application\\chrome.exe`
+		],
+		aix: [],
+		android: [],
+		freebsd: [],
+		haiku: [],
+		openbsd: [],
+		sunos: [],
+		cygwin: [],
+		netbsd: []
+	},
+	chromium: {
+		darwin: ["/Applications/Chromium.app/Contents/MacOS/Chromium"],
+		linux: ["chromium-browser", "chromium"],
+		win32: [`${process.env.LOCALAPPDATA}\\Chromium\\Application\\chrome.exe`],
+		aix: [],
+		android: [],
+		freebsd: [],
+		haiku: [],
+		openbsd: [],
+		sunos: [],
+		cygwin: [],
+		netbsd: []
+	},
+	edge: {
+		darwin: ["/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge"],
+		linux: ["microsoft-edge", "microsoft-edge-stable"],
+		win32: [`${process.env.PROGRAMFILES}\\Microsoft\\Edge\\Application\\msedge.exe`, `${process.env["PROGRAMFILES(X86)"]}\\Microsoft\\Edge\\Application\\msedge.exe`],
+		aix: [],
+		android: [],
+		freebsd: [],
+		haiku: [],
+		openbsd: [],
+		sunos: [],
+		cygwin: [],
+		netbsd: []
+	},
+	brave: {
+		darwin: ["/Applications/Brave Browser.app/Contents/MacOS/Brave Browser"],
+		linux: ["brave-browser", "brave"],
+		win32: [`${process.env.PROGRAMFILES}\\BraveSoftware\\Brave-Browser\\Application\\brave.exe`, `${process.env.LOCALAPPDATA}\\BraveSoftware\\Brave-Browser\\Application\\brave.exe`],
+		aix: [],
+		android: [],
+		freebsd: [],
+		haiku: [],
+		openbsd: [],
+		sunos: [],
+		cygwin: [],
+		netbsd: []
+	}
+};
+const BASE_DIR = join(CLI_RUNTIME_DIR, ".browse-agent");
+const DEFAULT_SERVICE_PORT = Number(process.env.BROWSE_AGENT_SERVICE_PORT || 9316);
+async function importSdk() {
+	try {
+		return await import("browse-agent-sdk");
+	} catch {}
+	const globalSdk = join(dirname(CLI_RUNTIME_DIR), "node_modules", "browse-agent-sdk");
+	if (existsSync(globalSdk)) {
+		const pkg = JSON.parse(readFileSync(join(globalSdk, "package.json"), "utf8"));
+		return await import(pathToFileURL(join(globalSdk, pkg.module || pkg.main || "index.js")).href);
+	}
+	throw new Error("browse-agent-sdk not found. Run \"setup\" first.");
+}
+const DEFAULT_PROFILE_PATHS = {
+	chrome: {
+		darwin: join(HOME, "Library", "Application Support", "Google", "Chrome"),
+		linux: join(HOME, ".config", "google-chrome"),
+		win32: join(process.env.LOCALAPPDATA || "", "Google", "Chrome", "User Data"),
+		aix: "",
+		android: "",
+		freebsd: "",
+		haiku: "",
+		openbsd: "",
+		sunos: "",
+		cygwin: "",
+		netbsd: ""
+	},
+	chromium: {
+		darwin: join(HOME, "Library", "Application Support", "Chromium"),
+		linux: join(HOME, ".config", "chromium"),
+		win32: join(process.env.LOCALAPPDATA || "", "Chromium", "User Data"),
+		aix: "",
+		android: "",
+		freebsd: "",
+		haiku: "",
+		openbsd: "",
+		sunos: "",
+		cygwin: "",
+		netbsd: ""
+	},
+	edge: {
+		darwin: join(HOME, "Library", "Application Support", "Microsoft Edge"),
+		linux: join(HOME, ".config", "microsoft-edge"),
+		win32: join(process.env.LOCALAPPDATA || "", "Microsoft", "Edge", "User Data"),
+		aix: "",
+		android: "",
+		freebsd: "",
+		haiku: "",
+		openbsd: "",
+		sunos: "",
+		cygwin: "",
+		netbsd: ""
+	},
+	brave: {
+		darwin: join(HOME, "Library", "Application Support", "BraveSoftware", "Brave-Browser"),
+		linux: join(HOME, ".config", "BraveSoftware", "Brave-Browser"),
+		win32: join(process.env.LOCALAPPDATA || "", "BraveSoftware", "Brave-Browser", "User Data"),
+		aix: "",
+		android: "",
+		freebsd: "",
+		haiku: "",
+		openbsd: "",
+		sunos: "",
+		cygwin: "",
+		netbsd: ""
+	}
+};
+function saveSession(data) {
+	mkdirSync(BASE_DIR, { recursive: true });
+	writeFileSync(join(BASE_DIR, "_session.json"), JSON.stringify(data, null, 2));
+}
+function loadSession() {
+	const stateFile = join(BASE_DIR, "_session.json");
+	if (!existsSync(stateFile)) return null;
+	return JSON.parse(readFileSync(stateFile, "utf8"));
+}
+function clearSession() {
+	const stateFile = join(BASE_DIR, "_session.json");
+	if (existsSync(stateFile)) rmSync(stateFile);
+}
+function saveServiceSession(data) {
+	mkdirSync(BASE_DIR, { recursive: true });
+	writeFileSync(join(BASE_DIR, "_service.json"), JSON.stringify(data, null, 2));
+}
+function loadServiceSession() {
+	const stateFile = join(BASE_DIR, "_service.json");
+	if (!existsSync(stateFile)) return null;
+	return JSON.parse(readFileSync(stateFile, "utf8"));
+}
+function clearServiceSession() {
+	const stateFile = join(BASE_DIR, "_service.json");
+	if (existsSync(stateFile)) rmSync(stateFile);
+}
+function findBrowser(browser) {
+	if (process.env.CHROME_PATH) return process.env.CHROME_PATH;
+	const paths = BROWSER_PATHS[browser];
+	if (!paths) throw new Error(`Unknown browser: ${browser}. Use: chrome, chromium, edge, brave`);
+	const isAbsolute = (path) => path.startsWith("/") || /^[a-zA-Z]:\\/.test(path);
+	const whichCmd = process.platform === "win32" ? "where" : "which";
+	for (const path of paths[process.platform] || []) try {
+		if (isAbsolute(path)) {
+			if (existsSync(path)) return path;
+		} else {
+			const resolved = execSync(`${whichCmd} "${path}"`, { stdio: "pipe" }).toString().trim().split("\n")[0];
+			if (resolved) return resolved;
+		}
+	} catch {}
+	if (browser !== "edge") {
+		console.error(`[browse-agent] ${browser} not found, falling back to edge...`);
+		return findBrowser("edge");
+	}
+	throw new Error("No supported browser found. Set CHROME_PATH env variable or install Chrome/Edge.");
+}
+function getProfileDir(browser, useUserProfile) {
+	if (useUserProfile) {
+		const profilePath = DEFAULT_PROFILE_PATHS[browser]?.[process.platform];
+		if (profilePath && existsSync(profilePath)) return profilePath;
+		console.error(`[browse-agent] Default ${browser} profile not found at ${profilePath}`);
+		console.error("[browse-agent] Falling back to isolated profile.");
+	}
+	const dir = join(BASE_DIR, "chrome-profile");
+	mkdirSync(dir, { recursive: true });
+	return dir;
+}
+function patchExtension(port, secret) {
+	const extensionSrc = join(BASE_DIR, "extension");
+	const extensionWork = join(BASE_DIR, "_ext_work");
+	if (!existsSync(join(extensionSrc, "manifest.json"))) throw new Error(`Extension is not installed at ${extensionSrc}. Run "browse-agent setup" first.`);
+	if (existsSync(extensionWork)) rmSync(extensionWork, { recursive: true });
+	cpSync(extensionSrc, extensionWork, { recursive: true });
+	const swPath = join(extensionWork, "service-worker.js");
+	const originalSW = readFileSync(swPath, "utf8");
+	writeFileSync(swPath, [`chrome.storage.local.set({ wsUrl: 'ws://127.0.0.1:${port}', secret: '${secret}' });`, originalSW].join("\n"));
+	return extensionWork;
+}
+function cleanExtensionWork() {
+	const extensionWork = join(BASE_DIR, "_ext_work");
+	if (existsSync(extensionWork)) rmSync(extensionWork, { recursive: true });
+}
+function resolveOptions(options = {}) {
+	return {
+		browser: options.browser ?? process.env.BROWSER ?? "chrome",
+		headless: options.headless ?? process.env.HEADLESS === "true",
+		useUserProfile: options.useUserProfile ?? process.env.USE_USER_PROFILE === "true",
+		port: options.port ?? Number(process.env.BROWSE_AGENT_PORT || 9315),
+		timeout: options.timeout ?? Number(process.env.CONNECTION_TIMEOUT || 3e4),
+		secret: options.secret ?? process.env.SHARED_SECRET ?? ""
+	};
+}
+//#endregion
+export { clearSession as a, importSdk as c, patchExtension as d, resolveOptions as f, clearServiceSession as i, loadServiceSession as l, saveSession as m, DEFAULT_SERVICE_PORT as n, findBrowser as o, saveServiceSession as p, cleanExtensionWork as r, getProfileDir as s, BASE_DIR as t, loadSession as u };
+
+//# sourceMappingURL=config.js.map

package/dist/script.d.ts

@@ -0,0 +1,113 @@
+import "browse-agent-sdk";
+
+//#region src/scripts/config.d.ts
+type BrowserName = 'chrome' | 'chromium' | 'edge' | 'brave';
+interface SessionData {
+  pid?: number;
+  port: number;
+  secret: string;
+  browser: BrowserName;
+  profileDir: string;
+  extensionWork: string;
+  startedAt: string;
+  _agent?: any;
+  _proc?: any;
+}
+//#endregion
+//#region src/scripts/launch-browser.d.ts
+interface LaunchOptions {
+  browser?: 'chrome' | 'chromium' | 'edge' | 'brave';
+  headless?: boolean;
+  useUserProfile?: boolean;
+  port?: number;
+  timeout?: number;
+  secret?: string;
+}
+declare function launchBrowser(options?: LaunchOptions): Promise<SessionData>;
+//#endregion
+//#region src/scripts/connect.d.ts
+interface ConnectOptions {
+  port?: number;
+  secret?: string;
+  timeout?: number;
+}
+declare function connect(options?: ConnectOptions): Promise<any>;
+//#endregion
+//#region src/scripts/close-browser.d.ts
+declare function closeBrowser(agent?: {
+  stop?: () => Promise<void>;
+}): Promise<void>;
+//#endregion
+//#region src/scripts/clear.d.ts
+declare function clear(): Promise<void>;
+//#endregion
+//#region src/scripts/navigate.d.ts
+declare function navigate(agent: any, url: string, options?: Record<string, unknown>): Promise<unknown>;
+//#endregion
+//#region src/scripts/get-content.d.ts
+interface GetContentOptions {
+  format?: string;
+  tabId?: number;
+}
+declare function getContent(agent: any, options?: GetContentOptions): Promise<unknown>;
+//#endregion
+//#region src/scripts/get-dom.d.ts
+interface GetDomOptions {
+  property?: string;
+  all?: boolean;
+  tabId?: number;
+}
+declare function getDOM(agent: any, selector: string, options?: GetDomOptions): Promise<unknown>;
+//#endregion
+//#region src/scripts/evaluate.d.ts
+interface EvaluateOptions {
+  tabId?: number;
+}
+declare function evaluate(agent: any, expression: string, options?: EvaluateOptions): Promise<unknown>;
+//#endregion
+//#region src/scripts/inject-script.d.ts
+interface InjectScriptOptions {
+  tabId?: number;
+}
+declare function injectScript(agent: any, code: string, options?: InjectScriptOptions): Promise<unknown>;
+//#endregion
+//#region src/scripts/inject-css.d.ts
+interface InjectCssOptions {
+  tabId?: number;
+}
+declare function injectCSS(agent: any, code: string, options?: InjectCssOptions): Promise<unknown>;
+//#endregion
+//#region src/scripts/screenshot.d.ts
+interface ScreenshotClip {
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+}
+interface ScreenshotOptions {
+  format?: string;
+  quality?: number;
+  tabId?: number;
+  clip?: ScreenshotClip;
+}
+declare function screenshot(agent: any, mode?: string, options?: ScreenshotOptions): Promise<unknown>;
+//#endregion
+//#region src/scripts/tabs.d.ts
+declare function listTabs(agent: any): Promise<unknown>;
+declare function closeTab(agent: any, tabId: number): Promise<void>;
+declare function activateTab(agent: any, tabId: number): Promise<void>;
+//#endregion
+//#region src/scripts/browse.d.ts
+interface BrowseOptions {
+  browser?: 'chrome' | 'chromium' | 'edge' | 'brave';
+  headless?: boolean;
+  useUserProfile?: boolean;
+  port?: number;
+  timeout?: number;
+  secret?: string;
+  printResult?: boolean;
+}
+declare function browse(task: (agent: any) => Promise<unknown>, options?: BrowseOptions): Promise<unknown>;
+//#endregion
+export { activateTab, browse, clear, closeBrowser, closeTab, connect, evaluate, getContent, getDOM, injectCSS, injectScript, launchBrowser, listTabs, navigate, screenshot };
+//# sourceMappingURL=script.d.ts.map

package/dist/script.js

@@ -0,0 +1,53 @@
+import { c as importSdk, f as resolveOptions, r as cleanExtensionWork, u as loadSession } from "./config.js";
+import { t as clear } from "./clear.js";
+import { a as injectCSS, c as getDOM, d as closeBrowser, f as launchBrowser, i as screenshot, l as getContent, n as closeTab, o as injectScript, r as listTabs, s as evaluate, t as activateTab, u as navigate } from "./tabs.js";
+//#region src/scripts/connect.ts
+async function connect(options = {}) {
+	const { BrowserAgent } = await importSdk();
+	const session = loadSession();
+	const port = options.port ?? session?.port ?? resolveOptions().port;
+	const secret = options.secret ?? session?.secret ?? resolveOptions().secret;
+	const timeout = options.timeout ?? resolveOptions().timeout;
+	const agent = new BrowserAgent({
+		secret,
+		port
+	});
+	await agent.start();
+	console.error(`[browse-agent] Connecting on port ${port}...`);
+	await agent.waitForConnection(timeout);
+	console.error("[browse-agent] Extension connected");
+	return agent;
+}
+//#endregion
+//#region src/scripts/browse.ts
+async function browse(task, options = {}) {
+	const opts = resolveOptions(options);
+	let session;
+	let agent;
+	let taskResult;
+	try {
+		session = await launchBrowser(opts);
+		agent = session._agent;
+		await agent.waitForConnection(opts.timeout);
+		console.error("[browse-agent] Extension connected");
+		taskResult = await task(agent);
+		if (options.printResult !== false && taskResult !== void 0) console.log(JSON.stringify(taskResult, null, 2));
+	} catch (err) {
+		const message = err instanceof Error ? err.message : String(err);
+		console.error("[browse-agent] Error:", message);
+		process.exit(1);
+	} finally {
+		if (session?._proc) try {
+			session._proc.kill();
+		} catch {}
+		if (agent) try {
+			await agent.stop();
+		} catch {}
+		cleanExtensionWork();
+	}
+	return taskResult;
+}
+//#endregion
+export { activateTab, browse, clear, closeBrowser, closeTab, connect, evaluate, getContent, getDOM, injectCSS, injectScript, launchBrowser, listTabs, navigate, screenshot };
+
+//# sourceMappingURL=script.js.map

package/dist/service.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/service.js

@@ -0,0 +1,156 @@
+import { f as resolveOptions, i as clearServiceSession, n as DEFAULT_SERVICE_PORT, p as saveServiceSession } from "./config.js";
+import { a as injectCSS, c as getDOM, d as closeBrowser, f as launchBrowser, i as screenshot, l as getContent, n as closeTab, o as injectScript, r as listTabs, s as evaluate, t as activateTab, u as navigate } from "./tabs.js";
+import { createServer } from "node:http";
+//#region src/service.ts
+function toCommandRequest(value) {
+	const name = value.name;
+	if (typeof name !== "string" || name.length === 0) throw new Error("Invalid command request: \"name\" must be a non-empty string.");
+	const payloadRaw = value.payload;
+	return {
+		name,
+		payload: payloadRaw !== void 0 && payloadRaw !== null && typeof payloadRaw === "object" ? payloadRaw : void 0
+	};
+}
+let currentSession = null;
+let currentAgent = null;
+function getServicePort() {
+	const index = process.argv.findIndex((arg) => arg === "--service-port");
+	if (index !== -1 && process.argv[index + 1]) {
+		const parsed = Number(process.argv[index + 1]);
+		if (!Number.isNaN(parsed)) return parsed;
+	}
+	return DEFAULT_SERVICE_PORT;
+}
+function writeJson(res, status, body) {
+	res.statusCode = status;
+	res.setHeader("Content-Type", "application/json; charset=utf-8");
+	res.end(JSON.stringify(body));
+}
+async function readJson(req) {
+	const chunks = [];
+	for await (const chunk of req) chunks.push(Buffer.from(chunk));
+	if (chunks.length === 0) return {};
+	const raw = Buffer.concat(chunks).toString("utf8");
+	if (!raw) return {};
+	return JSON.parse(raw);
+}
+function sessionInfo(session) {
+	if (!session) return { running: false };
+	const { _agent, _proc, ...info } = session;
+	return {
+		running: true,
+		...info
+	};
+}
+async function handleLaunch(body) {
+	if (currentSession && currentAgent) return sessionInfo(currentSession);
+	const options = {
+		browser: body.browser,
+		headless: body.headless,
+		port: body.port,
+		timeout: body.timeout,
+		secret: body.secret
+	};
+	const session = await launchBrowser(options);
+	currentSession = session;
+	currentAgent = session._agent;
+	const timeout = resolveOptions(options).timeout;
+	await currentAgent.waitForConnection(timeout);
+	return sessionInfo(session);
+}
+async function handleCommand(body) {
+	if (!currentAgent) throw new Error("Service is running but browser session is not started. Run \"browse-agent launch\" first.");
+	const payload = body.payload ?? {};
+	switch (body.name) {
+		case "navigate": return navigate(currentAgent, String(payload.url), payload.options ?? {});
+		case "get-content": return getContent(currentAgent, payload.options ?? {});
+		case "get-dom": return getDOM(currentAgent, String(payload.selector), payload.options ?? {});
+		case "evaluate": return evaluate(currentAgent, String(payload.expression), payload.options ?? {});
+		case "inject-script": return injectScript(currentAgent, String(payload.code), payload.options ?? {});
+		case "inject-css": return injectCSS(currentAgent, String(payload.code), payload.options ?? {});
+		case "screenshot": return screenshot(currentAgent, String(payload.mode ?? "visible"), payload.options ?? {});
+		case "tabs-list": return listTabs(currentAgent);
+		case "tabs-close":
+			await closeTab(currentAgent, Number(payload.tabId));
+			return { closed: Number(payload.tabId) };
+		case "tabs-activate":
+			await activateTab(currentAgent, Number(payload.tabId));
+			return { activated: Number(payload.tabId) };
+		default: throw new Error(`Unknown command: ${body.name}`);
+	}
+}
+async function stopBrowserSession() {
+	if (!currentSession && !currentAgent) return;
+	await closeBrowser(currentAgent ?? void 0);
+	currentSession = null;
+	currentAgent = null;
+}
+const servicePort = getServicePort();
+const server = createServer(async (req, res) => {
+	try {
+		const method = req.method ?? "GET";
+		const url = req.url ?? "/";
+		if (method === "GET" && url === "/health") {
+			writeJson(res, 200, {
+				ok: true,
+				servicePort,
+				pid: process.pid
+			});
+			return;
+		}
+		if (method === "GET" && url === "/status") {
+			writeJson(res, 200, {
+				servicePort,
+				pid: process.pid,
+				...sessionInfo(currentSession)
+			});
+			return;
+		}
+		if (method === "POST" && url === "/launch") {
+			writeJson(res, 200, await handleLaunch(await readJson(req)));
+			return;
+		}
+		if (method === "POST" && url === "/command") {
+			writeJson(res, 200, await handleCommand(toCommandRequest(await readJson(req))));
+			return;
+		}
+		if (method === "POST" && url === "/close") {
+			await stopBrowserSession();
+			writeJson(res, 200, { closed: true });
+			return;
+		}
+		if (method === "POST" && url === "/shutdown") {
+			await stopBrowserSession();
+			clearServiceSession();
+			writeJson(res, 200, { stopped: true });
+			server.close(() => {
+				process.exit(0);
+			});
+			return;
+		}
+		writeJson(res, 404, { error: `Unknown route: ${method} ${url}` });
+	} catch (err) {
+		writeJson(res, 500, { error: err instanceof Error ? err.message : String(err) });
+	}
+});
+server.listen(servicePort, "127.0.0.1", () => {
+	saveServiceSession({
+		pid: process.pid,
+		servicePort,
+		startedAt: (/* @__PURE__ */ new Date()).toISOString()
+	});
+});
+process.on("SIGINT", async () => {
+	await stopBrowserSession();
+	clearServiceSession();
+	process.exit(0);
+});
+process.on("SIGTERM", async () => {
+	await stopBrowserSession();
+	clearServiceSession();
+	process.exit(0);
+});
+//#endregion
+export {};
+
+//# sourceMappingURL=service.js.map

package/dist/tabs.js

@@ -0,0 +1,126 @@
+import { a as clearSession, c as importSdk, d as patchExtension, f as resolveOptions, m as saveSession, o as findBrowser, r as cleanExtensionWork, s as getProfileDir, u as loadSession } from "./config.js";
+import { spawn } from "node:child_process";
+//#region src/scripts/launch-browser.ts
+async function launchBrowser(options = {}) {
+	const { BrowserAgent } = await importSdk();
+	const opts = resolveOptions(options);
+	const extensionWork = patchExtension(opts.port, opts.secret);
+	const profileDir = getProfileDir(opts.browser, opts.useUserProfile ?? true);
+	const agent = new BrowserAgent({
+		secret: opts.secret,
+		port: opts.port
+	});
+	await agent.start();
+	console.error(`[browse-agent] Server started on port ${opts.port}`);
+	const launchArgs = [
+		`--load-extension=${extensionWork}`,
+		"--no-first-run",
+		"--no-default-browser-check"
+	];
+	if (opts.headless) launchArgs.push("--headless=new");
+	const proc = spawn(findBrowser(opts.browser), launchArgs, {
+		stdio: "ignore",
+		detached: true
+	});
+	proc.on("error", (err) => {
+		console.error(`[browse-agent] ${opts.browser} launch failed:`, err.message);
+		process.exit(1);
+	});
+	proc.unref();
+	const session = {
+		pid: proc.pid,
+		port: opts.port,
+		secret: opts.secret,
+		browser: opts.browser,
+		profileDir,
+		extensionWork,
+		startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+		_agent: agent,
+		_proc: proc
+	};
+	saveSession(session);
+	console.error(`[browse-agent] Browser launched (PID: ${proc.pid})`);
+	return session;
+}
+//#endregion
+//#region src/scripts/close-browser.ts
+async function closeBrowser(agent) {
+	const session = loadSession();
+	if (session?.pid) try {
+		process.kill(session.pid);
+		console.error(`[browse-agent] Browser (PID: ${session.pid}) killed`);
+	} catch (err) {
+		const killErr = err;
+		if (killErr.code === "ESRCH") console.error(`[browse-agent] Browser (PID: ${session.pid}) already exited`);
+		else console.error("[browse-agent] Failed to kill browser:", killErr.message);
+	}
+	if (agent?.stop) try {
+		await agent.stop();
+	} catch {}
+	cleanExtensionWork();
+	clearSession();
+	console.error("[browse-agent] Session cleaned up");
+}
+//#endregion
+//#region src/scripts/navigate.ts
+async function navigate(agent, url, options = {}) {
+	return await agent.navigate(url, options);
+}
+//#endregion
+//#region src/scripts/get-content.ts
+async function getContent(agent, options = {}) {
+	return await agent.getContent(options);
+}
+//#endregion
+//#region src/scripts/get-dom.ts
+async function getDOM(agent, selector, options = {}) {
+	return await agent.getDOM(selector, options);
+}
+//#endregion
+//#region src/scripts/evaluate.ts
+async function evaluate(agent, expression, options = {}) {
+	return await agent.evaluate(expression, options.tabId);
+}
+//#endregion
+//#region src/scripts/inject-script.ts
+async function injectScript(agent, code, options = {}) {
+	return await agent.injectScript(code, options.tabId);
+}
+//#endregion
+//#region src/scripts/inject-css.ts
+async function injectCSS(agent, code, options = {}) {
+	return await agent.injectCSS(code, options.tabId);
+}
+//#endregion
+//#region src/scripts/screenshot.ts
+async function screenshot(agent, mode = "visible", options = {}) {
+	let result;
+	switch (mode) {
+		case "fullPage":
+			result = await agent.screenshotFullPage(options);
+			break;
+		case "area":
+			if (!options.clip) throw new Error("clip option required for area screenshot");
+			result = await agent.screenshotArea(options.clip, options);
+			break;
+		default:
+			result = await agent.screenshotVisible(options);
+			break;
+	}
+	return result;
+}
+//#endregion
+//#region src/scripts/tabs.ts
+async function listTabs(agent) {
+	return await agent.listTabs();
+}
+async function closeTab(agent, tabId) {
+	await agent.closeTab(tabId);
+}
+async function activateTab(agent, tabId) {
+	await agent.activateTab(tabId);
+}
+//#endregion
+export { injectCSS as a, getDOM as c, closeBrowser as d, launchBrowser as f, screenshot as i, getContent as l, closeTab as n, injectScript as o, listTabs as r, evaluate as s, activateTab as t, navigate as u };
+
+//# sourceMappingURL=tabs.js.map