@xopcai/xopc 0.0.368 → 0.0.370

package/dist/src/auth/oauth/openai.js

@@ -0,0 +1,90 @@
+import { __esmMin } from "../../../_virtual/_rolldown/runtime.js";
+import { init_write_file_atomic, writeTextAtomic } from "../../infra/write-file-atomic.js";
+import { init_paths, resolveCredentialsDir } from "../../config/paths.js";
+import { init_oauth_provider_lock, withOAuthProviderLock } from "../oauth-provider-lock.js";
+import { init_register_bundled_oauth_flows, registerBundledOAuthFlows } from "../../providers/register-bundled-oauth-flows.js";
+import { join } from "node:path";
+import { randomUUID } from "node:crypto";
+import { readFile } from "node:fs/promises";
+import { openaiProvider } from "@earendil-works/pi-ai/providers/openai";
+//#region src/auth/oauth/openai.ts
+async function getDeviceId(signal) {
+	return withOAuthProviderLock("openai-device-id", async () => {
+		const path = join(resolveCredentialsDir(), "openai-device-id");
+		try {
+			const id = (await readFile(path, "utf8")).trim();
+			if (!/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(id)) throw new Error("Invalid OpenAI installation device ID");
+			return id;
+		} catch (error) {
+			if (error.code !== "ENOENT") throw error;
+			const id = randomUUID();
+			await writeTextAtomic(path, id);
+			return id;
+		}
+	}, { signal });
+}
+function getOpenaiOAuth() {
+	registerBundledOAuthFlows();
+	const oauth = openaiProvider().auth.oauth;
+	if (!oauth) throw new Error("OpenAI ChatGPT OAuth is unavailable");
+	return oauth;
+}
+function fromPiCredential({ type: _type, ...credentials }) {
+	return credentials;
+}
+function toAuthInteraction(callbacks) {
+	return {
+		signal: callbacks.signal ?? new AbortController().signal,
+		async prompt(prompt) {
+			if (prompt.type === "select") return await callbacks.onSelect({
+				message: prompt.message,
+				options: [...prompt.options]
+			}) ?? "";
+			return callbacks.onPrompt({
+				message: prompt.message,
+				placeholder: prompt.placeholder,
+				signal: prompt.signal
+			});
+		},
+		notify(event) {
+			if (event.type === "auth_url") callbacks.onAuth({
+				url: event.url,
+				instructions: event.instructions
+			});
+			else if (event.type === "device_code") callbacks.onDeviceCode(event);
+			else callbacks.onProgress?.(event.message);
+		}
+	};
+}
+var openaiOAuthProvider;
+var init_openai = __esmMin((() => {
+	init_paths();
+	init_write_file_atomic();
+	init_oauth_provider_lock();
+	init_register_bundled_oauth_flows();
+	openaiOAuthProvider = {
+		id: "openai",
+		name: "OpenAI (ChatGPT subscription)",
+		usesCallbackServer: true,
+		loginMethods: ["browser"],
+		async login(callbacks) {
+			const deviceId = await getDeviceId(callbacks.signal);
+			return fromPiCredential(await getOpenaiOAuth().login(toAuthInteraction(callbacks), {
+				getDeviceId: () => deviceId,
+				agentName: "xopc"
+			}));
+		},
+		async refreshToken(credentials, signal) {
+			return fromPiCredential(await getOpenaiOAuth().refresh({
+				...credentials,
+				type: "oauth"
+			}, signal ?? new AbortController().signal));
+		},
+		getApiKey(credentials) {
+			return credentials.access;
+		}
+	};
+}));
+//#endregion
+init_openai();
+export { init_openai, openaiOAuthProvider };

package/dist/src/auth/oauth/registry.js

@@ -8,7 +8,7 @@ import { init_google_gemini_cli } from "./google-gemini-cli.js";
 import { init_kimi_coding, kimiCodingOAuthProvider } from "./kimi-coding.js";
 import { init_minimax_cn, minimaxCnOAuthProvider } from "./minimax-cn.js";
 import { init_minimax, minimaxOAuthProvider } from "./minimax.js";
-import { init_openai_codex, openaiCodexOAuthProvider } from "./openai-codex.js";
+import { init_openai, openaiOAuthProvider } from "./openai.js";
 import { init_xopc_cloud, xopcCloudOAuthProvider, xopcShareOAuthProvider, xopcTunnelOAuthProvider } from "./xopc-cloud.js";
 //#region src/auth/oauth/registry.ts
 function definition(provider, purpose, displayName = provider.name) {
@@ -44,7 +44,7 @@ var init_registry = __esmMin((() => {
 	init_kimi_coding();
 	init_minimax_cn();
 	init_minimax();
-	init_openai_codex();
+	init_openai();
 	init_xopc_cloud();
 	OAUTH_PROVIDER_DEFINITIONS = {
 		"xopc-cloud": {
@@ -69,7 +69,7 @@ var init_registry = __esmMin((() => {
 		"github-copilot": definition(githubCopilotOAuthProvider, "models"),
 		"google-gemini-cli": definition(geminiCliOAuthProvider, "models"),
 		"google-antigravity": definition(antigravityOAuthProvider, "models"),
-		"openai-codex": definition(openaiCodexOAuthProvider, "models")
+		openai: definition(openaiOAuthProvider, "models")
 	};
 }));
 //#endregion

package/dist/src/auth/oauth/types.d.ts

@@ -15,6 +15,7 @@ export type OAuthPrompt = {
     message: string;
     placeholder?: string;
     allowEmpty?: boolean;
+    signal?: AbortSignal;
 };
 export type OAuthAuthInfo = {
     url: string;

package/dist/src/auth/oauth/xopc-cloud.js

@@ -3,8 +3,8 @@ import { generatePKCE, init_pkce } from "./pkce.js";
 import { init_resolution, resolveConnectedPlatformEndpoint } from "../../platform/resolution.js";
 import { hostname } from "node:os";
 import { randomBytes } from "node:crypto";
-import http from "node:http";
 import { setTimeout as setTimeout$1 } from "node:timers/promises";
+import http from "node:http";
 //#region src/auth/oauth/xopc-cloud.ts
 function consoleUrl() {
 	return (process.env.XOPC_CONSOLE_URL ?? resolveConnectedPlatformEndpoint("authorizationServer") ?? DEFAULT_CONSOLE_URL).replace(/\/+$/, "");

package/dist/src/auth/sync-provider-auth.js

@@ -1,6 +1,7 @@
 import { __esmMin } from "../../_virtual/_rolldown/runtime.js";
 import { init_paths, resolveAgentAuthProfilesPath, resolveAuthProfilesPath, resolveOAuthPath } from "../config/paths.js";
 import { init_registry, isOAuthOnlyProvider } from "./oauth/registry.js";
+import { assertCurrentModelProvider, init_provider_policy } from "../providers/provider-policy.js";
 import { getDefaultAgentId, init_resolve_route } from "../routing/resolve-route.js";
 import { existsSync, readFileSync } from "node:fs";
 //#region src/auth/sync-provider-auth.ts
@@ -81,6 +82,7 @@ function readOAuthAccessTokenSync(provider) {
 */
 function resolveProviderApiKeySync(provider) {
 	const normalized = provider.toLowerCase();
+	assertCurrentModelProvider(normalized);
 	if (isOAuthOnlyProvider(normalized)) return readOAuthAccessTokenSync(normalized);
 	const fromAgent = readApiKeyFromProfilesFile(resolveAgentAuthProfilesPath(getDefaultAgentId()), normalized);
 	if (fromAgent) return fromAgent;
@@ -91,6 +93,7 @@ function resolveProviderApiKeySync(provider) {
 /** Resolve one agent's private credential, then the shared credential and OAuth token. */
 function resolveProviderApiKeyForAgentSync(provider, agentId, _config) {
 	const normalized = provider.toLowerCase();
+	assertCurrentModelProvider(normalized);
 	if (isOAuthOnlyProvider(normalized)) return readOAuthAccessTokenSync(normalized);
 	if (agentId?.trim()) {
 		const fromAgent = readApiKeyFromProfilesFile(resolveAgentAuthProfilesPath(agentId.trim()), normalized);
@@ -105,6 +108,7 @@ function resolveProviderApiKeyForAgentSync(provider, agentId, _config) {
 * matching async CredentialResolver resolution (excluding env — callers check env separately).
 */
 function hasProviderAuthOnDiskSync(provider) {
+	assertCurrentModelProvider(provider.toLowerCase());
 	if (isOAuthOnlyProvider(provider.toLowerCase())) return hasOAuthTokenSync(provider);
 	if (hasApiKeyInProfilesFile(resolveAgentAuthProfilesPath(getDefaultAgentId()), provider)) return true;
 	if (hasApiKeyInProfilesFile(resolveAuthProfilesPath(), provider)) return true;
@@ -114,6 +118,7 @@ function hasProviderAuthOnDiskSync(provider) {
 var init_sync_provider_auth = __esmMin((() => {
 	init_paths();
 	init_resolve_route();
+	init_provider_policy();
 	init_registry();
 }));
 //#endregion

package/dist/src/automations/capabilities/write.d.ts

@@ -31,6 +31,7 @@ export declare const AutomationCreateCapabilityInputSchema: z.ZodObject<{
     }, z.core.$strict>, z.ZodObject<{
         kind: z.ZodLiteral<"browser_automation">;
         automationId: z.ZodString;
+        revision: z.ZodOptional<z.ZodNumber>;
         inputs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
         timeoutSeconds: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strict>, z.ZodObject<{
@@ -231,6 +232,7 @@ export declare const AutomationUpdatePatchSchema: z.ZodObject<{
     }, z.core.$strict>, z.ZodObject<{
         kind: z.ZodLiteral<"browser_automation">;
         automationId: z.ZodString;
+        revision: z.ZodOptional<z.ZodNumber>;
         inputs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
         timeoutSeconds: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strict>, z.ZodObject<{

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

@@ -48,6 +48,7 @@ export type AutomationAction = {
 } | {
     kind: 'browser_automation';
     automationId: string;
+    revision?: number;
     inputs?: Record<string, unknown>;
     timeoutSeconds?: number;
 } | {
@@ -342,8 +343,18 @@ export interface AutomationDeps {
     prepareAgentSession?: (input: PrepareAutomationAgentSessionInput) => Promise<void>;
     workflowRunService?: WorkflowRunServiceLike;
     browserAutomationService?: {
+        get(id: string): {
+            revision: number;
+            verified: boolean;
+        } | null;
+        versions(id: string): {
+            revision: number;
+            verified: boolean;
+        }[];
         runAndWait(automationId: string, inputs: Record<string, unknown>, signal?: AbortSignal, context?: {
             triggerEvent?: AutomationEvent;
+            revision?: number;
+            clientRequestId?: string;
         }): Promise<{
             id: string;
             status: 'queued' | 'running' | 'succeeded' | 'failed' | 'cancelled';

package/dist/src/automations/domain/validation.d.ts

@@ -61,6 +61,7 @@ export declare const AutomationActionSchema: z.ZodDiscriminatedUnion<[z.ZodObjec
 }, z.core.$strict>, z.ZodObject<{
     kind: z.ZodLiteral<"browser_automation">;
     automationId: z.ZodString;
+    revision: z.ZodOptional<z.ZodNumber>;
     inputs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     timeoutSeconds: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strict>, z.ZodObject<{
@@ -281,6 +282,7 @@ export declare const AutomationSchema: z.ZodObject<{
     }, z.core.$strict>, z.ZodObject<{
         kind: z.ZodLiteral<"browser_automation">;
         automationId: z.ZodString;
+        revision: z.ZodOptional<z.ZodNumber>;
         inputs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
         timeoutSeconds: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strict>, z.ZodObject<{
@@ -480,6 +482,7 @@ export declare const CreateAutomationSchema: z.ZodObject<{
     }, z.core.$strict>, z.ZodObject<{
         kind: z.ZodLiteral<"browser_automation">;
         automationId: z.ZodString;
+        revision: z.ZodOptional<z.ZodNumber>;
         inputs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
         timeoutSeconds: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strict>, z.ZodObject<{
@@ -706,6 +709,7 @@ export declare const UpdateAutomationSchema: z.ZodObject<{
     }, z.core.$strict>, z.ZodObject<{
         kind: z.ZodLiteral<"browser_automation">;
         automationId: z.ZodString;
+        revision: z.ZodOptional<z.ZodNumber>;
         inputs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
         timeoutSeconds: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strict>, z.ZodObject<{

package/dist/src/automations/domain/validation.js

@@ -95,6 +95,7 @@ const AutomationActionSchema = z.discriminatedUnion("kind", [
 	z.object({
 		kind: z.literal("browser_automation"),
 		automationId: nonEmptyString.max(100),
+		revision: z.number().int().positive().optional(),
 		inputs: z.record(z.string(), z.unknown()).optional(),
 		timeoutSeconds: z.number().int().min(1).max(86400).optional()
 	}).strict(),

package/dist/src/automations/draft/automation-draft-validator.d.ts

@@ -60,6 +60,7 @@ export declare function buildAutomationDraftResponse(draft: GeneratedAutomationD
         } | {
             kind: "browser_automation";
             automationId: string;
+            revision?: number;
             inputs?: Record<string, unknown>;
             timeoutSeconds?: number;
         } | {

package/dist/src/automations/service/action-executor.js

@@ -77,7 +77,7 @@ var AutomationActionExecutor = class {
 			mode: "idempotent",
 			key: "run_id"
 		}, (input, action) => this.executeWorkflow(input.automation, action, input.run, input.signal, input.hooks, input.context));
-		this.register("browser_automation", { mode: "never" }, (input, action) => this.executeBrowserAutomation(input.automation, action, input.signal, input.hooks, input.context));
+		this.register("browser_automation", { mode: "never" }, (input, action) => this.executeBrowserAutomation(input.automation, action, input.signal, input.hooks, input.context, input.run.id));
 		this.register("task_command", {
 			mode: "idempotent",
 			key: "run_id"
@@ -186,7 +186,7 @@ var AutomationActionExecutor = class {
 			})).summary ?? "System action completed"
 		};
 	}
-	async executeBrowserAutomation(automation, action, signal, hooks, context) {
+	async executeBrowserAutomation(automation, action, signal, hooks, context, executionRunId) {
 		await hooks.onRunPatch?.({ currentPhase: "action" });
 		const safetyMode = automation.safety?.mode ?? "auto_apply";
 		if (safetyMode !== "auto_apply") return {
@@ -198,7 +198,15 @@ var AutomationActionExecutor = class {
 			status: "failed",
 			error: "Browser automation is not available"
 		};
-		const run = context.triggerEvent ? await service.runAndWait(action.automationId, action.inputs ?? {}, signal, { triggerEvent: context.triggerEvent }) : await service.runAndWait(action.automationId, action.inputs ?? {}, signal);
+		if (action.revision === void 0 || !service.versions(action.automationId).some((item) => item.revision === action.revision && item.verified)) return {
+			status: "failed",
+			error: "The scheduled browser automation version has not been verified."
+		};
+		const run = await service.runAndWait(action.automationId, action.inputs ?? {}, signal, {
+			revision: action.revision,
+			clientRequestId: `schedule:${executionRunId}:${action.revision}`,
+			...context.triggerEvent ? { triggerEvent: context.triggerEvent } : {}
+		});
 		if (run.status === "succeeded") return {
 			status: "succeeded",
 			summary: `Browser automation ${action.automationId} completed: ${JSON.stringify(run.result ?? null).slice(0, 3500)}`

package/dist/src/automations/service/automation-service.d.ts

@@ -31,6 +31,7 @@ export declare class AutomationService {
     /** SQLite-only creation; scheduling starts after the caller commits. */
     createAtomically(input: CreateAutomationInput): Automation;
     private applyCreate;
+    private pinBrowserVersion;
     list(options?: {
         projectId?: string;
     }): Promise<Automation[]>;

package/dist/src/automations/service/automation-service.js

@@ -114,12 +114,23 @@ var AutomationService = class {
 			createdAtMs: now,
 			updatedAtMs: now
 		});
+		this.pinBrowserVersion(automation);
 		if (getAutomation(automation.id)) throw new AutomationAlreadyExistsError(automation.id);
 		automation.updatedAtMs = Math.max(automation.updatedAtMs, (getDeletedAutomationRevision(automation.id) ?? -1) + 1);
 		automation.state.nextRunAtMs = computeNextAutomationRunAtMs(automation, now);
 		saveAutomation(automation);
 		return automation;
 	}
+	pinBrowserVersion(automation) {
+		if (automation.action.kind !== "browser_automation") return;
+		const browser = this.deps.browserAutomationService;
+		if (!browser) throw new Error("Browser automation service is unavailable.");
+		const action = automation.action;
+		const version = action.revision === void 0 ? browser.get(action.automationId) : browser.versions(action.automationId).find((item) => item.revision === action.revision);
+		if (!version) throw new Error("Browser automation version not found.");
+		if (automation.enabled && !version.verified) throw new Error("Run and verify this browser automation before scheduling it.");
+		action.revision = version.revision;
+	}
 	async list(options) {
 		return listAutomations(options);
 	}
@@ -154,6 +165,7 @@ var AutomationService = class {
 				...parsed.state ?? {}
 			}
 		});
+		this.pinBrowserVersion(next);
 		if ("enabled" in parsed || "trigger" in parsed) next.state.nextRunAtMs = computeNextAutomationRunAtMs(next, now);
 		saveAutomation(next);
 		return next;
@@ -559,7 +571,7 @@ var AutomationService = class {
 		let artifacts;
 		const triggerEvent = listAutomationRunEvents(run.id).map(readAutomationEventFromRunEvent).find((item) => item !== null);
 		try {
-			const maxAttempts = Math.max(1, (automation.reliability?.retryCount ?? 0) + 1);
+			const maxAttempts = automation.action.kind === "browser_automation" ? 1 : Math.max(1, (automation.reliability?.retryCount ?? 0) + 1);
 			let task;
 			for (let attempt = 1;; attempt += 1) {
 				run = {

package/dist/src/bootstrap/application-state.js

@@ -2,9 +2,9 @@ import { requireXopcDatabase } from "../storage/sqlite/connection.js";
 import { init_sqlite } from "../storage/sqlite/index.js";
 import { AgentCatalogService } from "../agent-catalog/service.js";
 import { ensureStarterAgentsInitialized } from "../agent/starter-agents.js";
-import { migrateIdentityMarkdownToCatalog } from "../agent-catalog/migrations/identity-markdown-cutover.js";
 import { cutoverLegacyAgentConfig } from "../agent-catalog/migrations/legacy-config-cutover.js";
 import "../agent-catalog/index.js";
+import { migrateIdentityMarkdownToCatalog } from "../agent-catalog/migrations/identity-markdown-cutover.js";
 import { migrateCloudPublicModelsSync } from "../migrations/cloud-public-models.js";
 import { runBootstrapMigrationsSync } from "../migrations/runner.js";
 //#region src/bootstrap/application-state.ts

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

@@ -2,6 +2,10 @@ import type { BrowserAutomation, BrowserAutomationRun, BrowserAutomationRunEvent
 export declare const listBrowserAutomations: () => BrowserAutomation[];
 export declare const getBrowserAutomation: (id: string) => BrowserAutomation | null;
 export declare function saveBrowserAutomation(value: BrowserAutomation): void;
+export declare function getBrowserAutomationVersion(id: string, revision: number): BrowserAutomation | null;
+export declare function listBrowserAutomationVersions(id: string): BrowserAutomation[];
+export declare function verifyBrowserAutomationRun(run: BrowserAutomationRun): void;
+export declare function findBrowserAutomationRunByRequest(requestId: string): BrowserAutomationRun | null;
 export declare const deleteBrowserAutomation: (id: string) => boolean;
 export declare function saveBrowserAutomationRun(value: BrowserAutomationRun): void;
 export declare const getBrowserAutomationRun: (id: string) => BrowserAutomationRun | null;

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

@@ -2,9 +2,10 @@ import { getSqliteDatabase, runSqliteWriteTransaction } from "../../storage/sqli
 import { init_sqlite } from "../../storage/sqlite/index.js";
 //#region src/browser/automations/repository.ts
 init_sqlite();
-const AUTOMATION_SELECT = "SELECT automation_id, revision, status, definition_json, created_at_ms, updated_at_ms FROM browser_automations";
-const RUN_SELECT = "SELECT run_id, automation_id, automation_revision, definition_json, status, inputs_json, result_json, error, created_at_ms, started_at_ms, ended_at_ms, duration_ms FROM browser_automation_runs";
+const AUTOMATION_SELECT = "SELECT a.*, EXISTS(SELECT 1 FROM browser_automation_verifications v WHERE v.automation_id=a.automation_id AND v.revision=a.revision) AS verified FROM browser_automations a";
+const RUN_SELECT = "SELECT client_request_id, business_outcome, run_id, automation_id, automation_revision, definition_json, status, inputs_json, result_json, error, created_at_ms, started_at_ms, ended_at_ms, duration_ms FROM browser_automation_runs";
 const parseAutomation = (row) => ({
+	verified: !!row.verified,
 	id: row.automation_id,
 	revision: row.revision,
 	status: row.status,
@@ -13,6 +14,8 @@ const parseAutomation = (row) => ({
 	updatedAtMs: row.updated_at_ms
 });
 const parseRun = (row) => ({
+	clientRequestId: row.client_request_id ?? void 0,
+	businessOutcome: row.business_outcome ?? void 0,
 	id: row.run_id,
 	automationId: row.automation_id,
 	automationRevision: row.automation_revision,
@@ -28,15 +31,33 @@ const parseRun = (row) => ({
 });
 const listBrowserAutomations = () => getSqliteDatabase().prepare(`${AUTOMATION_SELECT} ORDER BY updated_at_ms DESC`).all().map(parseAutomation);
 const getBrowserAutomation = (id) => {
-	const row = getSqliteDatabase().prepare(`${AUTOMATION_SELECT} WHERE automation_id = ?`).get(id);
+	const row = getSqliteDatabase().prepare(`${AUTOMATION_SELECT} WHERE a.automation_id = ?`).get(id);
 	return row ? parseAutomation(row) : null;
 };
 function saveBrowserAutomation(value) {
-	runSqliteWriteTransaction((db) => db.prepare("INSERT INTO browser_automations (automation_id, revision, status, definition_json, created_at_ms, updated_at_ms) VALUES (?, ?, ?, ?, ?, ?) ON CONFLICT(automation_id) DO UPDATE SET revision=excluded.revision, status=excluded.status, definition_json=excluded.definition_json, updated_at_ms=excluded.updated_at_ms").run(value.id, value.revision, value.status, JSON.stringify(value.definition), value.createdAtMs, value.updatedAtMs));
+	runSqliteWriteTransaction((db) => {
+		db.prepare("INSERT INTO browser_automations (automation_id, revision, status, definition_json, created_at_ms, updated_at_ms) VALUES (?, ?, ?, ?, ?, ?) ON CONFLICT(automation_id) DO UPDATE SET revision=excluded.revision, status=excluded.status, definition_json=excluded.definition_json, updated_at_ms=excluded.updated_at_ms").run(value.id, value.revision, value.status, JSON.stringify(value.definition), value.createdAtMs, value.updatedAtMs);
+		db.prepare("INSERT OR IGNORE INTO browser_automation_versions (automation_id, revision, definition_json, created_at_ms) VALUES (?, ?, ?, ?)").run(value.id, value.revision, JSON.stringify(value.definition), value.updatedAtMs);
+	});
+}
+function getBrowserAutomationVersion(id, revision) {
+	const row = getSqliteDatabase().prepare("SELECT v.*, a.status, a.created_at_ms, v.created_at_ms AS updated_at_ms, EXISTS(SELECT 1 FROM browser_automation_verifications p WHERE p.automation_id=v.automation_id AND p.revision=v.revision) AS verified FROM browser_automation_versions v JOIN browser_automations a USING(automation_id) WHERE v.automation_id=? AND v.revision=?").get(id, revision);
+	return row ? parseAutomation(row) : null;
+}
+function listBrowserAutomationVersions(id) {
+	return getSqliteDatabase().prepare("SELECT revision FROM browser_automation_versions WHERE automation_id=? ORDER BY revision DESC").all(id).map((row) => getBrowserAutomationVersion(id, row.revision));
+}
+function verifyBrowserAutomationRun(run) {
+	if (run.status !== "succeeded" || run.businessOutcome !== "verified") return;
+	runSqliteWriteTransaction((db) => db.prepare("INSERT INTO browser_automation_verifications (automation_id, revision, run_id, verified_at_ms) VALUES (?, ?, ?, ?) ON CONFLICT(automation_id, revision) DO UPDATE SET run_id=excluded.run_id, verified_at_ms=excluded.verified_at_ms").run(run.automationId, run.automationRevision, run.id, run.endedAtMs));
+}
+function findBrowserAutomationRunByRequest(requestId) {
+	const row = getSqliteDatabase().prepare(`${RUN_SELECT} WHERE client_request_id=?`).get(requestId);
+	return row ? parseRun(row) : null;
 }
 const deleteBrowserAutomation = (id) => runSqliteWriteTransaction((db) => db.prepare("DELETE FROM browser_automations WHERE automation_id = ?").run(id).changes > 0);
 function saveBrowserAutomationRun(value) {
-	runSqliteWriteTransaction((db) => db.prepare("INSERT INTO browser_automation_runs (run_id, automation_id, automation_revision, definition_json, status, inputs_json, result_json, error, created_at_ms, started_at_ms, ended_at_ms, duration_ms) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) ON CONFLICT(run_id) DO UPDATE SET status=excluded.status, result_json=excluded.result_json, error=excluded.error, started_at_ms=excluded.started_at_ms, ended_at_ms=excluded.ended_at_ms, duration_ms=excluded.duration_ms").run(value.id, value.automationId, value.automationRevision, JSON.stringify(value.definition), value.status, JSON.stringify(value.inputs), value.result === void 0 ? null : JSON.stringify(value.result), value.error ?? null, value.createdAtMs, value.startedAtMs ?? null, value.endedAtMs ?? null, value.durationMs ?? null));
+	runSqliteWriteTransaction((db) => db.prepare("INSERT INTO browser_automation_runs (run_id, automation_id, automation_revision, definition_json, status, inputs_json, result_json, error, created_at_ms, started_at_ms, ended_at_ms, duration_ms, client_request_id, business_outcome) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) ON CONFLICT(run_id) DO UPDATE SET status=excluded.status, result_json=excluded.result_json, error=excluded.error, started_at_ms=excluded.started_at_ms, ended_at_ms=excluded.ended_at_ms, duration_ms=excluded.duration_ms, business_outcome=excluded.business_outcome").run(value.id, value.automationId, value.automationRevision, JSON.stringify(value.definition), value.status, JSON.stringify(value.inputs), value.result === void 0 ? null : JSON.stringify(value.result), value.error ?? null, value.createdAtMs, value.startedAtMs ?? null, value.endedAtMs ?? null, value.durationMs ?? null, value.clientRequestId ?? null, value.businessOutcome ?? null));
 }
 const getBrowserAutomationRun = (id) => {
 	const row = getSqliteDatabase().prepare(`${RUN_SELECT} WHERE run_id = ?`).get(id);
@@ -58,4 +79,4 @@ const listBrowserAutomationRunEvents = (runId) => getSqliteDatabase().prepare("S
 	createdAtMs: row.created_at_ms
 }));
 //#endregion
-export { appendBrowserAutomationRunEvent, deleteBrowserAutomation, getBrowserAutomation, getBrowserAutomationRun, hasActiveBrowserAutomationRuns, listActiveBrowserAutomationRuns, listBrowserAutomationRunEvents, listBrowserAutomationRuns, listBrowserAutomations, nextBrowserAutomationRunEventSeq, saveBrowserAutomation, saveBrowserAutomationRun };
+export { appendBrowserAutomationRunEvent, deleteBrowserAutomation, findBrowserAutomationRunByRequest, getBrowserAutomation, getBrowserAutomationRun, getBrowserAutomationVersion, hasActiveBrowserAutomationRuns, listActiveBrowserAutomationRuns, listBrowserAutomationRunEvents, listBrowserAutomationRuns, listBrowserAutomationVersions, listBrowserAutomations, nextBrowserAutomationRunEventSeq, saveBrowserAutomation, saveBrowserAutomationRun, verifyBrowserAutomationRun };

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

@@ -30,6 +30,26 @@ async function runBrowserAutomation(input) {
 				sessionId = observation?.sessionId;
 			}
 			if (step.action === "navigate") assertAllowedDomain(input.definition.allowedDomains, render(step.url, values));
+			if ("target" in step && step.target) {
+				const resolved = await input.runtime.execute(input.taskKey, {
+					action: "resolve",
+					sessionId,
+					semanticTarget: step.target
+				}, input.signal);
+				if (!resolved.ok) {
+					input.onStep({
+						index,
+						action: step.action,
+						status: "failed",
+						result: resolved
+					});
+					return resolved;
+				}
+				observation = resolved.receipt.observation;
+				sessionId = observation?.sessionId ?? sessionId;
+			}
+			if (observation) assertAllowedDomain(input.definition.allowedDomains, observation.url);
+			if (step.action === "click" && observation?.nodes[0]?.href) assertAllowedDomain(input.definition.allowedDomains, observation.nodes[0].href);
 			const action = buildAction(step, values, observation, sessionId);
 			const result = await input.runtime.execute(input.taskKey, action, input.signal);
 			if (!result.ok) {
@@ -43,7 +63,7 @@ async function runBrowserAutomation(input) {
 			}
 			observation = result.receipt.observation ?? observation;
 			sessionId = observation?.sessionId ?? sessionId;
-			if (step.action === "navigate") assertAllowedDomain(input.definition.allowedDomains, observation?.url ?? render(step.url, values));
+			if (observation) assertAllowedDomain(input.definition.allowedDomains, observation.url);
 			input.onStep({
 				index,
 				action: step.action,
@@ -61,16 +81,80 @@ async function runBrowserAutomation(input) {
 			return result;
 		}
 	}
-	return {
-		ok: true,
-		receipt: {
-			action: "sequence",
-			risk: input.definition.risk,
-			durationMs: Date.now() - startedAt,
-			verified: true,
-			observation
+	const readField = async (spec) => {
+		if (spec.target) {
+			const result = await input.runtime.execute(input.taskKey, {
+				action: "resolve",
+				sessionId,
+				semanticTarget: spec.target
+			}, input.signal);
+			if (!result.ok) return void 0;
+			observation = result.receipt.observation;
+		} else {
+			const result = await input.runtime.execute(input.taskKey, {
+				action: "observe",
+				sessionId,
+				visual: "never"
+			}, input.signal);
+			if (!result.ok) return void 0;
+			observation = result.receipt.observation;
 		}
+		if (!observation) return void 0;
+		assertAllowedDomain(input.definition.allowedDomains, observation.url);
+		const node = observation.nodes[0];
+		if (spec.field === "url") return observation.url;
+		if (spec.field === "title") return observation.title;
+		if (spec.field === "checked") return node?.states.includes("checked");
+		if (spec.field === "text") return node?.description ?? node?.name;
+		return node?.[spec.field];
 	};
+	try {
+		for (const assertion of input.definition.successCriteria ?? []) {
+			const deadline = Date.now() + 1e4;
+			let passed = false;
+			do {
+				if (input.signal.aborted) return automationFailure("INVALID_INPUT", "Run cancelled.", observation);
+				const actual = await readField(assertion);
+				passed = assertion.equals !== void 0 ? actual === (typeof assertion.equals === "string" ? render(assertion.equals, values) : assertion.equals) : typeof actual === "string" && actual.includes(render(assertion.includes, values));
+				if (!passed) await new Promise((resolve) => setTimeout(resolve, 200));
+			} while (!passed && Date.now() < deadline);
+			if (!passed) return {
+				ok: false,
+				error: {
+					code: "EXPECTATION_FAILED",
+					message: "The business result did not match its success criteria.",
+					observation
+				}
+			};
+		}
+		const outputs = {};
+		for (const [name, spec] of Object.entries(input.definition.outputs ?? {})) {
+			const value = await readField(spec);
+			if (typeof value !== "string" || !value) return {
+				ok: false,
+				error: {
+					code: "EXPECTATION_FAILED",
+					message: `Output ${name} is unavailable.`,
+					observation
+				}
+			};
+			outputs[name] = value;
+		}
+		return {
+			ok: true,
+			receipt: {
+				action: "sequence",
+				risk: input.definition.risk,
+				durationMs: Date.now() - startedAt,
+				verified: !!input.definition.successCriteria?.length,
+				businessOutcome: input.definition.successCriteria?.length ? "verified" : "completed",
+				outputs,
+				observation
+			}
+		};
+	} catch (error) {
+		return automationFailure("BLOCKED_URL", error, observation);
+	}
 }
 function buildAction(step, inputs, observation, sessionId) {
 	if (step.action === "navigate") return {
@@ -98,6 +182,13 @@ function buildAction(step, inputs, observation, sessionId) {
 			submit: step.submit,
 			expect: step.expect
 		};
+		case "check": return {
+			action: "check",
+			sessionId,
+			revision,
+			ref,
+			checked: step.checked
+		};
 		case "select": return {
 			action: "select",
 			sessionId,
@@ -149,6 +240,7 @@ function resolveBrowserAutomationInputs(definition, provided) {
 	for (const [name, spec] of Object.entries(definition.inputs)) {
 		const value = values[name] ?? spec.default;
 		if (value === void 0 && spec.required) throw new Error(`Missing required automation input: ${name}`);
+		if (value !== void 0 && spec.choices && !spec.choices.includes(value)) throw new Error(`Automation input ${name} is not an allowed choice.`);
 		if (value !== void 0 && typeof value !== spec.type) throw new Error(`Automation input ${name} must be ${spec.type}.`);
 		if (values[name] === void 0 && value !== void 0) values[name] = value;
 	}

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

@@ -10,8 +10,8 @@ function createRuntimeBrowserAutomationService(deps) {
 		allowedUploadRoots: [process.cwd()],
 		emit: deps.emit
 	});
-	return new BrowserAutomationService(async ({ definition, inputs, signal, onStep }) => {
-		const taskKey = `browser-automation:${crypto.randomUUID()}`;
+	return new BrowserAutomationService(async ({ runId, definition, inputs, signal, onStep }) => {
+		const taskKey = `browser-automation:${runId}`;
 		try {
 			const result = await runBrowserAutomation({
 				definition,
@@ -23,7 +23,8 @@ function createRuntimeBrowserAutomationService(deps) {
 			});
 			return result.ok ? {
 				ok: true,
-				result: result.receipt
+				result: result.receipt.outputs ?? {},
+				businessOutcome: result.receipt.businessOutcome
 			} : {
 				ok: false,
 				error: "error" in result ? result.error.message : "Browser automation failed."