agentic-browser 0.1.0

package/dist/cli/index.mjs

@@ -0,0 +1,374 @@
+import { r as createCliRuntime } from "../runtime-C-oYEtN0.mjs";
+import fs from "node:fs";
+import path from "node:path";
+import crypto from "node:crypto";
+import { Command } from "commander";
+
+//#region src/cli/commands/agent.ts
+const STATE_FILE_NAME = "agent-state.json";
+function stateFilePath(runtime) {
+	return path.join(runtime.context.config.logDir, STATE_FILE_NAME);
+}
+function loadState(runtime) {
+	const filePath = stateFilePath(runtime);
+	if (!fs.existsSync(filePath)) return { sessionId: null };
+	try {
+		return JSON.parse(fs.readFileSync(filePath, "utf8"));
+	} catch {
+		return { sessionId: null };
+	}
+}
+function saveState(runtime, state) {
+	const dir = path.dirname(stateFilePath(runtime));
+	fs.mkdirSync(dir, { recursive: true });
+	fs.writeFileSync(stateFilePath(runtime), JSON.stringify(state, null, 2));
+}
+function requireSessionId(runtime) {
+	const state = loadState(runtime);
+	if (!state.sessionId) throw new Error("No active agent session. Run: agentic-browser agent start");
+	return state.sessionId;
+}
+function nextCommandId() {
+	return `cmd-${Date.now()}-${crypto.randomBytes(3).toString("hex")}`;
+}
+async function ensureReady(runtime, sessionId) {
+	if (runtime.api.getSession(sessionId).status === "ready") return;
+	const restarted = await runtime.api.restartSession(sessionId);
+	if (restarted.status !== "ready") throw new Error(`Session not ready after restart: ${restarted.status}`);
+}
+async function agentStart(runtime) {
+	const session = await runtime.api.createSession({ browser: "chrome" });
+	saveState(runtime, { sessionId: session.sessionId });
+	return {
+		ok: true,
+		action: "start",
+		sessionId: session.sessionId
+	};
+}
+async function agentStatus(runtime) {
+	const sessionId = requireSessionId(runtime);
+	return {
+		ok: true,
+		action: "status",
+		...runtime.api.getSession(sessionId)
+	};
+}
+async function agentStop(runtime) {
+	const sessionId = requireSessionId(runtime);
+	await runtime.api.terminateSession(sessionId);
+	saveState(runtime, { sessionId: null });
+	return {
+		ok: true,
+		action: "stop",
+		sessionId
+	};
+}
+async function agentRun(runtime, input) {
+	const sessionId = requireSessionId(runtime);
+	await ensureReady(runtime, sessionId);
+	const attempt = () => runtime.api.executeCommand(sessionId, {
+		commandId: nextCommandId(),
+		type: input.type,
+		payload: input.payload
+	});
+	try {
+		const first = await attempt();
+		if (first.resultStatus === "failed") throw new Error(first.resultMessage ?? "Command failed");
+		return {
+			ok: true,
+			action: "run",
+			...first
+		};
+	} catch {
+		await runtime.api.restartSession(sessionId);
+		const second = await attempt();
+		if (second.resultStatus === "failed") throw new Error(second.resultMessage ?? "Command failed after retry");
+		return {
+			ok: true,
+			action: "run",
+			...second
+		};
+	}
+}
+async function agentContent(runtime, input) {
+	const sessionId = requireSessionId(runtime);
+	await ensureReady(runtime, sessionId);
+	return {
+		ok: true,
+		action: "content",
+		...await runtime.api.getContent(sessionId, {
+			mode: input.mode,
+			selector: input.selector
+		})
+	};
+}
+async function agentElements(runtime, input) {
+	const sessionId = requireSessionId(runtime);
+	await ensureReady(runtime, sessionId);
+	return {
+		ok: true,
+		action: "elements",
+		...await runtime.api.getInteractiveElements(sessionId, {
+			roles: input.roles,
+			visibleOnly: input.visibleOnly,
+			limit: input.limit,
+			selector: input.selector
+		})
+	};
+}
+async function agentMemorySearch(runtime, input) {
+	return {
+		ok: true,
+		action: "memory-search",
+		...runtime.api.searchMemory(input)
+	};
+}
+async function agentCleanup(runtime, input) {
+	return {
+		ok: true,
+		action: "cleanup",
+		...runtime.api.cleanupSessions(input)
+	};
+}
+
+//#endregion
+//#region src/cli/output/result-formatter.ts
+function formatResult(resultStatus, message) {
+	return {
+		resultStatus,
+		message
+	};
+}
+
+//#endregion
+//#region src/cli/commands/session-start.ts
+async function runSessionStart(runtime, input) {
+	const session = await runtime.api.createSession(input);
+	return {
+		...formatResult("success", "Session started"),
+		sessionId: session.sessionId
+	};
+}
+
+//#endregion
+//#region src/cli/commands/session-status.ts
+async function runSessionStatus(runtime, input) {
+	return runtime.api.getSession(input.sessionId);
+}
+
+//#endregion
+//#region src/cli/commands/session-stop.ts
+async function runSessionStop(runtime, input) {
+	await runtime.api.terminateSession(input.sessionId);
+	return { terminated: true };
+}
+
+//#endregion
+//#region src/cli/commands/session-cleanup.ts
+async function runSessionCleanup(runtime, input) {
+	return runtime.api.cleanupSessions(input);
+}
+
+//#endregion
+//#region src/cli/commands/session-restart.ts
+async function runSessionRestart(runtime, input) {
+	return await runtime.api.restartSession(input.sessionId);
+}
+
+//#endregion
+//#region src/cli/commands/session-auth.ts
+async function runSessionAuth(runtime, input) {
+	const token = runtime.api.rotateSessionToken(input.sessionId);
+	return {
+		token,
+		valid: runtime.context.tokenService.validate(input.sessionId, token)
+	};
+}
+
+//#endregion
+//#region src/cli/commands/command-run.ts
+async function runCommand(runtime, input) {
+	if (!input.sessionId) throw new Error("No active session. Start or restart a session first.");
+	try {
+		return await runtime.api.executeCommand(input.sessionId, {
+			commandId: input.commandId,
+			type: input.type,
+			payload: input.payload
+		});
+	} catch (error) {
+		throw new Error(`Command rejected: ${error.message}`);
+	}
+}
+
+//#endregion
+//#region src/cli/commands/page-content.ts
+async function runPageContent(runtime, input) {
+	return await runtime.api.getContent(input.sessionId, {
+		mode: input.mode,
+		selector: input.selector
+	});
+}
+
+//#endregion
+//#region src/cli/commands/memory-search.ts
+async function runMemorySearch(runtime, input) {
+	if (!input.taskIntent || !input.taskIntent.trim()) throw new Error("taskIntent is required");
+	return runtime.api.searchMemory(input);
+}
+
+//#endregion
+//#region src/cli/commands/memory-inspect.ts
+async function runMemoryInspect(runtime, input) {
+	if (!input.insightId || !input.insightId.trim()) throw new Error("insightId is required");
+	return runtime.api.inspectMemory(input.insightId);
+}
+
+//#endregion
+//#region src/cli/commands/memory-verify.ts
+async function runMemoryVerify(runtime, input) {
+	if (!input.insightId || !input.insightId.trim()) throw new Error("insightId is required");
+	return runtime.api.verifyMemory(input.insightId);
+}
+
+//#endregion
+//#region src/cli/commands/memory-stats.ts
+async function runMemoryStats(runtime) {
+	return runtime.api.memoryStats();
+}
+
+//#endregion
+//#region src/cli/index.ts
+async function main() {
+	const runtime = createCliRuntime();
+	const program = new Command();
+	program.name("agentic-browser").description("Agentic browser CLI");
+	program.command("session:start").action(async () => {
+		const result = await runSessionStart(runtime, { browser: "chrome" });
+		console.log(JSON.stringify(result));
+	});
+	program.command("session:status").argument("<sessionId>").action(async (sessionId) => {
+		const result = await runSessionStatus(runtime, { sessionId });
+		console.log(JSON.stringify(result));
+	});
+	program.command("session:stop").argument("<sessionId>").action(async (sessionId) => {
+		const result = await runSessionStop(runtime, { sessionId });
+		console.log(JSON.stringify(result));
+	});
+	program.command("session:cleanup").option("--max-age-days <days>", "remove terminated sessions older than N days", "7").option("--dry-run", "show what would be removed without deleting").action(async (options) => {
+		const result = await runSessionCleanup(runtime, {
+			maxAgeDays: Number.parseFloat(options.maxAgeDays),
+			dryRun: Boolean(options.dryRun)
+		});
+		console.log(JSON.stringify(result));
+	});
+	program.command("session:restart").argument("<sessionId>").action(async (sessionId) => {
+		const result = await runSessionRestart(runtime, { sessionId });
+		console.log(JSON.stringify(result));
+	});
+	program.command("session:auth").argument("<sessionId>").action(async (sessionId) => {
+		const result = await runSessionAuth(runtime, { sessionId });
+		console.log(JSON.stringify(result));
+	});
+	program.command("command:run").argument("<sessionId>").argument("<commandId>").argument("<type>").argument("<payloadJson>").action(async (sessionId, commandId, type, payloadJson) => {
+		const result = await runCommand(runtime, {
+			sessionId,
+			commandId,
+			type,
+			payload: JSON.parse(payloadJson)
+		});
+		console.log(JSON.stringify(result));
+	});
+	program.command("page:content").argument("<sessionId>").option("--mode <mode>", "title|text|html", "text").option("--selector <selector>", "optional CSS selector").action(async (sessionId, options) => {
+		const result = await runPageContent(runtime, {
+			sessionId,
+			mode: options.mode,
+			selector: options.selector
+		});
+		console.log(JSON.stringify(result));
+	});
+	program.command("memory:search").argument("<taskIntent>").option("--domain <domain>", "website domain filter").option("--limit <limit>", "max results", "10").action(async (taskIntent, options) => {
+		const result = await runMemorySearch(runtime, {
+			taskIntent,
+			siteDomain: options.domain,
+			limit: Number.parseInt(options.limit, 10)
+		});
+		console.log(JSON.stringify(result));
+	});
+	program.command("memory:inspect").argument("<insightId>").action(async (insightId) => {
+		const result = await runMemoryInspect(runtime, { insightId });
+		console.log(JSON.stringify(result));
+	});
+	program.command("memory:verify").argument("<insightId>").action(async (insightId) => {
+		const result = await runMemoryVerify(runtime, { insightId });
+		console.log(JSON.stringify(result));
+	});
+	program.command("memory:stats").action(async () => {
+		const result = await runMemoryStats(runtime);
+		console.log(JSON.stringify(result));
+	});
+	const agent = program.command("agent").description("Stateful agent wrapper with session persistence and auto-retry");
+	agent.command("start").action(async () => {
+		const result = await agentStart(runtime);
+		console.log(JSON.stringify(result));
+	});
+	agent.command("status").action(async () => {
+		const result = await agentStatus(runtime);
+		console.log(JSON.stringify(result));
+	});
+	agent.command("stop").action(async () => {
+		const result = await agentStop(runtime);
+		console.log(JSON.stringify(result));
+	});
+	agent.command("run").argument("<type>", "navigate|interact|restart|terminate").argument("<payloadJson>", "JSON payload").action(async (type, payloadJson) => {
+		const result = await agentRun(runtime, {
+			type,
+			payload: JSON.parse(payloadJson)
+		});
+		console.log(JSON.stringify(result));
+	});
+	agent.command("content").option("--mode <mode>", "title|text|html", "text").option("--selector <selector>", "optional CSS selector").action(async (options) => {
+		const result = await agentContent(runtime, options);
+		console.log(JSON.stringify(result));
+	});
+	agent.command("elements").description("List interactive elements on the current page").option("--roles <roles>", "comma-separated roles filter", (v) => v.split(",")).option("--visible-only", "only visible elements", true).option("--no-visible-only", "include hidden elements").option("--limit <n>", "max elements", "50").option("--selector <selector>", "scope to CSS selector subtree").action(async (options) => {
+		const result = await agentElements(runtime, {
+			roles: options.roles,
+			visibleOnly: options.visibleOnly,
+			limit: Number.parseInt(options.limit, 10),
+			selector: options.selector
+		});
+		console.log(JSON.stringify(result));
+	});
+	agent.command("memory-search").argument("<taskIntent>").option("--domain <domain>", "website domain filter").option("--limit <limit>", "max results", "5").action(async (taskIntent, options) => {
+		const result = await agentMemorySearch(runtime, {
+			taskIntent,
+			siteDomain: options.domain,
+			limit: Number.parseInt(options.limit, 10)
+		});
+		console.log(JSON.stringify(result));
+	});
+	agent.command("cleanup").option("--max-age-days <days>", "remove sessions older than N days", "7").option("--dry-run", "show what would be removed").action(async (options) => {
+		const result = await agentCleanup(runtime, {
+			maxAgeDays: Number.parseFloat(options.maxAgeDays),
+			dryRun: Boolean(options.dryRun)
+		});
+		console.log(JSON.stringify(result));
+	});
+	program.command("mcp").description("Start the MCP server (stdio transport)").action(async () => {
+		const { main: startMcpServer } = await import("../mcp/index.mjs");
+		await startMcpServer();
+	});
+	program.command("setup").description("Configure agentic-browser as MCP server for your AI tool").action(async () => {
+		const { runSetup } = await import("../setup-CULSgM_M.mjs");
+		await runSetup();
+	});
+	await program.parseAsync(process.argv);
+}
+main().catch((error) => {
+	const message = error instanceof Error ? error.message : String(error);
+	console.error(JSON.stringify({ error: message }));
+	process.exit(1);
+});
+
+//#endregion
+export {  };

package/dist/index.mjs

@@ -0,0 +1,3 @@
+import { i as createMockAgenticBrowserCore, n as createAgenticBrowserCore, t as AgenticBrowserCore } from "./runtime-C-oYEtN0.mjs";
+
+export { AgenticBrowserCore, createAgenticBrowserCore, createMockAgenticBrowserCore };

package/dist/mcp/index.mjs

@@ -0,0 +1,170 @@
+import { n as createAgenticBrowserCore } from "../runtime-C-oYEtN0.mjs";
+import { z } from "zod";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+//#region src/mcp/index.ts
+let core;
+let activeSessionId;
+function getCore() {
+	if (!core) core = createAgenticBrowserCore();
+	return core;
+}
+function genId(prefix) {
+	return `${prefix}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+}
+const server = new McpServer({
+	name: "agentic-browser",
+	version: "0.1.0"
+});
+server.tool("browser_start_session", "Start a Chrome browser session for web automation. Call this first before using any other browser tool. Returns a sessionId you'll need for all subsequent calls.", {}, async () => {
+	const session = await getCore().startSession();
+	activeSessionId = session.sessionId;
+	return { content: [{
+		type: "text",
+		text: JSON.stringify(session)
+	}] };
+});
+server.tool("browser_navigate", "Navigate the browser to a URL. The browser must have an active session.", {
+	url: z.string().describe("The URL to navigate to"),
+	sessionId: z.string().optional().describe("Session ID (uses active session if omitted)")
+}, async ({ url, sessionId }) => {
+	const sid = sessionId ?? activeSessionId;
+	if (!sid) throw new Error("No active session. Call browser_start_session first.");
+	const result = await getCore().runCommand({
+		sessionId: sid,
+		commandId: genId("nav"),
+		type: "navigate",
+		payload: { url }
+	});
+	return { content: [{
+		type: "text",
+		text: JSON.stringify(result)
+	}] };
+});
+server.tool("browser_interact", "Interact with a page element. Actions: \"click\" (click element), \"type\" (type text into input), \"press\" (press a keyboard key like Enter), \"waitFor\" (wait for element to appear).", {
+	action: z.enum([
+		"click",
+		"type",
+		"press",
+		"waitFor"
+	]).describe("The interaction type"),
+	selector: z.string().optional().describe("CSS selector for the target element"),
+	text: z.string().optional().describe("Text to type (required for \"type\" action)"),
+	key: z.string().optional().describe("Key to press (required for \"press\" action, e.g. \"Enter\", \"Tab\")"),
+	timeoutMs: z.number().optional().describe("Timeout in milliseconds (for \"waitFor\" action, default 4000)"),
+	sessionId: z.string().optional().describe("Session ID (uses active session if omitted)")
+}, async ({ action, selector, text, key, timeoutMs, sessionId }) => {
+	const sid = sessionId ?? activeSessionId;
+	if (!sid) throw new Error("No active session. Call browser_start_session first.");
+	const payload = { action };
+	if (selector) payload.selector = selector;
+	if (text) payload.text = text;
+	if (key) payload.key = key;
+	if (timeoutMs) payload.timeoutMs = timeoutMs;
+	const result = await getCore().runCommand({
+		sessionId: sid,
+		commandId: genId("int"),
+		type: "interact",
+		payload
+	});
+	return { content: [{
+		type: "text",
+		text: JSON.stringify(result)
+	}] };
+});
+server.tool("browser_get_content", "Get the current page content. Modes: \"title\" (page title only), \"text\" (readable text content), \"html\" (raw HTML). Use selector to scope to a specific element.", {
+	mode: z.enum([
+		"title",
+		"text",
+		"html"
+	]).default("text").describe("Content extraction mode"),
+	selector: z.string().optional().describe("CSS selector to scope content (e.g. \"main\", \"#content\")"),
+	sessionId: z.string().optional().describe("Session ID (uses active session if omitted)")
+}, async ({ mode, selector, sessionId }) => {
+	const sid = sessionId ?? activeSessionId;
+	if (!sid) throw new Error("No active session. Call browser_start_session first.");
+	const result = await getCore().getPageContent({
+		sessionId: sid,
+		mode,
+		selector
+	});
+	return { content: [{
+		type: "text",
+		text: JSON.stringify(result)
+	}] };
+});
+server.tool("browser_get_elements", "Discover all interactive elements on the current page (buttons, links, inputs, etc.). Returns CSS selectors you can use with browser_interact. Call this to understand what's on the page before interacting.", {
+	roles: z.array(z.enum([
+		"link",
+		"button",
+		"input",
+		"select",
+		"textarea",
+		"checkbox",
+		"radio",
+		"contenteditable",
+		"custom"
+	])).optional().describe("Filter by element roles (omit for all)"),
+	visibleOnly: z.boolean().default(true).describe("Only return visible elements"),
+	limit: z.number().default(50).describe("Maximum number of elements to return"),
+	selector: z.string().optional().describe("CSS selector to scope element discovery to a subtree"),
+	sessionId: z.string().optional().describe("Session ID (uses active session if omitted)")
+}, async ({ roles, visibleOnly, limit, selector, sessionId }) => {
+	const sid = sessionId ?? activeSessionId;
+	if (!sid) throw new Error("No active session. Call browser_start_session first.");
+	const result = await getCore().getInteractiveElements({
+		sessionId: sid,
+		roles,
+		visibleOnly,
+		limit,
+		selector
+	});
+	return { content: [{
+		type: "text",
+		text: JSON.stringify(result)
+	}] };
+});
+server.tool("browser_search_memory", "Search task memory for previously learned selectors and interaction patterns. Use this before interacting with a known site to reuse proven selectors instead of rediscovering them.", {
+	taskIntent: z.string().describe("What you want to do, e.g. \"login:github.com\" or \"search:amazon.de\""),
+	siteDomain: z.string().optional().describe("Domain to scope the search"),
+	limit: z.number().default(5).describe("Maximum number of results")
+}, async ({ taskIntent, siteDomain, limit }) => {
+	const result = getCore().searchMemory({
+		taskIntent,
+		siteDomain,
+		limit
+	});
+	return { content: [{
+		type: "text",
+		text: JSON.stringify(result)
+	}] };
+});
+server.tool("browser_stop_session", "Stop the browser session and terminate Chrome. Call this when you're done with browser automation.", { sessionId: z.string().optional().describe("Session ID (uses active session if omitted)") }, async ({ sessionId }) => {
+	const sid = sessionId ?? activeSessionId;
+	if (!sid) throw new Error("No active session.");
+	await getCore().stopSession(sid);
+	if (activeSessionId === sid) activeSessionId = void 0;
+	return { content: [{
+		type: "text",
+		text: JSON.stringify({
+			ok: true,
+			stopped: sid
+		})
+	}] };
+});
+async function main() {
+	const transport = new StdioServerTransport();
+	transport.onclose = async () => {
+		if (activeSessionId) {
+			try {
+				await getCore().stopSession(activeSessionId);
+			} catch {}
+			activeSessionId = void 0;
+		}
+	};
+	await server.connect(transport);
+}
+
+//#endregion
+export { main };