@xopcai/xopc 0.0.415 → 0.0.417

package/dist/src/browser/setup/service.d.ts

@@ -0,0 +1,157 @@
+import { type BrowserActionInput, type BrowserControlResult } from '@xopcai/browser-control-contract';
+import type { BrowserSetupView } from '@xopcai/gateway-contract';
+import type { Config } from '../../config/schema.js';
+import type { EndpointToolRuntime } from '../../endpoint-tools/index.js';
+import type { BrowserSetup } from './types.js';
+export declare const browserConfigRevision: (config: Config) => string;
+export interface BrowserSetupDeps {
+    getConfig: () => Config;
+    verificationOrigin?: () => string;
+    saveConfig: (next: Config, expected: Config) => Promise<{
+        saved: boolean;
+        error?: string;
+    }>;
+    endpoints: EndpointToolRuntime;
+    canUseBrowser: (agentId: string) => boolean;
+    canSwitchDriver?: (conversationId: string) => boolean;
+    policyRevision?: (agentId: string) => string;
+    prepare: () => Promise<unknown>;
+    release: (endpointId: string, sessionId: string) => Promise<BrowserControlResult>;
+    open: (action: 'chrome' | 'folder' | 'both') => Promise<unknown>;
+    doctor: () => Promise<{
+        installed: boolean;
+        needsRefresh?: boolean;
+        extensionDir?: string;
+        nativeHost?: {
+            installed: boolean;
+        };
+    }>;
+}
+/** Setup writes use host-authorized interactive turns or existing owner grants. */
+export declare class BrowserSetupService {
+    private readonly deps;
+    private readonly preparing;
+    constructor(deps: BrowserSetupDeps);
+    private policyRevision;
+    endpoints(): {
+        endpointId: string;
+        principalId: string;
+        displayName: string;
+        appVersion: string;
+    }[];
+    owned(id: string, conversationId: string, agentId: string): BrowserSetup;
+    view(setup: BrowserSetup): BrowserSetupView & Record<string, unknown>;
+    inspect(conversationId: string, agentId: string): Promise<{
+        sceneId: string;
+        supportedConnection: string;
+        configRevision: string;
+        installation: {
+            installed: boolean;
+            needsRefresh: boolean;
+            nativeHostInstalled: boolean;
+            extensionDir: string;
+        };
+        toolPermission: string;
+        enabled: boolean;
+        driverKind: "extension" | "playwright" | "cdp" | "remote";
+        sharedScope: string;
+        endpoints: {
+            endpointId: string;
+            principalId: string;
+            displayName: string;
+            appVersion: string;
+        }[];
+        setup: BrowserSetupView & Record<string, unknown>;
+        guidanceRefs: {
+            section?: string;
+            sceneId: string;
+            path: string;
+            resourceVersion: string;
+        }[];
+        interaction: string;
+        supportedActions: string[];
+    }>;
+    command(command: string, args: Record<string, unknown>, context: {
+        conversationId: string;
+        agentId: string;
+        canConfigure?: boolean;
+    }, dryRun?: boolean): Promise<(BrowserSetupView & Record<string, unknown>) | {
+        sceneId: string;
+        supportedConnection: string;
+        configRevision: string;
+        installation: {
+            installed: boolean;
+            needsRefresh: boolean;
+            nativeHostInstalled: boolean;
+            extensionDir: string;
+        };
+        toolPermission: string;
+        enabled: boolean;
+        driverKind: "extension" | "playwright" | "cdp" | "remote";
+        sharedScope: string;
+        endpoints: {
+            endpointId: string;
+            principalId: string;
+            displayName: string;
+            appVersion: string;
+        }[];
+        setup: BrowserSetupView & Record<string, unknown>;
+        guidanceRefs: {
+            section?: string;
+            sceneId: string;
+            path: string;
+            resourceVersion: string;
+        }[];
+        interaction: string;
+        supportedActions: string[];
+    } | {
+        message: string;
+        sceneId: string;
+        supportedConnection: string;
+        configRevision: string;
+        installation: {
+            installed: boolean;
+            needsRefresh: boolean;
+            nativeHostInstalled: boolean;
+            extensionDir: string;
+        };
+        toolPermission: string;
+        enabled: boolean;
+        driverKind: "extension" | "playwright" | "cdp" | "remote";
+        sharedScope: string;
+        endpoints: {
+            endpointId: string;
+            principalId: string;
+            displayName: string;
+            appVersion: string;
+        }[];
+        setup: BrowserSetupView & Record<string, unknown>;
+        guidanceRefs: {
+            section?: string;
+            sceneId: string;
+            path: string;
+            resourceVersion: string;
+        }[];
+        interaction: string;
+        supportedActions: string[];
+        dryRun: boolean;
+    }>;
+    approve(setup: BrowserSetup, principalId: string, revision: number): BrowserSetup;
+    private revision;
+    prepare(setup: BrowserSetup): Promise<BrowserSetup>;
+    recheck(setup: BrowserSetup): Promise<BrowserSetup>;
+    open(setup: BrowserSetup, action: 'chrome' | 'folder' | 'both'): Promise<unknown>;
+    begin(setup: BrowserSetup, endpointId: string, origin: string, revision: number): BrowserSetup;
+    cancel(setup: BrowserSetup): BrowserSetup;
+    release(setup: BrowserSetup): Promise<BrowserSetup>;
+    canRestoreSession(taskKey: string, sessionId: string): boolean;
+    allowsVerificationUrl(taskKey: string, url: string): boolean;
+    /** Called only by the real Agent browser tool, before its normal runtime/policy path. */
+    beforeAction(conversationId: string, agentId: string, input: BrowserActionInput): {
+        setupId: string;
+        attemptId: string;
+        taskKey: string;
+        input: BrowserActionInput;
+    };
+    afterAction(setupId: string, attemptId: string, input: BrowserActionInput, result: BrowserControlResult): BrowserSetup;
+}

package/dist/src/browser/setup/service.js

@@ -0,0 +1,433 @@
+import { createLogger } from "../../utils/logger/index.js";
+import { init_logger } from "../../utils/logger.js";
+import { getBrowserTabBinding } from "../../storage/sqlite/browser-tab-binding-repository.js";
+import "../../../packages/browser-control-contract/src/index.js";
+import { createBrowserSetup, findBrowserSetup, readBrowserSetup, saveBrowserSetup } from "./repository.js";
+import { createHash, randomUUID } from "node:crypto";
+//#region src/browser/setup/service.ts
+init_logger();
+const log = createLogger("BrowserSetup");
+const VERSION = "1";
+const MAX_ACTIONS = 12;
+const VERIFY_MS = 12e4;
+const ref = (name, section) => ({
+	sceneId: "browser",
+	path: `references/browser/${name}.md`,
+	resourceVersion: VERSION,
+	...section ? { section } : {}
+});
+const browserConfigRevision = (config) => createHash("sha256").update(JSON.stringify(config.browser)).digest("hex");
+/** Setup writes use host-authorized interactive turns or existing owner grants. */
+var BrowserSetupService = class {
+	preparing = /* @__PURE__ */ new Set();
+	constructor(deps) {
+		this.deps = deps;
+	}
+	policyRevision(agentId) {
+		return this.deps.policyRevision?.(agentId) ?? String(this.deps.canUseBrowser(agentId));
+	}
+	endpoints() {
+		return this.deps.endpoints.registry.list().filter((e) => e.kind === "browser" && e.tools.some((t) => t.descriptor.name === "browser.control")).map((e) => ({
+			endpointId: e.endpointId,
+			principalId: e.principalId,
+			displayName: e.displayName,
+			appVersion: e.appVersion
+		}));
+	}
+	owned(id, conversationId, agentId) {
+		const setup = readBrowserSetup(id);
+		if (!setup || setup.conversationId !== conversationId || setup.agentId !== agentId) throw new Error("SETUP_NOT_FOUND");
+		return setup;
+	}
+	view(setup) {
+		if (setup.state === "verifying" && setup.attempt && Date.now() > setup.attempt.expiresAt) setup = {
+			...setup,
+			state: "needs_attention",
+			error: "VERIFICATION_EXPIRED: Release the demo session before starting a new test."
+		};
+		const attempt = setup.attempt ? (({ observation: _observation, ...summary }) => summary)(setup.attempt) : void 0;
+		const endpoint = setup.attempt ? this.endpoints().find((e) => e.endpointId === setup.attempt.endpointId) : void 0;
+		const changed = setup.configRevision !== browserConfigRevision(this.deps.getConfig()) || Boolean(setup.attempt && (setup.attempt.policyRevision !== this.policyRevision(setup.agentId) || !this.deps.canUseBrowser(setup.agentId) || endpoint && (endpoint.principalId !== setup.attempt.principalId || endpoint.appVersion !== setup.attempt.appVersion)));
+		return {
+			...setup,
+			attempt: setup.attempt ? attempt : void 0,
+			sceneId: "browser",
+			skillName: "configure-xopc",
+			resourceVersion: VERSION,
+			stale: changed,
+			toolPermission: this.deps.canUseBrowser(setup.agentId) ? "allowed" : "denied",
+			currentDriverKind: this.deps.getConfig().browser.driver.kind,
+			endpoints: this.endpoints(),
+			settingsPath: `/settings/agent-browser?browserSetup=${setup.id}&conversationId=${setup.conversationId}`,
+			checks: {
+				configured: this.deps.getConfig().browser.enabled && this.deps.getConfig().browser.driver.kind === "extension",
+				read: setup.attempt?.read ?? false,
+				clicked: setup.attempt?.clicked ?? false,
+				filled: setup.attempt?.filled ?? false,
+				released: setup.attempt?.released ?? false
+			},
+			guidanceRefs: [ref(setup.state === "verifying" || setup.state === "completed" ? "acceptance" : setup.error ? "troubleshooting" : "chrome-extension")],
+			allowedActions: setup.state === "cancelled" ? ["get", "release"] : setup.state === "completed" ? ["get", "verification_report"] : [
+				"get",
+				"recheck",
+				"cancel",
+				"release",
+				...!changed && setup.state !== "verifying" ? ["prepare", "advance"] : [],
+				...setup.approvedBy ? ["open"] : [],
+				...setup.state === "ready_for_verification" && !changed ? ["begin_verification"] : []
+			]
+		};
+	}
+	async inspect(conversationId, agentId) {
+		const config = this.deps.getConfig();
+		const existing = findBrowserSetup(conversationId, agentId);
+		const installation = await this.deps.doctor();
+		return {
+			sceneId: "browser",
+			supportedConnection: "extension",
+			configRevision: browserConfigRevision(config),
+			installation: {
+				installed: installation.installed,
+				needsRefresh: installation.needsRefresh ?? false,
+				nativeHostInstalled: installation.nativeHost?.installed === true,
+				extensionDir: installation.extensionDir
+			},
+			toolPermission: this.deps.canUseBrowser(agentId) ? "allowed" : "denied",
+			enabled: config.browser.enabled,
+			driverKind: config.browser.driver.kind,
+			sharedScope: "gateway",
+			endpoints: this.endpoints(),
+			setup: existing ? this.view(existing) : null,
+			guidanceRefs: [ref("overview")],
+			interaction: "conversation",
+			supportedActions: [
+				"inspect",
+				"preview",
+				"start",
+				"get",
+				"prepare",
+				"advance",
+				"open",
+				"release",
+				"recheck",
+				"request_interaction",
+				"begin_verification",
+				"verification_report",
+				"cancel"
+			]
+		};
+	}
+	async command(command, args, context, dryRun = false) {
+		if (command === "inspect" || command === "preview") return this.inspect(context.conversationId, context.agentId);
+		if (dryRun) return {
+			dryRun: true,
+			...await this.inspect(context.conversationId, context.agentId),
+			message: "No changes made. Explain the proposed setup steps in the conversation."
+		};
+		if (command === "start") {
+			const previous = findBrowserSetup(context.conversationId, context.agentId);
+			if (previous?.attempt && !previous.attempt.released) return this.view(previous);
+			if (previous && this.view(previous).stale && (!previous.attempt || previous.attempt.released)) this.cancel(previous);
+			return this.view(createBrowserSetup(context.conversationId, context.agentId, browserConfigRevision(this.deps.getConfig())));
+		}
+		if (typeof args.setupId !== "string") throw new Error("setupId is required");
+		let setup = this.owned(args.setupId, context.conversationId, context.agentId);
+		if (command === "get" || command === "verification_report" || command === "request_interaction") return this.view(setup);
+		if (command === "recheck") return this.view(await this.recheck(setup));
+		if (command === "release") return this.view(await this.release(setup));
+		if ([
+			"prepare",
+			"advance",
+			"open",
+			"begin_verification"
+		].includes(command)) {
+			if (!context.canConfigure) throw new Error("SETUP_INTERACTIVE_REQUIRED: Continue in an authorized interactive conversation.");
+			if (!Number.isInteger(args.expectedRevision) || args.expectedRevision !== setup.revision) throw new Error("SETUP_CONFLICT: Read the current progress.");
+			if (!this.deps.canUseBrowser(context.agentId)) throw new Error("AGENT_BROWSER_DENIED: Review this Agent tool permission in settings.");
+			if (command === "prepare" || command === "advance") {
+				const config = this.deps.getConfig();
+				if (config.browser.enabled && config.browser.driver.kind !== "extension" && args.switchDriver !== true) throw new Error("DRIVER_CHANGE_REQUIRED: Explain the shared driver change and confirm it with the user first.");
+				if (!setup.approvedBy) setup = this.approve(setup, `conversation:${context.conversationId}:${context.agentId}`, setup.revision);
+				const prepared = await this.prepare(setup);
+				return {
+					...this.view(prepared),
+					extensionDir: (await this.deps.doctor()).extensionDir
+				};
+			}
+			if (command === "open") {
+				if (args.target !== void 0 && ![
+					"chrome",
+					"folder",
+					"both"
+				].includes(String(args.target))) throw new Error("Choose chrome, folder or both");
+				if (!setup.approvedBy) throw new Error("SETUP_NOT_READY: Prepare the extension first.");
+				await this.open(setup, args.target ?? "both");
+				return this.view(readBrowserSetup(setup.id));
+			}
+			if (typeof args.endpointId !== "string") throw new Error("Select the exact Chrome with the user before testing");
+			if (!this.deps.verificationOrigin) throw new Error("Verification requires a running Gateway");
+			return this.view(this.begin(setup, args.endpointId, this.deps.verificationOrigin(), setup.revision));
+		}
+		if (command === "cancel") return this.view(this.cancel(setup));
+		throw new Error("Unsupported browser_setup command");
+	}
+	approve(setup, principalId, revision) {
+		this.revision(setup, revision);
+		if (setup.state === "cancelled" || setup.state === "verifying" || setup.state === "completed") throw new Error("SETUP_STATE_CHANGED");
+		if (setup.configRevision !== browserConfigRevision(this.deps.getConfig())) throw new Error("CONFIG_CHANGED: Review the current configuration before approving.");
+		return saveBrowserSetup({
+			...setup,
+			approvedBy: principalId,
+			error: void 0
+		}, setup.revision);
+	}
+	revision(setup, revision) {
+		if (setup.revision !== revision) throw new Error("SETUP_CONFLICT: Read the current progress.");
+	}
+	async prepare(setup) {
+		if (!setup.approvedBy || setup.state === "cancelled" || setup.state === "verifying" || setup.state === "completed") throw new Error("OWNER_APPROVAL_REQUIRED");
+		if (setup.attempt && !setup.attempt.released) throw new Error("CONTROL_RELEASE_REQUIRED");
+		if (this.preparing.has(setup.id)) return readBrowserSetup(setup.id);
+		if (["waiting_extension", "ready_for_verification"].includes(setup.state) && !setup.error) return this.recheck(setup);
+		const config = this.deps.getConfig();
+		if (setup.configRevision !== browserConfigRevision(config)) throw new Error("CONFIG_CHANGED: Review a new plan.");
+		if (config.browser.enabled && config.browser.driver.kind !== "extension" && this.deps.canSwitchDriver?.(setup.conversationId) === false) return saveBrowserSetup({
+			...setup,
+			state: "needs_attention",
+			error: "BROWSER_BUSY: Release existing browser sessions and wait for other runs before switching the shared driver."
+		}, setup.revision);
+		this.preparing.add(setup.id);
+		let current = saveBrowserSetup({
+			...setup,
+			state: "preparing",
+			error: void 0,
+			operation: {
+				key: setup.operation?.key ?? randomUUID(),
+				startedAt: Date.now()
+			}
+		}, setup.revision);
+		try {
+			const next = structuredClone(config);
+			next.browser.enabled = true;
+			next.browser.driver = { kind: "extension" };
+			if (browserConfigRevision(next) !== browserConfigRevision(config)) {
+				if (!(await this.deps.saveConfig(next, config)).saved) throw new Error("CONFIG_CHANGED: Configuration was not saved. Review the current settings.");
+			}
+			current = readBrowserSetup(setup.id);
+			if (current.state === "cancelled") return current;
+			current = saveBrowserSetup({
+				...current,
+				configRevision: browserConfigRevision(this.deps.getConfig())
+			}, current.revision);
+			await this.deps.prepare();
+			current = readBrowserSetup(setup.id);
+			if (current.state === "cancelled") return current;
+			this.preparing.delete(setup.id);
+			return await this.recheck(saveBrowserSetup({
+				...current,
+				state: "waiting_extension",
+				operation: void 0
+			}, current.revision));
+		} catch (error) {
+			log.warn({
+				err: error,
+				setupId: setup.id
+			}, "Browser setup preparation failed");
+			current = readBrowserSetup(setup.id);
+			if (current.state === "cancelled") return current;
+			return saveBrowserSetup({
+				...current,
+				state: "needs_attention",
+				operation: void 0,
+				error: "PREPARE_FAILED: Check the local installation and retry. Existing settings and files may have been prepared."
+			}, current.revision);
+		} finally {
+			this.preparing.delete(setup.id);
+		}
+	}
+	async recheck(setup) {
+		if (setup.state === "cancelled" || setup.state === "completed" || setup.state === "verifying" || this.preparing.has(setup.id)) return setup;
+		if (!setup.approvedBy || setup.attempt && !setup.attempt.released) return setup;
+		if (setup.configRevision !== browserConfigRevision(this.deps.getConfig())) return saveBrowserSetup({
+			...setup,
+			state: "needs_attention",
+			approvedBy: void 0,
+			error: "CONFIG_CHANGED: Restart the plan using the current settings."
+		}, setup.revision);
+		const doctor = await this.deps.doctor();
+		const current = readBrowserSetup(setup.id);
+		if (current.revision !== setup.revision) return current;
+		const ready = doctor.installed && !doctor.needsRefresh && doctor.nativeHost?.installed === true;
+		return saveBrowserSetup({
+			...setup,
+			state: ready ? this.endpoints().length ? "ready_for_verification" : "waiting_extension" : "needs_attention",
+			operation: void 0,
+			error: ready ? void 0 : "INSTALLATION_REQUIRED: Prepare or repair the local extension files."
+		}, setup.revision);
+	}
+	async open(setup, action) {
+		if (!setup.approvedBy || setup.state === "cancelled") throw new Error("OWNER_APPROVAL_REQUIRED");
+		return this.deps.open(action);
+	}
+	begin(setup, endpointId, origin, revision) {
+		this.revision(setup, revision);
+		if (!setup.approvedBy || setup.state !== "ready_for_verification") throw new Error("SETUP_NOT_READY");
+		if (setup.configRevision !== browserConfigRevision(this.deps.getConfig())) throw new Error("CONFIG_CHANGED");
+		if (setup.attempt && !setup.attempt.released) throw new Error("CONTROL_RELEASE_REQUIRED");
+		if (!this.deps.canUseBrowser(setup.agentId)) throw new Error("AGENT_BROWSER_DENIED: Enable browser_use for this Agent and start a refreshed turn.");
+		if (getBrowserTabBinding(setup.conversationId)) throw new Error("TAB_ALREADY_ATTACHED: Release the existing tab before starting this test.");
+		const endpoint = this.endpoints().find((e) => e.endpointId === endpointId);
+		if (!endpoint) throw new Error("ENDPOINT_OFFLINE");
+		const url = new URL(origin);
+		if (!["http:", "https:"].includes(url.protocol) || url.username || url.password) throw new Error("INVALID_ORIGIN");
+		const id = randomUUID();
+		const marker = `XOPC-${randomUUID()}`;
+		return saveBrowserSetup({
+			...setup,
+			state: "verifying",
+			error: void 0,
+			attempt: {
+				id,
+				endpointId,
+				principalId: endpoint.principalId,
+				appVersion: endpoint.appVersion,
+				policyRevision: this.policyRevision(setup.agentId),
+				fixtureUrl: `${url.origin}/browser-setup-test.html#${marker}`,
+				marker,
+				sample: `Hello-${id.slice(0, 8)}`,
+				sessionId: randomUUID(),
+				expiresAt: Date.now() + VERIFY_MS,
+				actions: 0,
+				read: false,
+				clicked: false,
+				filled: false,
+				released: false
+			}
+		}, setup.revision);
+	}
+	cancel(setup) {
+		if (setup.state === "cancelled") return setup;
+		return saveBrowserSetup({
+			...setup,
+			state: "cancelled",
+			approvedBy: void 0,
+			error: setup.attempt && !setup.attempt.released ? "CONTROL_RELEASE_REQUIRED: Close the verification browser session; cancellation does not prove release." : void 0
+		}, setup.revision);
+	}
+	async release(setup) {
+		if (!setup.attempt || setup.attempt.released) return setup;
+		const endpoint = this.endpoints().find((e) => e.endpointId === setup.attempt.endpointId);
+		if (!endpoint || endpoint.principalId !== setup.attempt.principalId) throw new Error("ENDPOINT_OFFLINE: Control release cannot be confirmed.");
+		const result = await this.deps.release(setup.attempt.endpointId, setup.attempt.sessionId);
+		return this.afterAction(setup.id, setup.attempt.id, { action: "close" }, result) ?? readBrowserSetup(setup.id);
+	}
+	canRestoreSession(taskKey, sessionId) {
+		const [prefix, setupId, attemptId] = taskKey.split(":");
+		if (prefix !== "browser-setup" || !setupId) return false;
+		const setup = readBrowserSetup(setupId);
+		return Boolean(setup?.attempt?.id === attemptId && setup.attempt.sessionId === sessionId && !setup.attempt.released);
+	}
+	allowsVerificationUrl(taskKey, url) {
+		const [prefix, setupId, attemptId] = taskKey.split(":");
+		if (prefix !== "browser-setup" || !setupId) return false;
+		const setup = readBrowserSetup(setupId);
+		return Boolean(setup?.approvedBy && setup.state === "verifying" && setup.attempt?.id === attemptId && setup.attempt.fixtureUrl === url && Date.now() <= setup.attempt.expiresAt && setup.configRevision === browserConfigRevision(this.deps.getConfig()));
+	}
+	/** Called only by the real Agent browser tool, before its normal runtime/policy path. */
+	beforeAction(conversationId, agentId, input) {
+		let setup = findBrowserSetup(conversationId, agentId);
+		if (setup?.attempt?.released && input.action === "close" && input.sessionId === setup.attempt.sessionId) throw new Error("VERIFICATION_ALREADY_RELEASED");
+		if (!setup?.attempt || setup.attempt.released || ![
+			"verifying",
+			"needs_attention",
+			"cancelled"
+		].includes(setup.state)) return void 0;
+		const a = setup.attempt;
+		if (!(input.action === "close")) {
+			if (setup.state !== "verifying") throw new Error("VERIFICATION_STOPPED: Close the verification session first.");
+			if (Date.now() > a.expiresAt || a.actions >= MAX_ACTIONS) throw new Error("VERIFICATION_BUDGET_EXCEEDED: Close the verification session.");
+			if (setup.configRevision !== browserConfigRevision(this.deps.getConfig()) || a.policyRevision !== this.policyRevision(setup.agentId)) throw new Error("CONFIG_CHANGED: Close the verification session.");
+			const endpoint = this.endpoints().find((e) => e.endpointId === a.endpointId);
+			if (!endpoint || endpoint.principalId !== a.principalId || endpoint.appVersion !== a.appVersion) throw new Error("ENDPOINT_CHANGED");
+			const node = "ref" in input ? a.observation?.nodes.find((n) => n.ref === input.ref) : void 0;
+			if (!(input.action === "navigate" ? !a.tabId && input.url === a.fixtureUrl : input.action === "observe" ? Boolean(a.sessionId) : input.action === "click" ? a.read && !a.clicked && node?.role === "button" && node.name === "Test click" && input.revision === a.observation?.revision : input.action === "fill" ? a.clicked && !a.filled && node?.name === "Test input" && input.value === a.sample && input.submit !== true && input.revision === a.observation?.revision : false)) throw new Error("VERIFICATION_ACTION_DENIED: Follow the test instructions using fresh observation refs.");
+		}
+		if (input.sessionId && input.sessionId !== a.sessionId) throw new Error("VERIFICATION_SESSION_MISMATCH");
+		setup = saveBrowserSetup({
+			...setup,
+			attempt: {
+				...a,
+				actions: a.actions + 1
+			}
+		}, setup.revision);
+		return {
+			setupId: setup.id,
+			attemptId: a.id,
+			taskKey: `browser-setup:${setup.id}:${a.id}`,
+			input: {
+				...input,
+				...a.sessionId ? { sessionId: a.sessionId } : {},
+				target: {
+					kind: "endpoint",
+					endpointId: a.endpointId
+				}
+			}
+		};
+	}
+	afterAction(setupId, attemptId, input, result) {
+		const setup = readBrowserSetup(setupId);
+		if (!setup?.attempt || setup.attempt.id !== attemptId) return;
+		const a = { ...setup.attempt };
+		if (input.action === "close" && result.ok && result.receipt.action === "close" && result.receipt.verified) {
+			a.released = true;
+			delete a.observation;
+			const complete = setup.state === "verifying" && setup.configRevision === browserConfigRevision(this.deps.getConfig()) && Date.now() <= a.expiresAt && a.policyRevision === this.policyRevision(setup.agentId) && this.deps.canUseBrowser(setup.agentId) && a.read && a.clicked && a.filled;
+			return saveBrowserSetup({
+				...setup,
+				attempt: a,
+				state: setup.state === "cancelled" ? "cancelled" : complete ? "completed" : "needs_attention",
+				error: complete || setup.state === "cancelled" ? void 0 : setup.error?.startsWith("BROWSER_CONTROL_REVOKED") ? setup.error : "VERIFICATION_INCOMPLETE: Review the checks and start a new test."
+			}, setup.revision);
+		}
+		if ("error" in result) return saveBrowserSetup({
+			...setup,
+			state: setup.state === "cancelled" ? "cancelled" : "needs_attention",
+			error: result.error.message.includes("BROWSER_CONTROL_REVOKED") ? "BROWSER_CONTROL_REVOKED: Chrome control was stopped by the user. Release the demo, then resume control in the extension before starting a new test." : "BROWSER_ACTION_FAILED: Close the verification session before retrying."
+		}, setup.revision);
+		if (result.receipt.action !== input.action) return saveBrowserSetup({
+			...setup,
+			state: setup.state === "cancelled" ? "cancelled" : "needs_attention",
+			error: "VERIFICATION_RECEIPT_MISMATCH: Release the demo session."
+		}, setup.revision);
+		const o = result.receipt.observation;
+		if (!o || !result.receipt.verified) return;
+		if (o.url !== a.fixtureUrl || a.tabId && o.tabId !== a.tabId || a.documentId && o.documentId !== a.documentId || a.sessionId && o.sessionId !== a.sessionId) return saveBrowserSetup({
+			...setup,
+			state: setup.state === "cancelled" ? "cancelled" : "needs_attention",
+			error: "VERIFICATION_TARGET_CHANGED: Close the verification session."
+		}, setup.revision);
+		a.sessionId = o.sessionId;
+		a.tabId = o.tabId;
+		a.documentId = o.documentId;
+		a.observation = {
+			revision: o.revision,
+			nodes: o.nodes.map(({ ref, role, name, value, states }) => ({
+				ref,
+				role,
+				name,
+				value,
+				states
+			}))
+		};
+		const names = o.nodes.map((n) => n.name);
+		if (names.includes(`Read check: ${a.marker}`)) a.read = true;
+		if (input.action === "click" && names.includes(`Click passed: ${a.marker}`)) a.clicked = true;
+		if (input.action === "fill" && a.clicked && names.includes(`Input passed: ${a.sample}`)) a.filled = true;
+		return saveBrowserSetup({
+			...setup,
+			attempt: a
+		}, setup.revision);
+	}
+};
+//#endregion
+export { BrowserSetupService, browserConfigRevision };

package/dist/src/browser/setup/types.d.ts

@@ -0,0 +1,38 @@
+import type { BrowserObservation } from '@xopcai/browser-control-contract';
+export type SetupState = 'plan_ready' | 'preparing' | 'waiting_extension' | 'ready_for_verification' | 'verifying' | 'needs_attention' | 'completed' | 'cancelled';
+export interface BrowserSetup {
+    id: string;
+    conversationId: string;
+    agentId: string;
+    revision: number;
+    state: SetupState;
+    configRevision: string;
+    approvedBy?: string;
+    createdAt: number;
+    updatedAt: number;
+    operation?: {
+        key: string;
+        startedAt: number;
+    };
+    error?: string;
+    attempt?: {
+        id: string;
+        endpointId: string;
+        principalId: string;
+        appVersion: string;
+        policyRevision: string;
+        fixtureUrl: string;
+        marker: string;
+        sample: string;
+        expiresAt: number;
+        actions: number;
+        sessionId?: string;
+        tabId?: string;
+        documentId?: string;
+        observation?: Pick<BrowserObservation, 'revision' | 'nodes'>;
+        read: boolean;
+        clicked: boolean;
+        filled: boolean;
+        released: boolean;
+    };
+}

package/dist/src/browser/setup/types.js

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

package/dist/src/capabilities/runtime/dispatcher.js

@@ -1,7 +1,7 @@
 import { SqliteCommitEffectError, init_transaction } from "../../storage/sqlite/transaction.js";
-import { OperationConflictError, executeAtomicOperation } from "./atomic-operations.js";
 import { CapabilityError } from "./errors.js";
 import { executeExternalOperation } from "./external-operations.js";
+import { OperationConflictError, executeAtomicOperation } from "./atomic-operations.js";
 import { createHash } from "node:crypto";
 import { z } from "zod";
 //#region src/capabilities/runtime/dispatcher.ts

package/dist/src/capabilities/runtime/product.js

@@ -1,6 +1,5 @@
 import { CapabilityError } from "./errors.js";
 import { CapabilityDispatcher } from "./dispatcher.js";
-import { registerAgentCapabilities } from "../../agent-catalog/capabilities.js";
 import { registerLocalAppReadCapabilities } from "../../local-apps/capabilities/read.js";
 import { registerNoteReadCapabilities } from "../../notes/capabilities/read.js";
 import { registerNoteWriteCapabilities } from "../../notes/capabilities/write.js";
@@ -17,6 +16,7 @@ import { registerAutomationDraftCapabilities } from "../../automations/capabilit
 import { registerTaskWriteCapabilities } from "../../tasks/capabilities/write.js";
 import { registerSettingsCapability } from "./settings.js";
 import { registerAppContextCapability } from "./app-context.js";
+import { registerAgentCapabilities } from "../../agent-catalog/capabilities.js";
 //#region src/capabilities/runtime/product.ts
 function createProductDispatcher(getNotes, taskWrites) {
 	const dispatcher = new CapabilityDispatcher();

package/dist/src/chat-previews/store.js

@@ -1,8 +1,7 @@
 import { getSqliteDatabase, runSqliteWriteTransaction } from "../storage/sqlite/transaction.js";
-import { init_sqlite } from "../storage/sqlite/index.js";
+import "../storage/sqlite/index.js";
 import { randomUUID } from "node:crypto";
 //#region src/chat-previews/store.ts
-init_sqlite();
 function previewFromRow(row) {
 	return {
 		id: row.preview_id,