hyperclaw 4.0.0 → 4.0.2

package/dist/audit-BYxPlnTQ.js

@@ -0,0 +1,248 @@
+const require_chunk = require('./chunk-jS-bbMI5.js');
+const chalk = require_chunk.__toESM(require("chalk"));
+const ora = require_chunk.__toESM(require("ora"));
+const fs_extra = require_chunk.__toESM(require("fs-extra"));
+const path = require_chunk.__toESM(require("path"));
+const os = require_chunk.__toESM(require("os"));
+
+//#region src/security/audit.ts
+const HC_DIR = path.default.join(os.default.homedir(), ".hyperclaw");
+async function checkFilePermissions() {
+	const findings = [];
+	const sensitiveFiles = [
+		path.default.join(HC_DIR, "hyperclaw.json"),
+		path.default.join(HC_DIR, "auth.json"),
+		path.default.join(HC_DIR, ".env"),
+		path.default.join(HC_DIR, "AGENTS.md")
+	];
+	for (const f of sensitiveFiles) if (await fs_extra.default.pathExists(f)) {
+		const stat = await fs_extra.default.stat(f);
+		if ((stat.mode & 63) !== 0) findings.push({
+			severity: "high",
+			category: "File Permissions",
+			title: `Unsafe permissions on ${path.default.basename(f)}`,
+			detail: `Mode ${(stat.mode & 511).toString(8)} allows group/other read`,
+			remediation: `chmod 600 ${f}`,
+			cvss: 7.5
+		});
+	}
+	const credsDir = path.default.join(HC_DIR, "credentials");
+	if (await fs_extra.default.pathExists(credsDir)) {
+		const stat = await fs_extra.default.stat(credsDir);
+		if ((stat.mode & 63) !== 0) findings.push({
+			severity: "critical",
+			category: "File Permissions",
+			title: "credentials/ directory is world-readable",
+			detail: `Mode ${(stat.mode & 511).toString(8)} — all credential files are exposed`,
+			remediation: `chmod 700 ${credsDir}`,
+			cvss: 9.1
+		});
+	}
+	return findings;
+}
+async function checkGatewayConfig() {
+	const findings = [];
+	let cfg = null;
+	try {
+		cfg = await fs_extra.default.readJson(path.default.join(HC_DIR, "hyperclaw.json"));
+	} catch {
+		return findings;
+	}
+	const token = cfg.gateway?.authToken;
+	if (!token) findings.push({
+		severity: "critical",
+		category: "Authentication",
+		title: "Gateway auth token not set",
+		detail: "Any client can connect to the gateway without authentication",
+		remediation: "hyperclaw gateway config --set-token",
+		cvss: 9.8
+	});
+	else if (token.length < 32) findings.push({
+		severity: "high",
+		category: "Authentication",
+		title: "Gateway auth token is too short",
+		detail: `Token is ${token.length} chars — minimum recommended is 32`,
+		remediation: "hyperclaw gateway config --regenerate-token",
+		cvss: 7.3
+	});
+	if (cfg.gateway?.bind === "0.0.0.0") findings.push({
+		severity: "medium",
+		category: "Network Exposure",
+		title: "Gateway bound to all interfaces (0.0.0.0)",
+		detail: "Gateway is accessible from the local network. Ensure auth token is strong.",
+		remediation: "Use 127.0.0.1 unless you need LAN access",
+		cvss: 5.3
+	});
+	if (cfg.gateway?.tailscaleExposure === "funnel") findings.push({
+		severity: "medium",
+		category: "Network Exposure",
+		title: "Gateway exposed via Tailscale Funnel (public internet)",
+		detail: "Your gateway is reachable from the public internet via Tailscale Funnel",
+		remediation: "Ensure auth token is strong and DM policies are restrictive",
+		cvss: 5.8
+	});
+	for (const [ch, chCfg] of Object.entries(cfg.channelConfigs || {})) {
+		const policy = chCfg?.dmPolicy?.policy;
+		if (policy === "open") findings.push({
+			severity: "high",
+			category: "DM Policy",
+			title: `DM policy is "open" on ${ch}`,
+			detail: "Anyone can send DMs to your agent. This is a prompt injection risk.",
+			remediation: `hyperclaw channels add ${ch}  # and choose pairing or allowlist`,
+			cvss: 7.1
+		});
+		if (policy === "allowlist") {
+			const allowFrom = chCfg?.dmPolicy?.allowFrom || [];
+			if (allowFrom.length === 0) findings.push({
+				severity: "high",
+				category: "DM Policy",
+				title: `Empty allowlist on ${ch} — DMs are silently dropped`,
+				detail: `allowFrom is [] — no one can reach your agent on ${ch}`,
+				remediation: `hyperclaw pairing approve ${ch} <code>`,
+				cvss: 4
+			});
+		}
+	}
+	return findings;
+}
+async function checkSecretsInPrompts() {
+	const findings = [];
+	const secretPatterns = [
+		{
+			pattern: /sk-[a-zA-Z0-9]{20,}/,
+			name: "OpenAI API key"
+		},
+		{
+			pattern: /tvly-[a-zA-Z0-9]{20,}/,
+			name: "Tavily API key"
+		},
+		{
+			pattern: /xai-[a-zA-Z0-9]{20,}/,
+			name: "xAI API key"
+		},
+		{
+			pattern: /ghp_[a-zA-Z0-9]{36}/,
+			name: "GitHub PAT"
+		},
+		{
+			pattern: /or-[a-zA-Z0-9]{20,}/,
+			name: "OpenRouter API key"
+		},
+		{
+			pattern: /[a-f0-9]{64}/,
+			name: "Potential hex secret"
+		}
+	];
+	const filesToScan = [
+		path.default.join(HC_DIR, "AGENTS.md"),
+		path.default.join(HC_DIR, "MEMORY.md"),
+		path.default.join(HC_DIR, "hyperclaw.json")
+	];
+	for (const f of filesToScan) {
+		if (!await fs_extra.default.pathExists(f)) continue;
+		const content = await fs_extra.default.readFile(f, "utf8");
+		for (const { pattern, name } of secretPatterns) if (pattern.test(content)) findings.push({
+			severity: "critical",
+			category: "Secret Exposure",
+			title: `${name} potentially embedded in ${path.default.basename(f)}`,
+			detail: `Found pattern matching ${name} in plaintext file. Secrets in prompts are a serious risk.`,
+			remediation: `Remove the secret and use: hyperclaw secrets set KEY=value`,
+			cvss: 9.1
+		});
+	}
+	return findings;
+}
+async function deepScan() {
+	const findings = [];
+	const hubState = path.default.join(HC_DIR, "hub-state.json");
+	if (await fs_extra.default.pathExists(hubState)) {
+		const state = await fs_extra.default.readJson(hubState);
+		const dangerous = state.installed?.filter((s) => s.risk === "dangerous") || [];
+		for (const s of dangerous) findings.push({
+			severity: "critical",
+			category: "Installed Skills",
+			title: `Dangerous skill installed: ${s.name}`,
+			detail: s.riskReason || "Skill is flagged as dangerous",
+			remediation: `hyperclaw hub --uninstall ${s.id}`,
+			cvss: 8.5
+		});
+	}
+	let cfg = null;
+	try {
+		cfg = await fs_extra.default.readJson(path.default.join(HC_DIR, "hyperclaw.json"));
+	} catch {}
+	if (cfg?.gateway?.authToken) {
+		const token = cfg.gateway.authToken;
+		const entropy = estimateEntropy(token);
+		if (entropy < 3.5) findings.push({
+			severity: "high",
+			category: "Token Quality",
+			title: "Gateway auth token has low entropy",
+			detail: `Estimated entropy: ${entropy.toFixed(2)} bits/char — token may be guessable`,
+			remediation: "hyperclaw gateway config --regenerate-token",
+			cvss: 6.5
+		});
+	}
+	return findings;
+}
+function estimateEntropy(str) {
+	const freq = /* @__PURE__ */ new Map();
+	for (const ch of str) freq.set(ch, (freq.get(ch) || 0) + 1);
+	let entropy = 0;
+	for (const count of freq.values()) {
+		const p = count / str.length;
+		entropy -= p * Math.log2(p);
+	}
+	return entropy;
+}
+const SEVERITY_ORDER = [
+	"critical",
+	"high",
+	"medium",
+	"low",
+	"info"
+];
+const SEVERITY_COLOR = {
+	critical: chalk.default.bgRed.white.bold,
+	high: chalk.default.red,
+	medium: chalk.default.yellow,
+	low: chalk.default.cyan,
+	info: chalk.default.gray
+};
+async function runSecurityAudit(deep = false) {
+	console.log(chalk.default.bold.cyan("\n  🔐 HYPERCLAW SECURITY AUDIT\n"));
+	const spinner = (0, ora.default)("Running security checks...").start();
+	const allFindings = [
+		...await checkFilePermissions(),
+		...await checkGatewayConfig(),
+		...await checkSecretsInPrompts(),
+		...deep ? await deepScan() : []
+	];
+	spinner.stop();
+	if (deep) console.log(chalk.default.gray("  Mode: DEEP SCAN\n"));
+	else console.log(chalk.default.gray("  Mode: standard (run with --deep for full scan)\n"));
+	if (allFindings.length === 0) {
+		console.log(chalk.default.green("  ✔  No security issues found!\n"));
+		return;
+	}
+	allFindings.sort((a, b) => SEVERITY_ORDER.indexOf(a.severity) - SEVERITY_ORDER.indexOf(b.severity));
+	for (const f of allFindings) {
+		const color = SEVERITY_COLOR[f.severity];
+		const badge = color(` ${f.severity.toUpperCase()} `);
+		const cvss = f.cvss ? chalk.default.gray(` CVSS ${f.cvss}`) : "";
+		console.log(`  ${badge}${cvss}  ${chalk.default.white(f.title)}`);
+		console.log(`     ${chalk.default.gray(`Category: ${f.category}`)}`);
+		console.log(`     ${chalk.default.gray(f.detail)}`);
+		console.log(`     ${chalk.default.cyan("Fix: " + f.remediation)}`);
+		console.log();
+	}
+	const counts = SEVERITY_ORDER.reduce((acc, sev) => {
+		acc[sev] = allFindings.filter((f) => f.severity === sev).length;
+		return acc;
+	}, {});
+	console.log(`  ${chalk.default.bold("Summary:")} ${chalk.default.bgRed.white.bold(` ${counts.critical} CRITICAL `)}  ${chalk.default.red(`${counts.high} high`)}  ${chalk.default.yellow(`${counts.medium} medium`)}  ${chalk.default.cyan(`${counts.low} low`)}\n`);
+	if (!deep) console.log(chalk.default.gray("  Run: hyperclaw security audit --deep   for full credential entropy scan\n"));
+}
+
+//#endregion
+exports.runSecurityAudit = runSecurityAudit;

package/dist/bounty-tools-C6LyzxM-.js

@@ -0,0 +1,211 @@
+const require_chunk = require('./chunk-jS-bbMI5.js');
+const require_env_resolve = require('./env-resolve-szSWl0UF.js');
+const https = require_chunk.__toESM(require("https"));
+
+//#region packages/core/src/agent/bounty-tools.ts
+function fetchJson(url, auth) {
+	return new Promise((resolve, reject) => {
+		const u = new URL(url);
+		const opts = {
+			hostname: u.hostname,
+			port: 443,
+			path: u.pathname + u.search,
+			method: "GET",
+			headers: { "Accept": "application/json" }
+		};
+		if (auth) {
+			const h = opts.headers;
+			if (auth.startsWith("Basic ") || auth.startsWith("Token ") || auth.startsWith("Bearer ")) h["Authorization"] = auth;
+			else h["Authorization"] = `Basic ${Buffer.from(auth).toString("base64")}`;
+		}
+		https.default.get(opts, (res) => {
+			let data = "";
+			res.on("data", (c) => data += c);
+			res.on("end", () => {
+				try {
+					resolve(JSON.parse(data || "{}"));
+				} catch {
+					resolve({});
+				}
+			});
+		}).on("error", reject);
+	});
+}
+function getBountyTools(cfg) {
+	const hackeroneKey = require_env_resolve.resolveServiceApiKey("hackerone", cfg);
+	const bugcrowdKey = require_env_resolve.resolveServiceApiKey("bugcrowd", cfg);
+	const synackKey = require_env_resolve.resolveServiceApiKey("synack", cfg);
+	const tools = [];
+	if (hackeroneKey) tools.push({
+		name: "hackerone_list_programs",
+		description: "List HackerOne programs you have access to. Use for bug bounty research.",
+		input_schema: {
+			type: "object",
+			properties: { limit: {
+				type: "string",
+				description: "Max programs (default 20)"
+			} }
+		},
+		handler: async (input) => {
+			try {
+				const auth = Buffer.from(hackeroneKey.includes(":") ? hackeroneKey : `:${hackeroneKey}`).toString("base64");
+				const body = await fetchJson("https://api.hackerone.com/v1/hackers/programs", `Basic ${auth}`);
+				const progs = body.data || [];
+				const limit = parseInt(input.limit || "20", 10);
+				return progs.slice(0, limit).map((p) => {
+					const attrs = p.attributes;
+					return `- ${attrs?.name || p.id} (${attrs?.state || "?"})`;
+				}).join("\n") || "No programs found.";
+			} catch (e) {
+				return `Error: ${e.message}. Check HackerOne API key (username:token).`;
+			}
+		}
+	});
+	if (bugcrowdKey) tools.push({
+		name: "bugcrowd_list_programs",
+		description: "List Bugcrowd programs. Use for bug bounty research.",
+		input_schema: {
+			type: "object",
+			properties: { limit: {
+				type: "string",
+				description: "Max programs (default 20)"
+			} }
+		},
+		handler: async (input) => {
+			try {
+				const auth = bugcrowdKey.startsWith("Token ") ? bugcrowdKey : `Token ${bugcrowdKey}`;
+				const body = await fetchJson("https://api.bugcrowd.com/programs", auth);
+				const progs = (body && typeof body === "object" && "data" in body ? body.data : body) || [];
+				const arr = Array.isArray(progs) ? progs : [progs];
+				const limit = parseInt(input.limit || "20", 10);
+				return arr.slice(0, limit).map((p) => {
+					const attrs = p.attributes;
+					const name = attrs?.name || p.name || p.id || "?";
+					const links = p.links;
+					const linkUrl = links?.self || p.url || "";
+					return `- ${name} ${linkUrl ? `(${linkUrl})` : ""}`;
+				}).join("\n") || JSON.stringify(body).slice(0, 500);
+			} catch (e) {
+				return `Error: ${e.message}. Check Bugcrowd API token.`;
+			}
+		}
+	});
+	if (synackKey) tools.push({
+		name: "synack_list_targets",
+		description: "List Synack targets you have access to. Use for bug bounty research.",
+		input_schema: {
+			type: "object",
+			properties: {}
+		},
+		handler: async () => {
+			try {
+				const body = await fetchJson("https://api.synack.com/api/targets", `Bearer ${synackKey}`);
+				const targets = body.targets || body || [];
+				const arr = Array.isArray(targets) ? targets : [targets];
+				return arr.slice(0, 20).map((t) => `- ${t.name || t.slug || t.id || "?"}`).join("\n") || "No targets or check Synack API.";
+			} catch (e) {
+				return `Error: ${e.message}. Check Synack API token.`;
+			}
+		}
+	});
+	const apiKeys = cfg?.skills?.apiKeys ?? {};
+	const genericServiceIds = Object.keys(apiKeys).filter((id) => !KNOWN_BOUNTY_SERVICES.includes(id.toLowerCase()));
+	if (genericServiceIds.length > 0) tools.push({
+		name: "call_service_api",
+		description: `Call external API for services with configured keys. Available: ${genericServiceIds.join(", ")}. Use when the user needs to query an API for a service they've added (Stripe, GitHub, custom APIs, etc).`,
+		input_schema: {
+			type: "object",
+			properties: {
+				service_id: {
+					type: "string",
+					description: `Service id from configured keys: ${genericServiceIds.join(", ")}`
+				},
+				url: {
+					type: "string",
+					description: "Full API URL (e.g. https://api.example.com/v1/resource) or path if baseUrl configured"
+				},
+				method: {
+					type: "string",
+					description: "HTTP method",
+					enum: [
+						"GET",
+						"POST",
+						"PUT",
+						"PATCH",
+						"DELETE"
+					]
+				},
+				body: {
+					type: "object",
+					description: "Request body for POST/PUT/PATCH (optional)"
+				}
+			},
+			required: ["service_id", "url"]
+		},
+		handler: async (input) => {
+			const serviceId = String(input.service_id || "").trim().toLowerCase();
+			const url = String(input.url || "");
+			const method = String(input.method || "GET").toUpperCase();
+			const key = require_env_resolve.resolveServiceApiKey(serviceId, cfg);
+			if (!key) return `Error: No API key for service "${serviceId}". Configure via: hyperclaw config set-service-key ${serviceId} <key>`;
+			if (!url || !url.startsWith("http")) return "Error: url must be a full URL (https://...).";
+			try {
+				const body = await genericHttpRequest(url, method, key, input.body);
+				return typeof body === "string" ? body : JSON.stringify(body, null, 2).slice(0, 8e3);
+			} catch (e) {
+				return `Error: ${e.message}`;
+			}
+		}
+	});
+	return tools;
+}
+function genericHttpRequest(url, method, apiKey, body) {
+	return new Promise((resolve, reject) => {
+		const u = new URL(url);
+		const authHeader = apiKey.startsWith("Bearer ") || apiKey.startsWith("Token ") || apiKey.startsWith("Basic ") ? apiKey : `Bearer ${apiKey}`;
+		const bodyStr = body && method !== "GET" ? JSON.stringify(body) : void 0;
+		const opts = {
+			hostname: u.hostname,
+			port: u.port || 443,
+			path: u.pathname + u.search,
+			method,
+			headers: {
+				"Accept": "application/json",
+				"Authorization": authHeader,
+				...bodyStr ? {
+					"Content-Type": "application/json",
+					"Content-Length": Buffer.byteLength(bodyStr)
+				} : {}
+			}
+		};
+		const req = https.default.request(opts, (res) => {
+			let data = "";
+			res.on("data", (c) => {
+				data += c.toString();
+			});
+			res.on("end", () => {
+				try {
+					resolve(JSON.parse(data || "{}"));
+				} catch {
+					resolve(data || "{}");
+				}
+			});
+		});
+		req.on("error", reject);
+		if (bodyStr) req.write(bodyStr);
+		req.end();
+	});
+}
+var KNOWN_BOUNTY_SERVICES;
+var init_bounty_tools = require_chunk.__esm({ "packages/core/src/agent/bounty-tools.ts"() {
+	require_env_resolve.init_env_resolve();
+	KNOWN_BOUNTY_SERVICES = [
+		"hackerone",
+		"bugcrowd",
+		"synack"
+	];
+} });
+
+//#endregion
+init_bounty_tools();
+exports.getBountyTools = getBountyTools;

package/dist/browser-tools-CQBSbIuO.js

@@ -0,0 +1,5 @@
+const require_chunk = require('./chunk-jS-bbMI5.js');
+const require_browser_tools = require('./browser-tools-YQmwRLLM.js');
+
+require_browser_tools.init_browser_tools();
+exports.getBrowserTools = require_browser_tools.getBrowserTools;

package/dist/browser-tools-YQmwRLLM.js

@@ -0,0 +1,179 @@
+const require_chunk = require('./chunk-jS-bbMI5.js');
+
+//#region packages/core/src/agent/browser-tools.ts
+async function getBrowser() {
+	try {
+		const puppeteer = await import("puppeteer").catch(() => null);
+		if (!puppeteer) return null;
+		if (!sharedBrowser || !sharedBrowser.connected) {
+			const execPath = process.env.PUPPETEER_EXECUTABLE_PATH;
+			sharedBrowser = await puppeteer.default.launch({
+				headless: true,
+				executablePath: execPath || void 0,
+				args: [
+					"--no-sandbox",
+					"--disable-setuid-sandbox",
+					"--disable-dev-shm-usage"
+				]
+			});
+			sharedPage = await sharedBrowser.newPage();
+			await sharedPage.setViewport({
+				width: 1280,
+				height: 800
+			});
+			await sharedPage.setUserAgent("Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36");
+		}
+		return {
+			browser: sharedBrowser,
+			page: sharedPage
+		};
+	} catch {
+		return null;
+	}
+}
+function getBrowserTools() {
+	return [{
+		name: "browser_snapshot",
+		description: "Capture a snapshot of the current browser page (DOM, text, links). Use before interacting. Pass url to navigate first.",
+		input_schema: {
+			type: "object",
+			properties: { url: {
+				type: "string",
+				description: "URL to navigate to before snapshot (optional if already on page)"
+			} },
+			required: []
+		},
+		handler: async (input) => {
+			const bw = await getBrowser();
+			if (!bw) return BROWSER_SETUP;
+			const { page } = bw;
+			try {
+				if (input.url) await page.goto(input.url, {
+					waitUntil: "domcontentloaded",
+					timeout: 15e3
+				});
+				const snapshot = await page.evaluate(() => {
+					const text = document.body?.innerText?.slice(0, 12e3) || "";
+					const links = Array.from(document.querySelectorAll("a[href]")).map((a) => ({
+						text: (a.textContent || "").trim().slice(0, 80),
+						href: a.getAttribute("href")
+					})).filter((l) => l.href?.startsWith("http")).slice(0, 50);
+					const title = document.title || "";
+					const url = window.location.href;
+					return JSON.stringify({
+						title,
+						url,
+						text,
+						links
+					});
+				});
+				return snapshot;
+			} catch (e) {
+				return `Browser snapshot error: ${e.message}`;
+			}
+		}
+	}, {
+		name: "browser_action",
+		description: "Perform an action in the browser: click, type, scroll, navigate. Use after browser_snapshot.",
+		input_schema: {
+			type: "object",
+			properties: {
+				action: {
+					type: "string",
+					description: "Action: click, type, scroll, navigate",
+					enum: [
+						"click",
+						"type",
+						"scroll",
+						"navigate"
+					]
+				},
+				selector: {
+					type: "string",
+					description: "CSS selector or link text to match (for click/type)"
+				},
+				value: {
+					type: "string",
+					description: "For type: text to type. For navigate: URL. For scroll: \"up\" or \"down\""
+				}
+			},
+			required: ["action"]
+		},
+		handler: async (input) => {
+			const action = String(input?.action ?? "");
+			const selector = input?.selector;
+			const value = input?.value;
+			const bw = await getBrowser();
+			if (!bw) return BROWSER_SETUP;
+			const { page } = bw;
+			try {
+				switch (action) {
+					case "navigate":
+						if (!value) return "navigate requires value (URL)";
+						await page.goto(value, {
+							waitUntil: "domcontentloaded",
+							timeout: 15e3
+						});
+						return `Navigated to ${value}`;
+					case "click":
+						if (!selector) return "click requires selector";
+						const sel = selector.trim();
+						const isCss = /^[#.\w\[\]="'\s-:>+~]+$/.test(sel) && (sel.includes("#") || sel.includes(".") || sel.includes("[") || /^[a-z][a-z0-9]*$/i.test(sel));
+						if (isCss) {
+							await page.waitForSelector(sel, { timeout: 5e3 });
+							await page.click(sel);
+							return `Clicked ${sel}`;
+						}
+						const safe = sel.replace(/["']/g, "").slice(0, 100);
+						const xpath = `//a[contains(text(),"${safe}")]`;
+						const [el] = await page.$x(xpath);
+						if (el) {
+							await el.click();
+							return `Clicked link "${sel}"`;
+						}
+						const btnXpath = `//button[contains(text(),"${safe}")]`;
+						const [btn] = await page.$x(btnXpath);
+						if (btn) {
+							await btn.click();
+							return `Clicked button "${sel}"`;
+						}
+						throw new Error(`Element not found: ${sel}`);
+					case "type":
+						if (!selector) return "type requires selector";
+						await page.waitForSelector(selector, { timeout: 5e3 });
+						await page.type(selector, value || "");
+						return `Typed "${value || ""}" into ${selector}`;
+					case "scroll":
+						const dir = (value || "down").toLowerCase();
+						await page.evaluate((d) => {
+							window.scrollBy(0, d === "up" ? -400 : 400);
+						}, dir);
+						return `Scrolled ${dir}`;
+					default: return `Unknown action: ${action}`;
+				}
+			} catch (e) {
+				return `Browser action error: ${e.message}`;
+			}
+		}
+	}];
+}
+var BROWSER_SETUP, sharedBrowser, sharedPage;
+var init_browser_tools = require_chunk.__esm({ "packages/core/src/agent/browser-tools.ts"() {
+	BROWSER_SETUP = "Browser control requires Puppeteer. Install: npm i puppeteer. Then enable in config: browser.enabled: true";
+	sharedBrowser = null;
+	sharedPage = null;
+} });
+
+//#endregion
+Object.defineProperty(exports, 'getBrowserTools', {
+  enumerable: true,
+  get: function () {
+    return getBrowserTools;
+  }
+});
+Object.defineProperty(exports, 'init_browser_tools', {
+  enumerable: true,
+  get: function () {
+    return init_browser_tools;
+  }
+});