@xopcai/xopc 0.0.368 → 0.0.369

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

@@ -1,6 +1,6 @@
 import { BrowserAutomationDefinitionSchema } from "./schema.js";
 import { resolveBrowserAutomationInputs } from "./runner.js";
-import { appendBrowserAutomationRunEvent, deleteBrowserAutomation, getBrowserAutomation, getBrowserAutomationRun, hasActiveBrowserAutomationRuns, listActiveBrowserAutomationRuns, listBrowserAutomationRunEvents, listBrowserAutomationRuns, listBrowserAutomations, nextBrowserAutomationRunEventSeq, saveBrowserAutomation, saveBrowserAutomationRun } from "./repository.js";
+import { appendBrowserAutomationRunEvent, deleteBrowserAutomation, findBrowserAutomationRunByRequest, getBrowserAutomation, getBrowserAutomationRun, getBrowserAutomationVersion, hasActiveBrowserAutomationRuns, listActiveBrowserAutomationRuns, listBrowserAutomationRunEvents, listBrowserAutomationRuns, listBrowserAutomationVersions, listBrowserAutomations, nextBrowserAutomationRunEventSeq, saveBrowserAutomation, saveBrowserAutomationRun, verifyBrowserAutomationRun } from "./repository.js";
 import { randomUUID } from "node:crypto";
 //#region src/browser/automations/service.ts
 var BrowserAutomationService = class {
@@ -15,7 +15,8 @@ var BrowserAutomationService = class {
 			saveBrowserAutomationRun({
 				...run,
 				status: "failed",
-				error: "Gateway stopped before the run completed.",
+				businessOutcome: "unknown",
+				error: "Gateway stopped before the run completed. Check the business result before running again.",
 				endedAtMs,
 				durationMs: run.startedAtMs ? endedAtMs - run.startedAtMs : void 0
 			});
@@ -27,6 +28,9 @@ var BrowserAutomationService = class {
 	get(id) {
 		return getBrowserAutomation(id);
 	}
+	versions(id) {
+		return listBrowserAutomationVersions(id);
+	}
 	listRuns(automationId) {
 		return listBrowserAutomationRuns(automationId);
 	}
@@ -43,10 +47,13 @@ var BrowserAutomationService = class {
 		const parsed = BrowserAutomationDefinitionSchema.parse(input.definition);
 		if (input.expectedId && parsed.id !== input.expectedId) throw new Error("Browser automation id cannot change.");
 		const existing = getBrowserAutomation(parsed.id);
+		if (input.expectedRevision !== void 0 && existing?.revision !== input.expectedRevision) throw new Error("Browser automation revision changed. Reload before saving.");
+		const changed = !existing || canonical(existing.definition) !== canonical(parsed);
 		const now = Date.now();
 		const automation = {
 			id: parsed.id,
-			revision: (existing?.revision ?? 0) + 1,
+			verified: !changed && !!existing?.verified,
+			revision: (existing?.revision ?? 0) + (changed ? 1 : 0),
 			status: input.status ?? existing?.status ?? "enabled",
 			definition: parsed,
 			createdAtMs: existing?.createdAtMs ?? now,
@@ -60,12 +67,22 @@ var BrowserAutomationService = class {
 		return deleteBrowserAutomation(id);
 	}
 	startRun(automationId, inputs, context) {
-		const automation = getBrowserAutomation(automationId);
+		const requestId = context?.clientRequestId;
+		if (requestId) {
+			const previous = findBrowserAutomationRunByRequest(requestId);
+			if (previous) {
+				const contextualInputs = mergeBrowserAutomationTriggerInputs(previous.definition, inputs, context);
+				if (previous.automationId !== automationId || context?.revision !== void 0 && context.revision !== previous.automationRevision || canonical(previous.inputs) !== canonical(resolveBrowserAutomationInputs(previous.definition, contextualInputs))) throw new Error("Run request id was reused with a different automation, revision or inputs.");
+				return previous;
+			}
+		}
+		const automation = context?.revision !== void 0 ? getBrowserAutomationVersion(automationId, context.revision) : getBrowserAutomation(automationId);
 		if (!automation) throw new Error("Browser automation not found.");
 		if (automation.status !== "enabled") throw new Error("Browser automation is disabled.");
 		const contextualInputs = mergeBrowserAutomationTriggerInputs(automation.definition, inputs, context);
 		const resolvedInputs = resolveBrowserAutomationInputs(automation.definition, contextualInputs);
 		const run = {
+			clientRequestId: requestId,
 			id: randomUUID(),
 			automationId,
 			automationRevision: automation.revision,
@@ -93,6 +110,8 @@ var BrowserAutomationService = class {
 	}
 	async runAndWait(automationId, inputs, signal, context) {
 		const run = this.startRun(automationId, inputs, context);
+		const terminal = this.getRun(run.id);
+		if (terminal && !["queued", "running"].includes(terminal.status)) return terminal;
 		return new Promise((resolve) => {
 			const complete = (value) => {
 				signal?.removeEventListener("abort", onAbort);
@@ -131,6 +150,7 @@ var BrowserAutomationService = class {
 		this.addEvent(run.id, "run.started");
 		try {
 			const outcome = await this.executor({
+				runId: run.id,
 				definition: run.definition,
 				inputs: run.inputs,
 				signal: controller.signal,
@@ -142,6 +162,13 @@ var BrowserAutomationService = class {
 				status: controller.signal.aborted ? "cancelled" : outcome.ok ? "succeeded" : "failed",
 				result: outcome.result,
 				error: outcome.error,
+				businessOutcome: outcome.businessOutcome ?? (!outcome.ok && run.definition.steps.some((step) => [
+					"click",
+					"press",
+					"fill",
+					"select",
+					"check"
+				].includes(step.action)) ? "unknown" : "completed"),
 				endedAtMs,
 				durationMs: endedAtMs - startedAtMs
 			};
@@ -150,12 +177,14 @@ var BrowserAutomationService = class {
 			current = {
 				...current,
 				status: controller.signal.aborted ? "cancelled" : "failed",
+				businessOutcome: "unknown",
 				error: error instanceof Error ? error.message : String(error),
 				endedAtMs,
 				durationMs: endedAtMs - startedAtMs
 			};
 		}
 		saveBrowserAutomationRun(current);
+		verifyBrowserAutomationRun(current);
 		this.addEvent(run.id, "run.completed", {
 			status: current.status,
 			error: current.error
@@ -178,5 +207,8 @@ function mergeBrowserAutomationTriggerInputs(definition, inputs, context) {
 	for (const name of Object.keys(definition.inputs)) if (merged[name] === void 0 && candidates[name] !== void 0) merged[name] = candidates[name];
 	return merged;
 }
+function canonical(value) {
+	return JSON.stringify(value, (_key, item) => item && typeof item === "object" && !Array.isArray(item) ? Object.fromEntries(Object.entries(item).sort(([a], [b]) => a.localeCompare(b))) : item);
+}
 //#endregion
 export { BrowserAutomationService, mergeBrowserAutomationTriggerInputs };

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

@@ -1,4 +1,6 @@
 import type { BrowserExpectation, BrowserRiskLevel } from '@xopcai/browser-control-contract';
+import type { BrowserSemanticTarget } from '@xopcai/browser-control-contract';
+export type { BrowserSemanticTarget } from '@xopcai/browser-control-contract';
 export type BrowserAutomationStatus = 'enabled' | 'disabled';
 export type BrowserAutomationRunStatus = 'queued' | 'running' | 'succeeded' | 'failed' | 'cancelled';
 export interface BrowserAutomationInputDefinition {
@@ -8,10 +10,11 @@ export interface BrowserAutomationInputDefinition {
     description?: string;
     choices?: Array<string | number | boolean>;
 }
-export interface BrowserSemanticTarget {
-    role: string;
-    name?: string;
-    nameIncludes?: string;
+export interface BrowserAutomationAssertion {
+    target?: BrowserSemanticTarget;
+    field: 'text' | 'value' | 'url' | 'title' | 'checked';
+    equals?: string | boolean;
+    includes?: string;
 }
 export type BrowserAutomationStep = {
     action: 'navigate';
@@ -32,6 +35,10 @@ export type BrowserAutomationStep = {
     target: BrowserSemanticTarget;
     value: string;
     expect?: BrowserExpectation;
+} | {
+    action: 'check';
+    target: BrowserSemanticTarget;
+    checked: boolean;
 } | {
     action: 'press';
     target?: BrowserSemanticTarget;
@@ -57,10 +64,16 @@ export interface BrowserAutomationDefinition {
     risk: BrowserRiskLevel;
     inputs: Record<string, BrowserAutomationInputDefinition>;
     steps: BrowserAutomationStep[];
+    successCriteria?: BrowserAutomationAssertion[];
+    outputs?: Record<string, {
+        target?: BrowserSemanticTarget;
+        field: 'text' | 'value' | 'url' | 'title' | 'href';
+    }>;
 }
 export interface BrowserAutomation {
     id: string;
     revision: number;
+    verified: boolean;
     status: BrowserAutomationStatus;
     definition: BrowserAutomationDefinition;
     createdAtMs: number;
@@ -70,6 +83,8 @@ export interface BrowserAutomationRun {
     id: string;
     automationId: string;
     automationRevision: number;
+    clientRequestId?: string;
+    businessOutcome?: 'completed' | 'verified' | 'unknown';
     definition: BrowserAutomationDefinition;
     status: BrowserAutomationRunStatus;
     inputs: Record<string, unknown>;

package/dist/src/browser/drivers/extension-driver.d.ts

@@ -3,7 +3,7 @@ import type { BrowserDriver, BrowserPrimitiveInput } from './browser-driver.js';
 type ExtensionProvider = {
     start(): Promise<void>;
     waitForConnection(timeoutMs?: number): Promise<void>;
-    send(input: import('@xopcai/browser-control-contract').BrowserActionInput, timeoutMs?: number, visualFallback?: boolean): Promise<import('@xopcai/browser-control-contract').BrowserWireResult>;
+    send(input: import('@xopcai/browser-control-contract').BrowserActionInput, timeoutMs?: number, visualFallback?: boolean, signal?: AbortSignal): Promise<import('@xopcai/browser-control-contract').BrowserWireResult>;
 };
 export declare class ExtensionDriver implements BrowserDriver {
     private readonly provider;
@@ -16,10 +16,10 @@ export declare class ExtensionDriver implements BrowserDriver {
     disconnect(): Promise<void>;
     createSession(_sessionId: string): Promise<void>;
     closeSession(sessionId: string): Promise<void>;
-    navigate(sessionId: string, input: BrowserNavigateInput): Promise<BrowserControlResult>;
-    observe(sessionId: string, input: BrowserObserveInput): Promise<BrowserObservation>;
-    perform(sessionId: string, input: BrowserPrimitiveInput): Promise<BrowserControlResult>;
-    tabs(sessionId: string, input: BrowserTabsInput): Promise<BrowserControlResult>;
+    navigate(sessionId: string, input: BrowserNavigateInput, signal?: AbortSignal): Promise<BrowserControlResult>;
+    observe(sessionId: string, input: BrowserObserveInput, signal?: AbortSignal): Promise<BrowserObservation>;
+    perform(sessionId: string, input: BrowserPrimitiveInput, signal?: AbortSignal): Promise<BrowserControlResult>;
+    tabs(sessionId: string, input: BrowserTabsInput, signal?: AbortSignal): Promise<BrowserControlResult>;
     private send;
 }
 export {};

package/dist/src/browser/drivers/extension-driver.js

@@ -23,36 +23,36 @@ var ExtensionDriver = class {
 			sessionId
 		});
 	}
-	navigate(sessionId, input) {
+	navigate(sessionId, input, signal) {
 		return this.send({
 			...input,
 			sessionId
-		});
+		}, signal);
 	}
-	async observe(sessionId, input) {
+	async observe(sessionId, input, signal) {
 		const result = await this.send({
 			...input,
 			sessionId
-		});
+		}, signal);
 		if ("error" in result) throw new Error(result.error.message);
 		const observation = result.receipt.observation;
 		if (!observation) throw new Error("Extension returned no browser observation");
 		return observation;
 	}
-	perform(sessionId, input) {
+	perform(sessionId, input, signal) {
 		return this.send({
 			...input,
 			sessionId
-		});
+		}, signal);
 	}
-	tabs(sessionId, input) {
+	tabs(sessionId, input, signal) {
 		return this.send({
 			...input,
 			sessionId
-		});
+		}, signal);
 	}
-	async send(input) {
-		return (await this.provider.send(input, this.timeoutMs, this.visualFallback)).result;
+	async send(input, signal) {
+		return (await this.provider.send(input, this.timeoutMs, this.visualFallback, signal)).result;
 	}
 };
 //#endregion

package/dist/src/browser/drivers/playwright-driver.js

@@ -1,3 +1,5 @@
+import { browserDom } from "../../../packages/browser-control-contract/src/automation.js";
+import "../../../packages/browser-control-contract/src/index.js";
 import { verifyBrowserExpectation } from "../verification/expectation.js";
 import { randomUUID } from "node:crypto";
 //#region src/browser/drivers/playwright-driver.ts
@@ -174,6 +176,47 @@ var PlaywrightDriver = class {
 		try {
 			throwIfAborted(signal);
 			const state = await this.activeState(sessionId);
+			if (input.action === "resolve") {
+				const resolved = await state.page.evaluate(browserDom, {
+					operation: "resolve",
+					target: input.semanticTarget
+				});
+				if (resolved.matches !== 1) return {
+					ok: false,
+					error: {
+						code: "TARGET_NOT_FOUND",
+						message: `Semantic target must match exactly one element; matched ${resolved.matches}.`
+					}
+				};
+				const handle = await state.page.locator(`[data-xopc-ref="${resolved.node.ref}"]`).elementHandle();
+				if (!handle) return targetNotFound(resolved.node.ref);
+				state.refs.set(resolved.node.ref, handle);
+				state.revision += 1;
+				const observation = {
+					sessionId,
+					tabId: state.id,
+					revision: state.revision,
+					documentId: state.documentId,
+					url: state.page.url(),
+					title: await state.page.title(),
+					nodes: [resolved.node],
+					changes: {
+						added: [resolved.node],
+						changed: [],
+						removed: []
+					}
+				};
+				return {
+					ok: true,
+					receipt: {
+						action: "resolve",
+						risk: "read",
+						durationMs: Date.now() - startedAt,
+						verified: true,
+						observation
+					}
+				};
+			}
 			if ("revision" in input && input.revision !== state.revision) return stale(await this.observe(sessionId, {
 				action: "observe",
 				visual: "never"
@@ -188,6 +231,9 @@ var PlaywrightDriver = class {
 					await handle.fill(input.value, { timeout: this.options.actionTimeoutMs });
 					if (input.submit) await handle.press("Enter");
 					break;
+				case "check":
+					await handle.setChecked(input.checked, { timeout: this.options.actionTimeoutMs });
+					break;
 				case "select":
 					await handle.selectOption(input.value);
 					break;

package/dist/src/browser/index.d.ts

@@ -4,8 +4,7 @@ export type { BrowserDriver, BrowserPrimitiveInput } from './drivers/browser-dri
 export { PlaywrightDriver, type PlaywrightDriverOptions } from './drivers/playwright-driver.js';
 export { ExtensionDriver } from './drivers/extension-driver.js';
 export { formatBrowserObservation } from './observation/format.js';
-export { classifyBrowserRisk, browserRiskNeedsApproval } from './policy/browser-policy.js';
-export { createBrowserApproval, consumeBrowserApproval, decideBrowserApproval, listBrowserApprovals, } from './policy/approval-store.js';
+export { classifyBrowserRisk } from './policy/browser-policy.js';
 export { verifyBrowserExpectation } from './verification/expectation.js';
 export { BrowserNotReadyError, buildBrowserSetupDeepLink, checkBrowserReadiness, type BrowserDriverKind, type BrowserNotReadyReason, type BrowserSetupHint, } from './readiness.js';
 export { assertBrowserUrlAllowed, checkPostRedirectUrl, containsApiKeyPattern, isAlwaysBlockedUrl, } from './url-policy.js';

package/dist/src/browser/index.js

@@ -1,6 +1,5 @@
 import { assertBrowserUrlAllowed, checkPostRedirectUrl, containsApiKeyPattern, isAlwaysBlockedUrl } from "./url-policy.js";
-import { consumeBrowserApproval, createBrowserApproval, decideBrowserApproval, listBrowserApprovals } from "./policy/approval-store.js";
-import { browserRiskNeedsApproval, classifyBrowserRisk } from "./policy/browser-policy.js";
+import { classifyBrowserRisk } from "./policy/browser-policy.js";
 import { BrowserRuntime } from "./runtime/browser-runtime.js";
 import { ExtensionDriver } from "./drivers/extension-driver.js";
 import { verifyBrowserExpectation } from "./verification/expectation.js";
@@ -8,4 +7,4 @@ import { PlaywrightDriver } from "./drivers/playwright-driver.js";
 import { createBrowserDriver } from "./drivers/create-driver.js";
 import { formatBrowserObservation } from "./observation/format.js";
 import { BrowserNotReadyError, buildBrowserSetupDeepLink, checkBrowserReadiness } from "./readiness.js";
-export { BrowserNotReadyError, BrowserRuntime, ExtensionDriver, PlaywrightDriver, assertBrowserUrlAllowed, browserRiskNeedsApproval, buildBrowserSetupDeepLink, checkBrowserReadiness, checkPostRedirectUrl, classifyBrowserRisk, consumeBrowserApproval, containsApiKeyPattern, createBrowserApproval, createBrowserDriver, decideBrowserApproval, formatBrowserObservation, isAlwaysBlockedUrl, listBrowserApprovals, verifyBrowserExpectation };
+export { BrowserNotReadyError, BrowserRuntime, ExtensionDriver, PlaywrightDriver, assertBrowserUrlAllowed, buildBrowserSetupDeepLink, checkBrowserReadiness, checkPostRedirectUrl, classifyBrowserRisk, containsApiKeyPattern, createBrowserDriver, formatBrowserObservation, isAlwaysBlockedUrl, verifyBrowserExpectation };

package/dist/src/browser/policy/browser-policy.d.ts

@@ -1,3 +1,2 @@
 import type { BrowserActionInput, BrowserNode, BrowserRiskLevel } from '@xopcai/browser-control-contract';
 export declare function classifyBrowserRisk(input: BrowserActionInput, target?: BrowserNode): BrowserRiskLevel;
-export declare function browserRiskNeedsApproval(risk: BrowserRiskLevel): boolean;

package/dist/src/browser/policy/browser-policy.js

@@ -20,8 +20,5 @@ function classifyBrowserRisk(input, target) {
 	if (EXTERNAL_EFFECT_PATTERN.test(label)) return "external_effect";
 	return "draft";
 }
-function browserRiskNeedsApproval(risk) {
-	return risk === "external_effect" || risk === "destructive" || risk === "sensitive";
-}
 //#endregion
-export { browserRiskNeedsApproval, classifyBrowserRisk };
+export { classifyBrowserRisk };

package/dist/src/browser/providers/index.d.ts

@@ -1,4 +1,4 @@
 export type { CloudBrowserProvider, CloudBrowserProviderConfig } from './types.js';
 export { BrowserbaseProvider } from './browserbase.js';
 export { BrowserUseProvider } from './browser-use.js';
-export { ExtensionBrowserProvider } from './extension.js';
+export { RealtimeExtensionBrowserProvider } from './realtime-extension.js';

package/dist/src/browser/providers/index.js

@@ -1,4 +1,4 @@
 import { BrowserbaseProvider } from "./browserbase.js";
 import { BrowserUseProvider } from "./browser-use.js";
-import { ExtensionBrowserProvider } from "./extension.js";
-export { BrowserUseProvider, BrowserbaseProvider, ExtensionBrowserProvider };
+import { RealtimeExtensionBrowserProvider } from "./realtime-extension.js";
+export { BrowserUseProvider, BrowserbaseProvider, RealtimeExtensionBrowserProvider };

package/dist/src/browser/providers/realtime-extension.d.ts

@@ -12,7 +12,7 @@ export declare class RealtimeExtensionBrowserProvider {
     constructor(runtime: EndpointToolRuntime, config?: RealtimeExtensionProviderConfig);
     start(): Promise<void>;
     waitForConnection(timeoutMs?: number): Promise<void>;
-    send(input: BrowserActionInput, timeoutMs?: number, visualFallback?: boolean): Promise<BrowserWireResult>;
+    send(input: BrowserActionInput, timeoutMs?: number, visualFallback?: boolean, signal?: AbortSignal): Promise<BrowserWireResult>;
     isConnected(): boolean;
     getConnectionStatus(): {
         socketConnected: boolean;

package/dist/src/browser/providers/realtime-extension.js

@@ -20,7 +20,7 @@ var RealtimeExtensionBrowserProvider = class {
 			await new Promise((resolve) => setTimeout(resolve, 200));
 		}
 	}
-	async send(input, timeoutMs = this.commandTimeout, visualFallback = true) {
+	async send(input, timeoutMs = this.commandTimeout, visualFallback = true, signal) {
 		const endpoint = this.endpointForInput(input);
 		if (!endpoint) {
 			if (input.target?.kind === "endpoint") throw new Error(`The Chrome endpoint bound to this Session is offline (${input.target.endpointId}). Reconnect that browser or bind another one.`);
@@ -31,6 +31,9 @@ var RealtimeExtensionBrowserProvider = class {
 		if (!tool) throw new Error("Connected browser extension does not support authenticated Realtime browser control. Reload or update the extension.");
 		const id = crypto.randomUUID();
 		const controller = new AbortController();
+		const abort = () => controller.abort();
+		signal?.addEventListener("abort", abort, { once: true });
+		if (signal?.aborted) controller.abort();
 		const timer = setTimeout(() => controller.abort(), timeoutMs);
 		try {
 			const value = (await this.runtime.invocations.invoke({
@@ -53,6 +56,7 @@ var RealtimeExtensionBrowserProvider = class {
 			};
 		} finally {
 			clearTimeout(timer);
+			signal?.removeEventListener("abort", abort);
 		}
 	}
 	isConnected() {

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

@@ -0,0 +1,22 @@
+import type { BrowserRecordingEvent } from '@xopcai/browser-control-contract';
+import type { BrowserAutomationService, BrowserAutomationDefinition } from '../automations/index.js';
+type RecordingRow = {
+    recording_id: string;
+    principal_id: string;
+    state: string;
+    ack_seq: number;
+    final_seq: number | null;
+    automation_id: string | null;
+    error: string | null;
+};
+export declare class BrowserRecordingService {
+    private readonly automations;
+    constructor(automations: BrowserAutomationService);
+    get(id: string, principalId: string): RecordingRow | null;
+    append(id: string, principalId: string, payload: unknown): {
+        ackThrough: number;
+    };
+    finish(id: string, principalId: string, finalSeq: number): import("../automations/types.js").BrowserAutomation;
+}
+export declare function compileRecording(id: string, events: BrowserRecordingEvent[]): BrowserAutomationDefinition;
+export {};

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

@@ -0,0 +1,160 @@
+import { getSqliteDatabase, runSqliteWriteTransaction } from "../../storage/sqlite/transaction.js";
+import { init_sqlite } from "../../storage/sqlite/index.js";
+import { z } from "zod";
+//#region src/browser/recordings/service.ts
+init_sqlite();
+const Target = z.object({
+	role: z.string().min(1),
+	name: z.string().max(240).optional(),
+	nameIncludes: z.string().max(240).optional(),
+	testId: z.string().max(240).optional(),
+	scope: z.object({
+		role: z.string(),
+		name: z.string().max(240)
+	}).strict().optional()
+}).strict();
+const Event = z.object({
+	id: z.string().uuid(),
+	seq: z.number().int().positive(),
+	documentId: z.string().max(200),
+	sourceSeq: z.number().int().positive(),
+	url: z.string().url().max(4096),
+	action: z.enum([
+		"navigate",
+		"click",
+		"fill",
+		"select",
+		"check",
+		"press",
+		"checkpoint",
+		"unsupported"
+	]),
+	target: Target.optional(),
+	value: z.string().max(4096).optional(),
+	checked: z.boolean().optional(),
+	key: z.enum(["Enter", "Escape"]).optional()
+}).strict();
+const Batch = z.array(Event).min(1).max(100);
+var BrowserRecordingService = class {
+	constructor(automations) {
+		this.automations = automations;
+	}
+	get(id, principalId) {
+		return getSqliteDatabase().prepare("SELECT * FROM browser_recordings WHERE recording_id=? AND principal_id=?").get(id, principalId) ?? null;
+	}
+	append(id, principalId, payload) {
+		z.string().uuid().parse(id);
+		const events = Batch.parse(payload);
+		return runSqliteWriteTransaction((db) => {
+			const now = Date.now();
+			db.prepare("INSERT OR IGNORE INTO browser_recordings (recording_id, principal_id, state, created_at_ms, updated_at_ms) VALUES (?, ?, 'recording', ?, ?)").run(id, principalId, now, now);
+			const row = this.get(id, principalId);
+			if (!row) throw new Error("Recording belongs to another device.");
+			if (Math.max(row.ack_seq, events.at(-1).seq) > 1e4) throw new Error("Recording event budget exceeded.");
+			let bytes = db.prepare("SELECT COALESCE(SUM(length(CAST(payload_json AS BLOB))),0) AS bytes FROM browser_recording_events WHERE recording_id=?").get(id).bytes;
+			for (const event of events) {
+				const prior = db.prepare("SELECT payload_json FROM browser_recording_events WHERE recording_id=? AND seq=?").get(id, event.seq);
+				const serialized = JSON.stringify(event);
+				if (prior) {
+					if (prior.payload_json !== serialized) throw new Error("Recording event conflict.");
+					continue;
+				}
+				bytes += Buffer.byteLength(serialized);
+				if (bytes > 20 * 1024 * 1024) throw new Error("Recording storage budget exceeded.");
+				if (row.state === "saved") throw new Error("Recording is already finished.");
+				if (event.seq !== this.get(id, principalId).ack_seq + 1) throw new Error("Recording event sequence has a gap.");
+				if (!["http:", "https:"].includes(new URL(event.url).protocol)) throw new Error("Only HTTP pages can be recorded.");
+				db.prepare("INSERT INTO browser_recording_events (recording_id, seq, event_id, payload_json) VALUES (?, ?, ?, ?)").run(id, event.seq, event.id, serialized);
+				db.prepare("UPDATE browser_recordings SET ack_seq=?, updated_at_ms=? WHERE recording_id=?").run(event.seq, now, id);
+			}
+			return { ackThrough: this.get(id, principalId).ack_seq };
+		});
+	}
+	finish(id, principalId, finalSeq) {
+		z.number().int().min(1).max(1e4).parse(finalSeq);
+		const row = this.get(id, principalId);
+		if (!row) throw new Error("Recording not found.");
+		if (row.state === "saved") {
+			if (row.final_seq !== finalSeq) throw new Error("Recording final sequence conflicts with the saved recording.");
+			return this.automations.get(row.automation_id);
+		}
+		if (row.ack_seq !== finalSeq) throw new Error("Recording is incomplete. Waiting for all events.");
+		const events = getSqliteDatabase().prepare("SELECT payload_json FROM browser_recording_events WHERE recording_id=? ORDER BY seq").all(id).map((item) => JSON.parse(item.payload_json));
+		const sources = /* @__PURE__ */ new Map();
+		for (const event of events) {
+			if (event.sourceSeq !== (sources.get(event.documentId) ?? 0) + 1) throw new Error("Recording is incomplete: document events are missing.");
+			sources.set(event.documentId, event.sourceSeq);
+		}
+		for (const documentId of sources.keys()) if (events.filter((event) => event.documentId === documentId).at(-1)?.action !== "checkpoint") throw new Error("Recording is incomplete: a document did not confirm its final events.");
+		const definition = compileRecording(id, events);
+		return runSqliteWriteTransaction((db) => {
+			const automation = this.automations.save({ definition });
+			db.prepare("UPDATE browser_recordings SET state='saved', final_seq=?, automation_id=?, updated_at_ms=? WHERE recording_id=?").run(finalSeq, automation.id, Date.now(), id);
+			return automation;
+		});
+	}
+};
+function compileRecording(id, events) {
+	const steps = [];
+	const inputs = {};
+	for (const event of events) {
+		if (event.action === "checkpoint") continue;
+		if (event.action === "unsupported") throw new Error(event.value || "Recording contains an unsupported action.");
+		if (event.action === "navigate") {
+			if (steps.length && ["click", "press"].includes(steps.at(-1).action)) steps.push({
+				action: "wait",
+				condition: "page_idle"
+			});
+			else if (!steps.length || steps.at(-1)?.action !== "wait") steps.push({
+				action: "navigate",
+				url: event.url
+			});
+			continue;
+		}
+		if (!event.target) throw new Error("Recording contains an unsupported target.");
+		if (event.action === "fill" || event.action === "select") {
+			const key = `value${Object.keys(inputs).length + 1}`;
+			inputs[key] = {
+				type: "string",
+				default: event.value ?? "",
+				description: event.target.name || key
+			};
+			steps.push({
+				action: event.action,
+				target: event.target,
+				value: `\${input.${key}}`
+			});
+		} else if (event.action === "check") {
+			if (event.checked === void 0) throw new Error("Recording checkbox state is missing.");
+			steps.push({
+				action: "check",
+				target: event.target,
+				checked: event.checked
+			});
+		} else if (event.action === "press") {
+			if (!event.key) throw new Error("Recording key is missing.");
+			steps.push({
+				action: "press",
+				target: event.target,
+				key: event.key
+			});
+		} else steps.push({
+			action: "click",
+			target: event.target
+		});
+	}
+	if (!steps.length || steps.length > 100) throw new Error("Recording must contain between 1 and 100 executable steps.");
+	const first = events[0];
+	return {
+		id: `recording-${id}`,
+		name: events.find((event) => event.target?.name)?.target?.name || new URL(first.url).hostname,
+		description: "Recorded browser workflow",
+		allowedDomains: [...new Set(events.map((event) => new URL(event.url).hostname))],
+		risk: steps.some((step) => ["click", "press"].includes(step.action)) ? "external_effect" : "draft",
+		inputs,
+		steps,
+		outputs: { url: { field: "url" } }
+	};
+}
+//#endregion
+export { BrowserRecordingService, compileRecording };

package/dist/src/browser/runtime/browser-runtime.d.ts

@@ -18,7 +18,7 @@ export declare class BrowserRuntime {
     closeTaskSession(taskKey: string): Promise<void>;
     private dispatch;
     private executeSequence;
-    private authorize;
+    private actionDenied;
     private validateUrl;
     private validateRedirect;
     private blockedRedirect;