agentic-browser 0.1.0

package/dist/runtime-C-oYEtN0.mjs

@@ -0,0 +1,1708 @@
+import { spawn } from "node:child_process";
+import fs from "node:fs";
+import net from "node:net";
+import path from "node:path";
+import WebSocket, { WebSocketServer } from "ws";
+import { URL as URL$1, fileURLToPath } from "node:url";
+import crypto from "node:crypto";
+import { z } from "zod";
+
+//#region src/session/chrome-launcher.ts
+const CANDIDATES = [
+	"/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
+	"/usr/bin/google-chrome",
+	"/usr/bin/chromium-browser",
+	"C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe"
+];
+function discoverChrome(explicitPath) {
+	if (explicitPath && fs.existsSync(explicitPath)) return explicitPath;
+	const found = CANDIDATES.find((candidate) => fs.existsSync(candidate));
+	if (!found) throw new Error("No supported Chrome installation found.");
+	return found;
+}
+
+//#endregion
+//#region src/session/extension-loader.ts
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+function loadControlExtension() {
+	const packageRoot = path.resolve(__dirname, "..");
+	return {
+		extensionPath: path.resolve(packageRoot, "extension"),
+		loadedAt: (/* @__PURE__ */ new Date()).toISOString()
+	};
+}
+
+//#endregion
+//#region src/session/browser-controller.ts
+var CdpConnection = class CdpConnection {
+	nextId = 0;
+	constructor(ws) {
+		this.ws = ws;
+	}
+	static async connect(targetWsUrl) {
+		const ws = new WebSocket(targetWsUrl);
+		await new Promise((resolve, reject) => {
+			ws.once("open", () => resolve());
+			ws.once("error", (err) => reject(err));
+		});
+		return new CdpConnection(ws);
+	}
+	async send(method, params, timeoutMs = 15e3) {
+		const id = ++this.nextId;
+		const payload = {
+			id,
+			method,
+			params
+		};
+		return await new Promise((resolve, reject) => {
+			const timeout = setTimeout(() => {
+				this.ws.off("message", onMessage);
+				reject(/* @__PURE__ */ new Error(`CDP call '${method}' timed out after ${timeoutMs}ms`));
+			}, timeoutMs);
+			const onMessage = (raw) => {
+				const message = JSON.parse(raw.toString("utf8"));
+				if (message.id !== id) return;
+				clearTimeout(timeout);
+				this.ws.off("message", onMessage);
+				if (message.error) {
+					reject(new Error(message.error.message));
+					return;
+				}
+				resolve(message.result ?? {});
+			};
+			this.ws.on("message", onMessage);
+			this.ws.send(JSON.stringify(payload));
+		});
+	}
+	waitForEvent(method, timeoutMs = 5e3) {
+		return new Promise((resolve, reject) => {
+			const timeout = setTimeout(() => {
+				this.ws.off("message", onMessage);
+				reject(/* @__PURE__ */ new Error(`Timed out waiting for ${method}`));
+			}, timeoutMs);
+			const onMessage = (raw) => {
+				const message = JSON.parse(raw.toString("utf8"));
+				if (message.method !== method) return;
+				clearTimeout(timeout);
+				this.ws.off("message", onMessage);
+				resolve(message.params ?? {});
+			};
+			this.ws.on("message", onMessage);
+		});
+	}
+	close() {
+		this.ws.close();
+	}
+};
+async function getJson(url) {
+	const response = await fetch(url);
+	if (!response.ok) throw new Error(`HTTP ${response.status}: ${url}`);
+	return await response.json();
+}
+async function waitForDebugger(port) {
+	for (let i = 0; i < 60; i += 1) try {
+		await getJson(`http://127.0.0.1:${port}/json/version`);
+		return;
+	} catch {
+		await new Promise((resolve) => setTimeout(resolve, 250));
+	}
+	throw new Error("Chrome debug endpoint did not become ready in time");
+}
+async function ensurePageWebSocketUrl(cdpUrl) {
+	const page = (await getJson(`${cdpUrl}/json/list`)).find((target) => target.type === "page" && target.webSocketDebuggerUrl);
+	if (!page?.webSocketDebuggerUrl) throw new Error("No debuggable page target available");
+	return page.webSocketDebuggerUrl;
+}
+async function createTarget(cdpUrl, url = "about:blank") {
+	try {
+		return await ensurePageWebSocketUrl(cdpUrl);
+	} catch {}
+	const endpoint = `${cdpUrl}/json/new?${encodeURIComponent(url)}`;
+	for (const method of ["PUT", "GET"]) try {
+		const response = await fetch(endpoint, { method });
+		if (!response.ok) continue;
+		const payload = await response.json();
+		if (payload.webSocketDebuggerUrl) return payload.webSocketDebuggerUrl;
+	} catch {}
+	return await ensurePageWebSocketUrl(cdpUrl);
+}
+async function evaluateExpression(targetWsUrl, expression) {
+	const conn = await CdpConnection.connect(targetWsUrl);
+	try {
+		await conn.send("Page.enable");
+		await conn.send("Runtime.enable");
+		return (await conn.send("Runtime.evaluate", {
+			expression,
+			returnByValue: true,
+			awaitPromise: true
+		})).result.value ?? "";
+	} finally {
+		conn.close();
+	}
+}
+async function getFreePort() {
+	return await new Promise((resolve, reject) => {
+		const server = net.createServer();
+		server.once("error", reject);
+		server.listen(0, "127.0.0.1", () => {
+			const address = server.address();
+			if (!address || typeof address === "string") {
+				server.close();
+				reject(/* @__PURE__ */ new Error("Unable to allocate free port"));
+				return;
+			}
+			const { port } = address;
+			server.close(() => resolve(port));
+		});
+	});
+}
+var ChromeCdpBrowserController = class {
+	connections = /* @__PURE__ */ new Map();
+	constructor(baseDir, connectionFactory = CdpConnection.connect) {
+		this.baseDir = baseDir;
+		this.connectionFactory = connectionFactory;
+	}
+	async getConnection(targetWsUrl) {
+		const cached = this.connections.get(targetWsUrl);
+		if (cached) {
+			cached.lastUsedAt = Date.now();
+			return cached.conn;
+		}
+		const conn = await this.connectionFactory(targetWsUrl);
+		this.connections.set(targetWsUrl, {
+			conn,
+			enabled: {
+				page: false,
+				runtime: false
+			},
+			lastUsedAt: Date.now()
+		});
+		return conn;
+	}
+	dropConnection(targetWsUrl) {
+		const cached = this.connections.get(targetWsUrl);
+		if (!cached) return;
+		try {
+			cached.conn.close();
+		} catch {}
+		this.connections.delete(targetWsUrl);
+	}
+	closeConnection(targetWsUrl) {
+		this.dropConnection(targetWsUrl);
+	}
+	async ensureEnabled(targetWsUrl) {
+		const cached = this.connections.get(targetWsUrl);
+		if (!cached) return;
+		if (!cached.enabled.page) {
+			await cached.conn.send("Page.enable");
+			cached.enabled.page = true;
+		}
+		if (!cached.enabled.runtime) {
+			await cached.conn.send("Runtime.enable");
+			cached.enabled.runtime = true;
+		}
+	}
+	async launch(sessionId, explicitPath) {
+		const executablePath = discoverChrome(explicitPath);
+		const extension = loadControlExtension();
+		const profileDir = path.join(this.baseDir, "profiles", sessionId);
+		fs.mkdirSync(profileDir, { recursive: true });
+		const launchAttempts = [
+			{
+				withExtension: true,
+				headless: false
+			},
+			{
+				withExtension: false,
+				headless: false
+			},
+			{
+				withExtension: false,
+				headless: true
+			}
+		];
+		let lastError;
+		for (const attempt of launchAttempts) {
+			const port = await getFreePort();
+			const args = [
+				`--remote-debugging-port=${port}`,
+				`--user-data-dir=${profileDir}`,
+				"--no-first-run",
+				"--no-default-browser-check"
+			];
+			if (attempt.withExtension) args.push(`--disable-extensions-except=${extension.extensionPath}`, `--load-extension=${extension.extensionPath}`);
+			if (attempt.headless) args.push("--headless=new");
+			args.push("about:blank");
+			const child = spawn(executablePath, args, {
+				detached: true,
+				stdio: "ignore"
+			});
+			child.unref();
+			try {
+				await waitForDebugger(port);
+				const cdpUrl = `http://127.0.0.1:${port}`;
+				const targetWsUrl = await createTarget(cdpUrl, "about:blank");
+				await evaluateExpression(targetWsUrl, "window.location.href");
+				if (!child.pid) throw new Error("Failed to launch Chrome process");
+				return {
+					pid: child.pid,
+					cdpUrl,
+					targetWsUrl
+				};
+			} catch (error) {
+				lastError = error;
+				if (child.pid) try {
+					process.kill(child.pid, "SIGTERM");
+				} catch {}
+			}
+		}
+		throw new Error(lastError?.message ?? "Unable to launch Chrome");
+	}
+	async navigate(targetWsUrl, url) {
+		let conn = await this.getConnection(targetWsUrl);
+		try {
+			await this.ensureEnabled(targetWsUrl);
+			const loadPromise = Promise.race([conn.waitForEvent("Page.loadEventFired", 6e3), conn.waitForEvent("Page.frameStoppedLoading", 6e3)]);
+			await conn.send("Page.navigate", { url });
+			try {
+				await loadPromise;
+			} catch {}
+			return (await conn.send("Runtime.evaluate", {
+				expression: "window.location.href",
+				returnByValue: true
+			})).result.value ?? url;
+		} catch {
+			this.dropConnection(targetWsUrl);
+			conn = await this.getConnection(targetWsUrl);
+			await this.ensureEnabled(targetWsUrl);
+			const loadPromise = Promise.race([conn.waitForEvent("Page.loadEventFired", 6e3), conn.waitForEvent("Page.frameStoppedLoading", 6e3)]);
+			await conn.send("Page.navigate", { url });
+			try {
+				await loadPromise;
+			} catch {}
+			return (await conn.send("Runtime.evaluate", {
+				expression: "window.location.href",
+				returnByValue: true
+			})).result.value ?? url;
+		}
+	}
+	async interact(targetWsUrl, payload) {
+		let conn = await this.getConnection(targetWsUrl);
+		const expression = `(async () => {
+      const payload = ${JSON.stringify(payload)};
+      if (payload.action === 'click') {
+        const el = document.querySelector(payload.selector);
+        if (!el) throw new Error('Selector not found');
+        const rect = el.getBoundingClientRect();
+        if (rect.width === 0 && rect.height === 0) {
+          throw new Error('Element has zero size – it may be hidden or not rendered');
+        }
+        const cx = rect.left + rect.width / 2;
+        const cy = rect.top + rect.height / 2;
+        const topEl = document.elementFromPoint(cx, cy);
+        if (topEl && topEl !== el && !el.contains(topEl) && !topEl.contains(el)) {
+          const tag = topEl.tagName.toLowerCase();
+          const id = topEl.id ? '#' + topEl.id : '';
+          const cls = topEl.className && typeof topEl.className === 'string' ? '.' + topEl.className.split(' ').join('.') : '';
+          throw new Error('Element is covered by another element: ' + tag + id + cls);
+        }
+        el.click();
+        return 'clicked';
+      }
+      if (payload.action === 'type') {
+        const el = document.querySelector(payload.selector);
+        if (!el) throw new Error('Selector not found');
+        el.focus();
+        el.value = payload.text ?? '';
+        el.dispatchEvent(new Event('input', { bubbles: true }));
+        return 'typed';
+      }
+      if (payload.action === 'press') {
+        const target = document.activeElement;
+        if (!target) throw new Error('No active element to press key on');
+        const key = payload.key ?? 'Enter';
+        target.dispatchEvent(new KeyboardEvent('keydown', { key, bubbles: true }));
+        target.dispatchEvent(new KeyboardEvent('keyup', { key, bubbles: true }));
+        return 'pressed';
+      }
+      if (payload.action === 'waitFor') {
+        const timeout = payload.timeoutMs ?? 2000;
+        const started = Date.now();
+        while (Date.now() - started < timeout) {
+          if (document.querySelector(payload.selector)) {
+            return 'found';
+          }
+          await new Promise((resolve) => setTimeout(resolve, 100));
+        }
+        throw new Error('waitFor timeout');
+      }
+      if (payload.action === 'evaluate') {
+        const fn = new Function('return (' + (payload.text ?? '') + ')');
+        let result = fn();
+        if (result && typeof result === 'object' && typeof result.then === 'function') {
+          result = await result;
+        }
+        return typeof result === 'string' ? result : JSON.stringify(result);
+      }
+      throw new Error('Unsupported interact action');
+    })()`;
+		const execute = async (c) => {
+			await this.ensureEnabled(targetWsUrl);
+			const value = (await c.send("Runtime.evaluate", {
+				expression,
+				returnByValue: true,
+				awaitPromise: true
+			})).result.value ?? "";
+			if (payload.action === "click" && value === "clicked") try {
+				await c.waitForEvent("Page.frameStoppedLoading", 500);
+			} catch {}
+			return value;
+		};
+		try {
+			return await execute(conn);
+		} catch {
+			this.dropConnection(targetWsUrl);
+			conn = await this.getConnection(targetWsUrl);
+			return await execute(conn);
+		}
+	}
+	async getContent(targetWsUrl, options) {
+		const o = JSON.stringify(options);
+		let conn = await this.getConnection(targetWsUrl);
+		const expression = `(() => {
+      const options = ${o};
+      if (options.mode === 'title') return document.title ?? '';
+      if (options.mode === 'html') {
+        if (options.selector) {
+          const el = document.querySelector(options.selector);
+          return el ? el.outerHTML : '';
+        }
+        return document.documentElement?.outerHTML ?? '';
+      }
+      if (options.selector) {
+        const el = document.querySelector(options.selector);
+        return el ? el.innerText ?? '' : '';
+      }
+      return document.body?.innerText ?? '';
+    })()`;
+		try {
+			await this.ensureEnabled(targetWsUrl);
+			const content = (await conn.send("Runtime.evaluate", {
+				expression,
+				returnByValue: true
+			})).result.value ?? "";
+			return {
+				mode: options.mode,
+				content
+			};
+		} catch {
+			this.dropConnection(targetWsUrl);
+			conn = await this.getConnection(targetWsUrl);
+			await this.ensureEnabled(targetWsUrl);
+			const content = (await conn.send("Runtime.evaluate", {
+				expression,
+				returnByValue: true
+			})).result.value ?? "";
+			return {
+				mode: options.mode,
+				content
+			};
+		}
+	}
+	async getInteractiveElements(targetWsUrl, options) {
+		const o = JSON.stringify(options);
+		let conn = await this.getConnection(targetWsUrl);
+		const expression = `(() => {
+      const options = ${o};
+      const visibleOnly = options.visibleOnly !== false;
+      const limit = options.limit ?? 50;
+      const scopeSelector = options.selector;
+      const roleFilter = options.roles ? new Set(options.roles) : null;
+
+      const root = scopeSelector
+        ? document.querySelector(scopeSelector) ?? document.body
+        : document.body;
+
+      const candidates = root.querySelectorAll([
+        'a[href]',
+        'button',
+        'input:not([type="hidden"])',
+        'select',
+        'textarea',
+        '[role="button"]',
+        '[role="link"]',
+        '[role="checkbox"]',
+        '[role="radio"]',
+        '[role="menuitem"]',
+        '[role="tab"]',
+        '[role="switch"]',
+        '[onclick]',
+        '[tabindex]',
+        '[contenteditable="true"]',
+        '[contenteditable=""]',
+      ].join(','));
+
+      const seen = new Set();
+
+      function classifyRole(el) {
+        const tag = el.tagName.toLowerCase();
+        const ariaRole = el.getAttribute('role');
+        if (tag === 'a') return 'link';
+        if (tag === 'button' || ariaRole === 'button') return 'button';
+        if (tag === 'input') {
+          const t = (el.type || 'text').toLowerCase();
+          if (t === 'checkbox') return 'checkbox';
+          if (t === 'radio') return 'radio';
+          return 'input';
+        }
+        if (tag === 'select') return 'select';
+        if (tag === 'textarea') return 'textarea';
+        if (el.isContentEditable) return 'contenteditable';
+        if (ariaRole === 'link') return 'link';
+        if (ariaRole === 'checkbox' || ariaRole === 'switch') return 'checkbox';
+        if (ariaRole === 'radio') return 'radio';
+        return 'custom';
+      }
+
+      function getActions(role, el) {
+        switch (role) {
+          case 'link': case 'button': case 'custom': return ['click'];
+          case 'input': {
+            const t = (el.type || 'text').toLowerCase();
+            if (t === 'submit' || t === 'reset' || t === 'button' || t === 'file') return ['click'];
+            return ['click', 'type', 'press'];
+          }
+          case 'textarea': case 'contenteditable': return ['click', 'type', 'press'];
+          case 'select': return ['click', 'select'];
+          case 'checkbox': case 'radio': return ['click', 'toggle'];
+          default: return ['click'];
+        }
+      }
+
+      function escapeAttr(value) {
+        return value.replace(/\\\\/g, '\\\\\\\\').replace(/"/g, '\\\\"');
+      }
+
+      function buildSelector(el) {
+        if (el.id) return '#' + CSS.escape(el.id);
+
+        const name = el.getAttribute('name');
+        if (name) {
+          const tag = el.tagName.toLowerCase();
+          const sel = tag + '[name="' + escapeAttr(name) + '"]';
+          if (document.querySelectorAll(sel).length === 1) return sel;
+        }
+
+        const testId = el.getAttribute('data-testid') || el.getAttribute('data-test-id');
+        if (testId) {
+          const attr = el.hasAttribute('data-testid') ? 'data-testid' : 'data-test-id';
+          const sel = '[' + attr + '="' + escapeAttr(testId) + '"]';
+          if (document.querySelectorAll(sel).length === 1) return sel;
+        }
+
+        const ariaLabel = el.getAttribute('aria-label');
+        if (ariaLabel) {
+          const tag = el.tagName.toLowerCase();
+          const sel = tag + '[aria-label="' + escapeAttr(ariaLabel) + '"]';
+          if (document.querySelectorAll(sel).length === 1) return sel;
+        }
+
+        const parts = [];
+        let current = el;
+        while (current && current !== document.documentElement) {
+          const tag = current.tagName.toLowerCase();
+          const parent = current.parentElement;
+          if (!parent) { parts.unshift(tag); break; }
+          const siblings = Array.from(parent.children).filter(
+            c => c.tagName === current.tagName
+          );
+          if (siblings.length === 1) {
+            parts.unshift(tag);
+          } else {
+            const idx = siblings.indexOf(current) + 1;
+            parts.unshift(tag + ':nth-of-type(' + idx + ')');
+          }
+          current = parent;
+        }
+        return parts.join(' > ');
+      }
+
+      function isVisible(el) {
+        const style = window.getComputedStyle(el);
+        if (style.display === 'none' || style.visibility === 'hidden' || style.opacity === '0') {
+          return false;
+        }
+        const rect = el.getBoundingClientRect();
+        return rect.width > 0 && rect.height > 0;
+      }
+
+      function getText(el) {
+        const ariaLabel = el.getAttribute('aria-label');
+        if (ariaLabel) return ariaLabel.slice(0, 80);
+
+        const tag = el.tagName.toLowerCase();
+        if (tag === 'input') {
+          const v = el.value;
+          if (v) return v.slice(0, 80);
+          const ph = el.getAttribute('placeholder');
+          if (ph) return ph.slice(0, 80);
+          return el.type || 'text';
+        }
+
+        const directText = Array.from(el.childNodes)
+          .filter(n => n.nodeType === 3)
+          .map(n => n.textContent.trim())
+          .filter(Boolean)
+          .join(' ');
+        if (directText) return directText.slice(0, 80);
+
+        const innerText = (el.innerText || el.textContent || '').trim();
+        if (innerText) return innerText.slice(0, 80);
+
+        const title = el.getAttribute('title');
+        if (title) return title.slice(0, 80);
+        const placeholder = el.getAttribute('placeholder');
+        if (placeholder) return placeholder.slice(0, 80);
+        const alt = el.getAttribute('alt');
+        if (alt) return alt.slice(0, 80);
+        return '';
+      }
+
+      function isEnabled(el) {
+        if ('disabled' in el && el.disabled) return false;
+        const ariaDisabled = el.getAttribute('aria-disabled');
+        return ariaDisabled !== 'true';
+      }
+
+      const results = [];
+      let totalFound = 0;
+
+      for (const el of candidates) {
+        if (seen.has(el)) continue;
+        seen.add(el);
+
+        const role = classifyRole(el);
+        if (roleFilter && !roleFilter.has(role)) continue;
+
+        const vis = isVisible(el);
+        if (visibleOnly && !vis) continue;
+
+        totalFound++;
+        if (results.length >= limit) continue;
+
+        const entry = {
+          selector: buildSelector(el),
+          role,
+          tagName: el.tagName.toLowerCase(),
+          text: getText(el),
+          actions: getActions(role, el),
+          visible: vis,
+          enabled: isEnabled(el),
+        };
+
+        if (role === 'link' && el.href) entry.href = el.href;
+        if (role === 'input') entry.inputType = (el.type || 'text').toLowerCase();
+        const al = el.getAttribute('aria-label');
+        if (al) entry.ariaLabel = al;
+        const ph = el.getAttribute('placeholder');
+        if (ph) entry.placeholder = ph;
+
+        results.push(entry);
+      }
+
+      return { elements: results, totalFound, truncated: totalFound > results.length };
+    })()`;
+		const emptyResult = {
+			elements: [],
+			totalFound: 0,
+			truncated: false
+		};
+		const extract = (raw) => {
+			const v = raw.result.value;
+			if (v && typeof v === "object" && Array.isArray(v.elements)) return v;
+			return emptyResult;
+		};
+		try {
+			await this.ensureEnabled(targetWsUrl);
+			return extract(await conn.send("Runtime.evaluate", {
+				expression,
+				returnByValue: true
+			}));
+		} catch {
+			this.dropConnection(targetWsUrl);
+			conn = await this.getConnection(targetWsUrl);
+			await this.ensureEnabled(targetWsUrl);
+			return extract(await conn.send("Runtime.evaluate", {
+				expression,
+				returnByValue: true
+			}));
+		}
+	}
+	terminate(pid) {
+		try {
+			process.kill(pid, "SIGTERM");
+		} catch {}
+	}
+};
+var MockBrowserController = class {
+	pages = /* @__PURE__ */ new Map();
+	async launch(sessionId) {
+		const cdpUrl = `mock://${sessionId}`;
+		const targetWsUrl = cdpUrl;
+		this.pages.set(cdpUrl, {
+			url: "about:blank",
+			title: "about:blank",
+			text: "",
+			html: "<html><body></body></html>"
+		});
+		return {
+			pid: 1,
+			cdpUrl,
+			targetWsUrl
+		};
+	}
+	async navigate(cdpUrl, url) {
+		const page = this.pages.get(cdpUrl);
+		if (!page) throw new Error("mock page missing");
+		page.url = url;
+		page.title = url;
+		page.text = `Content of ${url}`;
+		page.html = `<html><body>${page.text}</body></html>`;
+		return url;
+	}
+	async interact(_cdpUrl, payload) {
+		return `interacted:${payload.action}`;
+	}
+	async getContent(cdpUrl, options) {
+		const page = this.pages.get(cdpUrl);
+		if (!page) throw new Error("mock page missing");
+		if (options.mode === "title") return {
+			mode: "title",
+			content: page.title
+		};
+		if (options.mode === "html") return {
+			mode: "html",
+			content: page.html
+		};
+		return {
+			mode: "text",
+			content: page.text
+		};
+	}
+	async getInteractiveElements(_targetWsUrl, _options) {
+		return {
+			elements: [],
+			totalFound: 0,
+			truncated: false
+		};
+	}
+	terminate(_pid) {}
+	closeConnection(_targetWsUrl) {}
+};
+
+//#endregion
+//#region src/session/session-store.ts
+var SessionStore = class {
+	filePath;
+	constructor(baseDir) {
+		fs.mkdirSync(baseDir, { recursive: true });
+		this.filePath = path.join(baseDir, "sessions.json");
+		if (!fs.existsSync(this.filePath)) this.write({ sessions: {} });
+	}
+	getActive() {
+		const state = this.read();
+		if (!state.activeSessionId) return;
+		return state.sessions[state.activeSessionId];
+	}
+	get(sessionId) {
+		return this.read().sessions[sessionId];
+	}
+	list() {
+		return Object.values(this.read().sessions);
+	}
+	save(record) {
+		const state = this.read();
+		state.sessions[record.session.sessionId] = record;
+		if (record.session.status !== "terminated") state.activeSessionId = record.session.sessionId;
+		this.write(state);
+	}
+	setSession(session) {
+		const state = this.read();
+		const existing = state.sessions[session.sessionId];
+		if (!existing) throw new Error("Session not found in store");
+		state.sessions[session.sessionId] = {
+			...existing,
+			session
+		};
+		if (session.status === "terminated" && state.activeSessionId === session.sessionId) delete state.activeSessionId;
+		this.write(state);
+	}
+	clearActive(sessionId) {
+		const state = this.read();
+		if (state.activeSessionId === sessionId) {
+			delete state.activeSessionId;
+			this.write(state);
+		}
+	}
+	setLastUrl(sessionId, lastUrl) {
+		const state = this.read();
+		const existing = state.sessions[sessionId];
+		if (!existing) throw new Error("Session not found in store");
+		state.sessions[sessionId] = {
+			...existing,
+			lastUrl
+		};
+		this.write(state);
+	}
+	replaceSessions(sessions, activeSessionId) {
+		const state = {
+			sessions: Object.fromEntries(sessions.map((record) => [record.session.sessionId, record])),
+			activeSessionId
+		};
+		this.write(state);
+	}
+	read() {
+		return JSON.parse(fs.readFileSync(this.filePath, "utf8"));
+	}
+	write(state) {
+		fs.writeFileSync(this.filePath, JSON.stringify(state, null, 2), "utf8");
+	}
+};
+
+//#endregion
+//#region src/session/session-manager.ts
+var SessionManager = class {
+	store;
+	constructor(ctx, browser) {
+		this.ctx = ctx;
+		this.browser = browser;
+		this.store = new SessionStore(this.ctx.config.logDir);
+	}
+	async createSession(input) {
+		if (input.browser !== "chrome") throw new Error("Only chrome is supported");
+		const active = this.store.getActive();
+		if (active && active.session.status !== "terminated") throw new Error("A managed session is already active");
+		const sessionId = crypto.randomUUID();
+		const token = this.ctx.tokenService.issue(sessionId);
+		const launched = await this.browser.launch(sessionId, this.ctx.config.browserExecutablePath);
+		const session = {
+			sessionId,
+			status: "ready",
+			browserType: "chrome",
+			startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+			authTokenRef: token
+		};
+		this.store.save({
+			session,
+			cdpUrl: launched.cdpUrl,
+			targetWsUrl: launched.targetWsUrl,
+			pid: launched.pid
+		});
+		this.recordEvent(sessionId, "lifecycle", "info", "Session started and ready");
+		return session;
+	}
+	getSession(sessionId) {
+		return this.mustGetRecord(sessionId).session;
+	}
+	async executeCommand(sessionId, input) {
+		const record = this.mustGetRecord(sessionId);
+		if (record.session.status !== "ready") throw new Error("Session is not ready. Restart session and retry.");
+		const command = {
+			commandId: input.commandId,
+			sessionId,
+			type: input.type,
+			payload: input.payload,
+			submittedAt: (/* @__PURE__ */ new Date()).toISOString()
+		};
+		let resultMessage = "";
+		let resultStatus = "success";
+		const memoryContext = this.buildMemoryContext(record, input);
+		const topInsight = this.ctx.memoryService.search({
+			taskIntent: memoryContext.taskIntent,
+			siteDomain: memoryContext.siteDomain,
+			limit: 1
+		}).at(0);
+		if (topInsight) this.recordEvent(sessionId, "command", "info", `Memory candidate ${topInsight.insightId} score=${topInsight.score.toFixed(3)} freshness=${topInsight.freshness}`);
+		try {
+			if (input.type === "navigate") {
+				const url = String(input.payload.url ?? "");
+				if (!url) throw new Error("navigate command requires payload.url");
+				const finalUrl = await this.browser.navigate(record.targetWsUrl, url);
+				this.store.setLastUrl(sessionId, finalUrl);
+				resultMessage = `Navigated to ${finalUrl}`;
+			} else if (input.type === "interact") resultMessage = `Interaction result: ${await this.browser.interact(record.targetWsUrl, input.payload)}`;
+			else if (input.type === "restart") {
+				await this.restartSession(sessionId);
+				resultMessage = "Session restarted";
+			} else if (input.type === "terminate") {
+				await this.terminateSession(sessionId);
+				resultMessage = "Session terminated";
+			}
+		} catch (error) {
+			resultStatus = "failed";
+			resultMessage = error.message;
+		}
+		const completed = {
+			...command,
+			completedAt: (/* @__PURE__ */ new Date()).toISOString(),
+			resultStatus,
+			resultMessage
+		};
+		this.recordEvent(sessionId, "command", resultStatus === "success" ? "info" : "warning", `Command ${input.type} -> ${resultStatus}`);
+		if (resultStatus === "success") this.ctx.memoryService.recordSuccess({
+			commandId: input.commandId,
+			taskIntent: memoryContext.taskIntent,
+			siteDomain: memoryContext.siteDomain,
+			sitePathPattern: memoryContext.sitePathPattern,
+			expectedOutcome: resultMessage,
+			step: memoryContext.step,
+			selector: memoryContext.selector,
+			url: memoryContext.url
+		});
+		else this.ctx.memoryService.recordFailure({
+			commandId: input.commandId,
+			taskIntent: memoryContext.taskIntent,
+			siteDomain: memoryContext.siteDomain,
+			sitePathPattern: memoryContext.sitePathPattern,
+			expectedOutcome: memoryContext.expectedOutcome,
+			step: memoryContext.step,
+			selector: memoryContext.selector,
+			url: memoryContext.url
+		}, resultMessage);
+		return completed;
+	}
+	async getContent(sessionId, options) {
+		const record = this.mustGetRecord(sessionId);
+		if (record.session.status !== "ready") throw new Error("Session is not ready");
+		return await this.browser.getContent(record.targetWsUrl, options);
+	}
+	async getInteractiveElements(sessionId, options) {
+		const record = this.mustGetRecord(sessionId);
+		if (record.session.status !== "ready") throw new Error("Session is not ready");
+		return await this.browser.getInteractiveElements(record.targetWsUrl, options);
+	}
+	setStatus(status, reason) {
+		const active = this.store.getActive();
+		if (!active) throw new Error("No active session");
+		const session = {
+			...active.session,
+			status,
+			endedAt: status === "terminated" ? (/* @__PURE__ */ new Date()).toISOString() : active.session.endedAt
+		};
+		this.store.setSession(session);
+		this.recordEvent(session.sessionId, "lifecycle", status === "failed" ? "error" : "warning", reason);
+		return session;
+	}
+	async terminateSession(sessionId) {
+		const record = this.mustGetRecord(sessionId);
+		if (record.session.status !== "terminated") {
+			if (this.browser.closeConnection) try {
+				this.browser.closeConnection(record.targetWsUrl);
+			} catch {}
+			this.browser.terminate(record.pid);
+			this.ctx.tokenService.revoke(sessionId);
+			const terminated = {
+				...record.session,
+				status: "terminated",
+				endedAt: (/* @__PURE__ */ new Date()).toISOString()
+			};
+			this.store.setSession(terminated);
+			this.store.clearActive(sessionId);
+			this.recordEvent(sessionId, "lifecycle", "info", "Session terminated");
+			return terminated;
+		}
+		return record.session;
+	}
+	async restartSession(sessionId) {
+		const record = this.mustGetRecord(sessionId);
+		if (record.session.status === "ready") return record.session;
+		if (this.browser.closeConnection) try {
+			this.browser.closeConnection(record.targetWsUrl);
+		} catch {}
+		const relaunched = await this.browser.launch(sessionId, this.ctx.config.browserExecutablePath);
+		const restarted = {
+			...record.session,
+			status: "ready",
+			endedAt: void 0
+		};
+		this.store.save({
+			session: restarted,
+			cdpUrl: relaunched.cdpUrl,
+			targetWsUrl: relaunched.targetWsUrl,
+			pid: relaunched.pid
+		});
+		this.recordEvent(sessionId, "lifecycle", "info", "Session restarted");
+		return restarted;
+	}
+	getAuthToken(sessionId) {
+		return this.mustGetRecord(sessionId).session.authTokenRef;
+	}
+	rotateAuthToken(sessionId) {
+		const record = this.mustGetRecord(sessionId);
+		this.ctx.tokenService.revoke(sessionId);
+		const nextToken = this.ctx.tokenService.issue(sessionId);
+		const updated = {
+			...record.session,
+			authTokenRef: nextToken
+		};
+		this.store.setSession(updated);
+		this.recordEvent(sessionId, "security", "info", "Session token rotated");
+		return nextToken;
+	}
+	listEvents(sessionId, limit = 100) {
+		return this.ctx.eventStore.list(sessionId, limit);
+	}
+	searchMemory(input) {
+		return this.ctx.memoryService.search(input);
+	}
+	inspectMemory(insightId) {
+		return this.ctx.memoryService.inspect(insightId);
+	}
+	verifyMemory(insightId) {
+		return this.ctx.memoryService.verify(insightId);
+	}
+	memoryStats() {
+		return this.ctx.memoryService.stats();
+	}
+	cleanupSessions(input) {
+		const maxAgeDays = input.maxAgeDays ?? 7;
+		if (!Number.isFinite(maxAgeDays) || maxAgeDays < 0) throw new Error("maxAgeDays must be a non-negative number");
+		const dryRun = input.dryRun ?? false;
+		const cutoffMs = Date.now() - maxAgeDays * 24 * 60 * 60 * 1e3;
+		const active = this.store.getActive();
+		const all = this.store.list();
+		const removedSessionIds = [];
+		const keep = [];
+		for (const record of all) {
+			if (active?.session.sessionId === record.session.sessionId) {
+				keep.push(record);
+				continue;
+			}
+			if (record.session.status !== "terminated") {
+				keep.push(record);
+				continue;
+			}
+			const endedAt = record.session.endedAt ? Date.parse(record.session.endedAt) : NaN;
+			if (Number.isNaN(endedAt) || endedAt > cutoffMs) {
+				keep.push(record);
+				continue;
+			}
+			removedSessionIds.push(record.session.sessionId);
+		}
+		const keepIds = new Set(keep.map((record) => record.session.sessionId));
+		const profilesDir = path.join(this.ctx.config.logDir, "profiles");
+		const removedProfileDirs = [];
+		if (fs.existsSync(profilesDir)) for (const entry of fs.readdirSync(profilesDir)) {
+			const fullPath = path.join(profilesDir, entry);
+			if (!fs.statSync(fullPath).isDirectory()) continue;
+			if (keepIds.has(entry)) continue;
+			removedProfileDirs.push(fullPath);
+		}
+		if (!dryRun) {
+			this.store.replaceSessions(keep, active?.session.sessionId);
+			for (const profilePath of removedProfileDirs) fs.rmSync(profilePath, {
+				recursive: true,
+				force: true
+			});
+		}
+		return {
+			removedSessionIds,
+			removedProfileDirs,
+			keptActiveSessionId: active?.session.sessionId,
+			dryRun
+		};
+	}
+	mustGetRecord(sessionId) {
+		const record = this.store.get(sessionId);
+		if (!record) throw new Error("Session not found");
+		if (!record.targetWsUrl) throw new Error("Session target is missing. Restart the session.");
+		const seeded = this.ctx.tokenService.get(sessionId);
+		if (!seeded || seeded !== record.session.authTokenRef) this.ctx.tokenService.seed(sessionId, record.session.authTokenRef);
+		return record;
+	}
+	recordEvent(sessionId, category, severity, message) {
+		this.ctx.eventStore.append({
+			eventId: crypto.randomUUID(),
+			sessionId,
+			category,
+			severity,
+			message,
+			createdAt: (/* @__PURE__ */ new Date()).toISOString()
+		});
+	}
+	buildMemoryContext(record, input) {
+		const selector = typeof input.payload.selector === "string" ? input.payload.selector : void 0;
+		const inputUrl = typeof input.payload.url === "string" ? input.payload.url : record.lastUrl;
+		const parsed = this.parseUrl(inputUrl);
+		const action = typeof input.payload.action === "string" ? input.payload.action : void 0;
+		const defaultIntent = input.type === "navigate" ? `navigate:${parsed.domain}` : input.type === "interact" ? `interact:${action ?? "action"}:${parsed.domain}` : `${input.type}:${parsed.domain}`;
+		const taskIntent = typeof input.payload.intent === "string" && input.payload.intent.trim() ? input.payload.intent : defaultIntent;
+		const expectedOutcome = typeof input.payload.expectedOutcome === "string" && input.payload.expectedOutcome.trim() ? input.payload.expectedOutcome : `${input.type} command succeeds`;
+		return {
+			taskIntent,
+			siteDomain: parsed.domain,
+			sitePathPattern: parsed.pathPattern,
+			expectedOutcome,
+			step: {
+				type: input.type === "navigate" ? "navigate" : input.type === "interact" ? "interact" : "assert",
+				summary: input.type === "interact" ? `interact:${action ?? "unknown"}` : input.type,
+				selector,
+				payload: input.payload
+			},
+			selector,
+			url: inputUrl
+		};
+	}
+	parseUrl(rawUrl) {
+		if (!rawUrl) return {
+			domain: "unknown",
+			pathPattern: "/"
+		};
+		try {
+			const parsed = new URL$1(rawUrl);
+			const firstSegment = parsed.pathname.split("/").filter(Boolean)[0];
+			const pathPattern = firstSegment ? `/${firstSegment}/*` : "/";
+			return {
+				domain: parsed.hostname.toLowerCase(),
+				pathPattern
+			};
+		} catch {
+			return {
+				domain: "unknown",
+				pathPattern: "/"
+			};
+		}
+	}
+};
+
+//#endregion
+//#region src/transport/control-api.ts
+var ControlApi = class {
+	constructor(sessions, eventStore) {
+		this.sessions = sessions;
+		this.eventStore = eventStore;
+	}
+	async createSession(input) {
+		return await this.sessions.createSession(input);
+	}
+	getSession(sessionId) {
+		return this.sessions.getSession(sessionId);
+	}
+	async terminateSession(sessionId) {
+		await this.sessions.terminateSession(sessionId);
+	}
+	async executeCommand(sessionId, input) {
+		return await this.sessions.executeCommand(sessionId, input);
+	}
+	async restartSession(sessionId) {
+		return await this.sessions.restartSession(sessionId);
+	}
+	rotateSessionToken(sessionId) {
+		return this.sessions.rotateAuthToken(sessionId);
+	}
+	async getContent(sessionId, options) {
+		return await this.sessions.getContent(sessionId, options);
+	}
+	async getInteractiveElements(sessionId, options) {
+		return await this.sessions.getInteractiveElements(sessionId, options);
+	}
+	listEvents(sessionId, limit = 100) {
+		return { events: this.eventStore.list(sessionId, limit) };
+	}
+	searchMemory(input) {
+		return { results: this.sessions.searchMemory(input) };
+	}
+	inspectMemory(insightId) {
+		return this.sessions.inspectMemory(insightId);
+	}
+	verifyMemory(insightId) {
+		return this.sessions.verifyMemory(insightId);
+	}
+	memoryStats() {
+		return this.sessions.memoryStats();
+	}
+	cleanupSessions(input) {
+		return this.sessions.cleanupSessions(input);
+	}
+};
+
+//#endregion
+//#region src/lib/config.ts
+const DEFAULT_PORT = 43111;
+const DEFAULT_TIMEOUT_MS = 2e3;
+function loadConfig(env = process.env) {
+	const wsPort = Number.parseInt(env.AGENTIC_BROWSER_WS_PORT ?? `${DEFAULT_PORT}`, 10);
+	const commandTimeoutMs = Number.parseInt(env.AGENTIC_BROWSER_COMMAND_TIMEOUT_MS ?? `${DEFAULT_TIMEOUT_MS}`, 10);
+	if (Number.isNaN(wsPort) || wsPort <= 0) throw new Error("AGENTIC_BROWSER_WS_PORT must be a positive integer");
+	if (Number.isNaN(commandTimeoutMs) || commandTimeoutMs <= 0) throw new Error("AGENTIC_BROWSER_COMMAND_TIMEOUT_MS must be a positive integer");
+	return {
+		host: env.AGENTIC_BROWSER_HOST ?? "127.0.0.1",
+		wsPort,
+		commandTimeoutMs,
+		logDir: env.AGENTIC_BROWSER_LOG_DIR ?? path.resolve(process.cwd(), ".agentic-browser"),
+		browserExecutablePath: env.AGENTIC_BROWSER_CHROME_PATH
+	};
+}
+
+//#endregion
+//#region src/observability/logger.ts
+var Logger = class {
+	constructor(namespace) {
+		this.namespace = namespace;
+	}
+	emit(level, message, context) {
+		const payload = {
+			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+			level,
+			namespace: this.namespace,
+			message,
+			context: context ?? {}
+		};
+		const line = JSON.stringify(payload);
+		if (level === "error") {
+			process.stderr.write(`${line}\n`);
+			return;
+		}
+		process.stdout.write(`${line}\n`);
+	}
+	info(message, context) {
+		this.emit("info", message, context);
+	}
+	warning(message, context) {
+		this.emit("warning", message, context);
+	}
+	error(message, context) {
+		this.emit("error", message, context);
+	}
+};
+
+//#endregion
+//#region src/observability/event-store.ts
+var EventStore = class {
+	events = /* @__PURE__ */ new Map();
+	filePath;
+	constructor(baseDir) {
+		this.baseDir = baseDir;
+		fs.mkdirSync(baseDir, { recursive: true });
+		this.filePath = path.join(baseDir, "session-events.log");
+	}
+	append(event) {
+		const existing = this.events.get(event.sessionId) ?? [];
+		existing.push(event);
+		this.events.set(event.sessionId, existing);
+		fs.appendFileSync(this.filePath, `${JSON.stringify(event)}\n`, "utf8");
+	}
+	list(sessionId, limit = 100) {
+		const entries = this.events.get(sessionId) ?? [];
+		return entries.slice(Math.max(0, entries.length - limit));
+	}
+};
+
+//#endregion
+//#region src/auth/session-token.ts
+var SessionTokenService = class {
+	bySession = /* @__PURE__ */ new Map();
+	issue(sessionId) {
+		const token = crypto.randomBytes(24).toString("hex");
+		this.bySession.set(sessionId, { token });
+		return token;
+	}
+	validate(sessionId, token) {
+		const record = this.bySession.get(sessionId);
+		if (!record || record.revokedAt) return false;
+		const expected = Buffer.from(record.token);
+		const provided = Buffer.from(token);
+		if (expected.length !== provided.length) return false;
+		return crypto.timingSafeEqual(expected, provided);
+	}
+	revoke(sessionId) {
+		const record = this.bySession.get(sessionId);
+		if (!record) return;
+		record.revokedAt = (/* @__PURE__ */ new Date()).toISOString();
+		this.bySession.set(sessionId, record);
+	}
+	get(sessionId) {
+		return this.bySession.get(sessionId)?.token;
+	}
+	seed(sessionId, token) {
+		this.bySession.set(sessionId, { token });
+	}
+};
+
+//#endregion
+//#region src/transport/ws-server.ts
+var AuthenticatedWsServer = class {
+	logger = new Logger("ws-server");
+	server;
+	constructor(options) {
+		this.options = options;
+	}
+	start(onMessage) {
+		this.server = new WebSocketServer({
+			host: this.options.host,
+			port: this.options.port
+		});
+		this.server.on("connection", (socket, request) => {
+			const url = new URL(request.url ?? "/", `http://${this.options.host}:${this.options.port}`);
+			const sessionId = url.searchParams.get("sessionId");
+			const token = url.searchParams.get("token");
+			if (!sessionId || !token || !this.options.tokenService.validate(sessionId, token)) {
+				this.logger.warning("Rejected websocket client", { sessionId });
+				socket.close(4401, "Unauthorized");
+				return;
+			}
+			socket.on("message", (payload) => onMessage(socket, payload.toString("utf8")));
+		});
+		this.logger.info("WebSocket server started", {
+			host: this.options.host,
+			port: this.options.port
+		});
+	}
+	stop() {
+		this.server?.close();
+		this.server = void 0;
+	}
+};
+
+//#endregion
+//#region src/memory/memory-index.ts
+function normalize(value) {
+	return value.trim().toLowerCase();
+}
+function freshnessWeight(freshness) {
+	if (freshness === "fresh") return 1;
+	if (freshness === "suspect") return .65;
+	return .3;
+}
+function confidenceFromCounts(successCount, failureCount) {
+	const total = successCount + failureCount;
+	if (total === 0) return .5;
+	return successCount / total;
+}
+function buildSelectorHints(insight) {
+	const weightedSelectors = /* @__PURE__ */ new Map();
+	for (const step of insight.actionRecipe) {
+		if (!step.selector) continue;
+		weightedSelectors.set(step.selector, (weightedSelectors.get(step.selector) ?? 0) + 2);
+	}
+	for (const evidence of insight.evidence) {
+		if (!evidence.selector || evidence.result !== "success") continue;
+		weightedSelectors.set(evidence.selector, (weightedSelectors.get(evidence.selector) ?? 0) + 3);
+	}
+	return [...weightedSelectors.entries()].sort((a, b) => b[1] - a[1]).slice(0, 5).map(([selector]) => selector);
+}
+function selectorSignal(insight) {
+	const recipeSelectors = insight.actionRecipe.filter((step) => Boolean(step.selector)).length;
+	const recipeCoverage = insight.actionRecipe.length > 0 ? recipeSelectors / insight.actionRecipe.length : 0;
+	const selectorEvidence = insight.evidence.filter((record) => Boolean(record.selector) && record.result === "success").length;
+	const evidenceStrength = Math.min(selectorEvidence / 5, 1);
+	return .7 * recipeCoverage + .3 * evidenceStrength;
+}
+var MemoryIndex = class {
+	search(insights, input) {
+		const normalizedIntent = normalize(input.taskIntent);
+		const normalizedDomain = input.siteDomain ? normalize(input.siteDomain) : void 0;
+		const limit = input.limit ?? 10;
+		return insights.map((insight) => {
+			const intentMatch = normalize(insight.taskIntent) === normalizedIntent ? 1 : 0;
+			const intentPartial = intentMatch === 1 || normalize(insight.taskIntent).includes(normalizedIntent) || normalizedIntent.includes(normalize(insight.taskIntent)) ? .65 : 0;
+			const domainMatch = normalizedDomain && normalize(insight.siteDomain) === normalizedDomain ? 1 : normalizedDomain ? 0 : .6;
+			const reliability = .6 * confidenceFromCounts(insight.successCount, insight.failureCount) + .4 * freshnessWeight(insight.freshness);
+			const selectorQuality = selectorSignal(insight);
+			const score = .5 * Math.max(intentMatch, intentPartial) + .2 * domainMatch + .15 * reliability + .15 * selectorQuality;
+			return {
+				insightId: insight.insightId,
+				taskIntent: insight.taskIntent,
+				siteDomain: insight.siteDomain,
+				confidence: insight.confidence,
+				freshness: insight.freshness,
+				lastVerifiedAt: insight.lastVerifiedAt,
+				selectorHints: buildSelectorHints(insight),
+				score
+			};
+		}).filter((result) => result.score > 0).sort((a, b) => b.score - a.score).slice(0, limit);
+	}
+};
+
+//#endregion
+//#region src/memory/staleness-detector.ts
+const MAX_SUSPECT_STRIKES = 2;
+function detectStalenessSignal(errorMessage, selector) {
+	const lowered = errorMessage.toLowerCase();
+	return {
+		reason: errorMessage,
+		selector,
+		isStructural: lowered.includes("selector not found") || lowered.includes("waitfor timeout") || lowered.includes("session target is missing") || lowered.includes("element has zero size") || lowered.includes("element is covered by another element")
+	};
+}
+function applyFailure(insight, signal) {
+	const now = (/* @__PURE__ */ new Date()).toISOString();
+	const nextStrike = signal.isStructural ? insight.staleStrikeCount + 1 : insight.staleStrikeCount;
+	let freshness = insight.freshness;
+	if (signal.isStructural && insight.freshness === "fresh") freshness = "suspect";
+	if (signal.isStructural && nextStrike >= MAX_SUSPECT_STRIKES) freshness = "stale";
+	const failureCount = insight.failureCount + 1;
+	const confidence = insight.successCount / Math.max(1, insight.successCount + failureCount);
+	return {
+		...insight,
+		freshness,
+		staleStrikeCount: nextStrike,
+		failureCount,
+		confidence,
+		updatedAt: now
+	};
+}
+function applySuccess(insight) {
+	const now = (/* @__PURE__ */ new Date()).toISOString();
+	const successCount = insight.successCount + 1;
+	const confidence = successCount / Math.max(1, successCount + insight.failureCount);
+	return {
+		...insight,
+		freshness: "fresh",
+		staleStrikeCount: 0,
+		successCount,
+		confidence,
+		lastVerifiedAt: now,
+		updatedAt: now
+	};
+}
+
+//#endregion
+//#region src/memory/memory-schemas.ts
+const InsightFreshnessSchema = z.enum([
+	"fresh",
+	"suspect",
+	"stale"
+]);
+const TaskStepSchema = z.object({
+	type: z.enum([
+		"navigate",
+		"interact",
+		"assert"
+	]),
+	summary: z.string().min(1),
+	selector: z.string().optional(),
+	payload: z.record(z.string(), z.unknown()).default({})
+});
+const EvidenceRecordSchema = z.object({
+	evidenceId: z.string().min(1),
+	commandId: z.string().min(1),
+	result: z.enum(["success", "failure"]),
+	reason: z.string().optional(),
+	selector: z.string().optional(),
+	url: z.string().optional(),
+	recordedAt: z.string().datetime()
+});
+const TaskInsightSchema = z.object({
+	insightId: z.string().min(1),
+	taskIntent: z.string().min(1),
+	siteDomain: z.string().min(1),
+	sitePathPattern: z.string().min(1),
+	actionRecipe: z.array(TaskStepSchema),
+	expectedOutcome: z.string().min(1),
+	confidence: z.number().min(0).max(1),
+	successCount: z.number().int().nonnegative(),
+	failureCount: z.number().int().nonnegative(),
+	useCount: z.number().int().nonnegative(),
+	freshness: InsightFreshnessSchema,
+	staleStrikeCount: z.number().int().nonnegative(),
+	lastVerifiedAt: z.string().datetime(),
+	createdAt: z.string().datetime(),
+	updatedAt: z.string().datetime(),
+	supersedes: z.string().optional(),
+	evidence: z.array(EvidenceRecordSchema)
+});
+const MemoryStateSchema = z.object({ insights: z.array(TaskInsightSchema) });
+
+//#endregion
+//#region src/memory/task-insight-store.ts
+const EMPTY_STATE = { insights: [] };
+var TaskInsightStore = class {
+	filePath;
+	constructor(baseDir) {
+		const memoryDir = path.join(baseDir, "memory");
+		fs.mkdirSync(memoryDir, { recursive: true });
+		this.filePath = path.join(memoryDir, "insights.json");
+		const tmpPath = `${this.filePath}.tmp`;
+		try {
+			if (fs.existsSync(tmpPath)) fs.unlinkSync(tmpPath);
+		} catch {}
+		if (!fs.existsSync(this.filePath)) this.write(EMPTY_STATE);
+	}
+	list() {
+		return this.read().insights;
+	}
+	get(insightId) {
+		return this.read().insights.find((insight) => insight.insightId === insightId);
+	}
+	upsert(insight) {
+		TaskInsightSchema.parse(insight);
+		const state = this.read();
+		const index = state.insights.findIndex((entry) => entry.insightId === insight.insightId);
+		if (index >= 0) state.insights[index] = insight;
+		else state.insights.push(insight);
+		this.write(state);
+	}
+	replaceMany(insights) {
+		for (const insight of insights) TaskInsightSchema.parse(insight);
+		this.write({ insights });
+	}
+	read() {
+		let raw;
+		try {
+			raw = JSON.parse(fs.readFileSync(this.filePath, "utf8"));
+		} catch {
+			this.backupAndReset();
+			return EMPTY_STATE;
+		}
+		try {
+			return MemoryStateSchema.parse(raw);
+		} catch {
+			const obj = raw;
+			if (Array.isArray(obj?.insights)) {
+				const salvaged = obj.insights.filter((item) => TaskInsightSchema.safeParse(item).success);
+				if (salvaged.length > 0) {
+					const state = { insights: salvaged };
+					this.backupAndReset();
+					this.write(state);
+					return state;
+				}
+			}
+			this.backupAndReset();
+			return EMPTY_STATE;
+		}
+	}
+	backupAndReset() {
+		const corruptPath = `${this.filePath}.corrupt-${Date.now()}`;
+		try {
+			fs.copyFileSync(this.filePath, corruptPath);
+		} catch {}
+	}
+	write(state) {
+		const tempPath = `${this.filePath}.tmp`;
+		fs.writeFileSync(tempPath, JSON.stringify(state, null, 2), "utf8");
+		fs.renameSync(tempPath, this.filePath);
+	}
+};
+
+//#endregion
+//#region src/memory/memory-service.ts
+var MemoryService = class {
+	store;
+	index;
+	constructor(baseDir) {
+		this.store = new TaskInsightStore(baseDir);
+		this.index = new MemoryIndex();
+	}
+	search(input) {
+		return this.index.search(this.store.list(), input);
+	}
+	inspect(insightId) {
+		const insight = this.store.get(insightId);
+		if (!insight) throw new Error("Insight not found");
+		return insight;
+	}
+	stats() {
+		const insights = this.store.list();
+		const byDomain = /* @__PURE__ */ new Map();
+		for (const insight of insights) byDomain.set(insight.siteDomain, (byDomain.get(insight.siteDomain) ?? 0) + 1);
+		return {
+			total: insights.length,
+			fresh: insights.filter((x) => x.freshness === "fresh").length,
+			suspect: insights.filter((x) => x.freshness === "suspect").length,
+			stale: insights.filter((x) => x.freshness === "stale").length,
+			topDomains: [...byDomain.entries()].sort((a, b) => b[1] - a[1]).slice(0, 10).map(([domain, count]) => ({
+				domain,
+				count
+			}))
+		};
+	}
+	verify(insightId) {
+		const insight = this.inspect(insightId);
+		const now = (/* @__PURE__ */ new Date()).toISOString();
+		const verified = {
+			...insight,
+			lastVerifiedAt: now,
+			updatedAt: now
+		};
+		this.store.upsert(verified);
+		return verified;
+	}
+	recordSuccess(input) {
+		const insights = this.store.list();
+		const matched = this.findBestExactMatch(insights, input.taskIntent, input.siteDomain);
+		const evidence = this.createEvidence(input, "success");
+		if (!matched) {
+			const now = (/* @__PURE__ */ new Date()).toISOString();
+			const created = {
+				insightId: crypto.randomUUID(),
+				taskIntent: input.taskIntent,
+				siteDomain: input.siteDomain,
+				sitePathPattern: input.sitePathPattern,
+				actionRecipe: [input.step],
+				expectedOutcome: input.expectedOutcome,
+				confidence: 1,
+				successCount: 1,
+				failureCount: 0,
+				useCount: 1,
+				freshness: "fresh",
+				staleStrikeCount: 0,
+				lastVerifiedAt: now,
+				createdAt: now,
+				updatedAt: now,
+				evidence: [evidence]
+			};
+			this.store.upsert(created);
+			return created;
+		}
+		const refreshed = applySuccess({
+			...matched,
+			useCount: matched.useCount + 1,
+			evidence: [...matched.evidence.slice(-49), evidence],
+			actionRecipe: this.mergeRecipe(matched.actionRecipe, input.step),
+			expectedOutcome: input.expectedOutcome
+		});
+		if (matched.freshness === "suspect" || matched.freshness === "stale") {
+			const now = (/* @__PURE__ */ new Date()).toISOString();
+			const versioned = {
+				...refreshed,
+				insightId: crypto.randomUUID(),
+				supersedes: matched.insightId,
+				staleStrikeCount: 0,
+				createdAt: now,
+				updatedAt: now
+			};
+			this.store.upsert(versioned);
+			return versioned;
+		}
+		this.store.upsert(refreshed);
+		return refreshed;
+	}
+	recordFailure(input, errorMessage) {
+		const insights = this.store.list();
+		const matched = this.findBestExactMatch(insights, input.taskIntent, input.siteDomain);
+		if (!matched) return;
+		const signal = detectStalenessSignal(errorMessage, input.selector);
+		const evidence = this.createEvidence(input, "failure", errorMessage);
+		const failed = applyFailure({
+			...matched,
+			useCount: matched.useCount + 1,
+			evidence: [...matched.evidence.slice(-49), evidence]
+		}, signal);
+		this.store.upsert(failed);
+		return failed;
+	}
+	findBestExactMatch(insights, taskIntent, siteDomain) {
+		return insights.filter((insight) => insight.taskIntent.toLowerCase() === taskIntent.toLowerCase() && insight.siteDomain.toLowerCase() === siteDomain.toLowerCase()).sort((a, b) => b.updatedAt.localeCompare(a.updatedAt))[0];
+	}
+	createEvidence(input, result, reason) {
+		return {
+			evidenceId: crypto.randomUUID(),
+			commandId: input.commandId,
+			result,
+			reason,
+			selector: input.selector,
+			url: input.url,
+			recordedAt: (/* @__PURE__ */ new Date()).toISOString()
+		};
+	}
+	mergeRecipe(recipe, step) {
+		if (recipe.find((existing) => existing.summary === step.summary && existing.selector === step.selector)) return recipe;
+		return [...recipe, step].slice(-8);
+	}
+};
+
+//#endregion
+//#region src/cli/app.ts
+function createAppContext(env = process.env) {
+	const config = loadConfig(env);
+	const logger = new Logger("app");
+	const eventStore = new EventStore(config.logDir);
+	const tokenService = new SessionTokenService();
+	return {
+		config,
+		logger,
+		eventStore,
+		tokenService,
+		wsServer: new AuthenticatedWsServer({
+			host: config.host,
+			port: config.wsPort,
+			tokenService
+		}),
+		memoryService: new MemoryService(config.logDir)
+	};
+}
+
+//#endregion
+//#region src/cli/runtime.ts
+var AgenticBrowserCore = class {
+	context;
+	sessions;
+	api;
+	constructor(context, browserController) {
+		this.context = context;
+		this.sessions = new SessionManager(context, browserController);
+		this.api = new ControlApi(this.sessions, context.eventStore);
+	}
+	async startSession(input = { browser: "chrome" }) {
+		return await this.api.createSession(input);
+	}
+	getSession(sessionId) {
+		return this.api.getSession(sessionId);
+	}
+	async runCommand(input) {
+		return await this.api.executeCommand(input.sessionId, {
+			commandId: input.commandId,
+			type: input.type,
+			payload: input.payload
+		});
+	}
+	async getPageContent(input) {
+		return await this.api.getContent(input.sessionId, {
+			mode: input.mode,
+			selector: input.selector
+		});
+	}
+	async getInteractiveElements(input) {
+		return await this.api.getInteractiveElements(input.sessionId, {
+			roles: input.roles,
+			visibleOnly: input.visibleOnly,
+			limit: input.limit,
+			selector: input.selector
+		});
+	}
+	async restartSession(sessionId) {
+		return await this.api.restartSession(sessionId);
+	}
+	async stopSession(sessionId) {
+		await this.api.terminateSession(sessionId);
+	}
+	rotateSessionToken(sessionId) {
+		return this.api.rotateSessionToken(sessionId);
+	}
+	searchMemory(input) {
+		return this.api.searchMemory(input);
+	}
+	inspectMemory(insightId) {
+		return this.api.inspectMemory(insightId);
+	}
+	verifyMemory(insightId) {
+		return this.api.verifyMemory(insightId);
+	}
+	memoryStats() {
+		return this.api.memoryStats();
+	}
+};
+function createAgenticBrowserCore(options = {}) {
+	const context = createAppContext(options.env);
+	return new AgenticBrowserCore(context, options.browserController ?? new ChromeCdpBrowserController(context.config.logDir));
+}
+function createMockAgenticBrowserCore(env) {
+	return new AgenticBrowserCore(createAppContext(env), new MockBrowserController());
+}
+function createCliRuntime() {
+	return createAgenticBrowserCore();
+}
+
+//#endregion
+export { createMockAgenticBrowserCore as i, createAgenticBrowserCore as n, createCliRuntime as r, AgenticBrowserCore as t };