@xopcai/xopc 0.0.251 → 0.0.252

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

@@ -2,7 +2,7 @@
 const DEFAULT_AUTOMATION_TIMEOUT_SECONDS = 1800;
 const DEFAULT_BROWSER_AUTOMATION_TIMEOUT_SECONDS = 600;
 function defaultAutomationTimeoutSeconds(action) {
-	return action.kind === "browser_recipe" ? 600 : DEFAULT_AUTOMATION_TIMEOUT_SECONDS;
+	return action.kind === "browser_automation" ? 600 : DEFAULT_AUTOMATION_TIMEOUT_SECONDS;
 }
 function resolveAutomationTimeoutSeconds(action, reliability) {
 	return reliability?.executionTimeoutSeconds ?? ("timeoutSeconds" in action ? action.timeoutSeconds : void 0) ?? reliability?.timeoutSeconds ?? defaultAutomationTimeoutSeconds(action);

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

@@ -46,9 +46,9 @@ export type AutomationAction = {
     maxSubagents?: number;
     timeoutSeconds?: number;
 } | {
-    kind: 'browser_recipe';
-    recipeId: string;
-    args?: Record<string, unknown>;
+    kind: 'browser_automation';
+    automationId: string;
+    inputs?: Record<string, unknown>;
     timeoutSeconds?: number;
 } | {
     kind: 'task_command';
@@ -189,8 +189,8 @@ export interface AutomationDeps {
     getDefaultAgentId?: () => string;
     prepareAgentSession?: (input: PrepareAutomationAgentSessionInput) => Promise<void>;
     workflowRunService?: WorkflowRunServiceLike;
-    browserRecipeService?: {
-        runAndWait(recipeId: string, args: Record<string, unknown>, signal?: AbortSignal): Promise<{
+    browserAutomationService?: {
+        runAndWait(automationId: string, inputs: Record<string, unknown>, signal?: AbortSignal): Promise<{
             id: string;
             status: 'queued' | 'running' | 'succeeded' | 'failed' | 'cancelled';
             result?: unknown;

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

@@ -59,9 +59,9 @@ export declare const AutomationActionSchema: z.ZodDiscriminatedUnion<[z.ZodObjec
     maxSubagents: z.ZodOptional<z.ZodNumber>;
     timeoutSeconds: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strict>, z.ZodObject<{
-    kind: z.ZodLiteral<"browser_recipe">;
-    recipeId: z.ZodString;
-    args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    kind: z.ZodLiteral<"browser_automation">;
+    automationId: z.ZodString;
+    inputs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     timeoutSeconds: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strict>, z.ZodObject<{
     kind: z.ZodLiteral<"task_command">;
@@ -236,9 +236,9 @@ export declare const AutomationSchema: z.ZodObject<{
         maxSubagents: z.ZodOptional<z.ZodNumber>;
         timeoutSeconds: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strict>, z.ZodObject<{
-        kind: z.ZodLiteral<"browser_recipe">;
-        recipeId: z.ZodString;
-        args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        kind: z.ZodLiteral<"browser_automation">;
+        automationId: z.ZodString;
+        inputs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
         timeoutSeconds: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strict>, z.ZodObject<{
         kind: z.ZodLiteral<"task_command">;
@@ -398,9 +398,9 @@ export declare const CreateAutomationSchema: z.ZodObject<{
         maxSubagents: z.ZodOptional<z.ZodNumber>;
         timeoutSeconds: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strict>, z.ZodObject<{
-        kind: z.ZodLiteral<"browser_recipe">;
-        recipeId: z.ZodString;
-        args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        kind: z.ZodLiteral<"browser_automation">;
+        automationId: z.ZodString;
+        inputs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
         timeoutSeconds: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strict>, z.ZodObject<{
         kind: z.ZodLiteral<"task_command">;
@@ -587,9 +587,9 @@ export declare const UpdateAutomationSchema: z.ZodObject<{
         maxSubagents: z.ZodOptional<z.ZodNumber>;
         timeoutSeconds: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strict>, z.ZodObject<{
-        kind: z.ZodLiteral<"browser_recipe">;
-        recipeId: z.ZodString;
-        args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        kind: z.ZodLiteral<"browser_automation">;
+        automationId: z.ZodString;
+        inputs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
         timeoutSeconds: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strict>, z.ZodObject<{
         kind: z.ZodLiteral<"task_command">;

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

@@ -83,9 +83,9 @@ const AutomationActionSchema = z.discriminatedUnion("kind", [
 		timeoutSeconds: z.number().int().min(1).max(86400).optional()
 	}).strict(),
 	z.object({
-		kind: z.literal("browser_recipe"),
-		recipeId: nonEmptyString.max(100),
-		args: z.record(z.string(), z.unknown()).optional(),
+		kind: z.literal("browser_automation"),
+		automationId: nonEmptyString.max(100),
+		inputs: z.record(z.string(), z.unknown()).optional(),
 		timeoutSeconds: z.number().int().min(1).max(86400).optional()
 	}).strict(),
 	z.object({

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

@@ -37,9 +37,9 @@ export declare function buildAutomationDraftResponse(draft: GeneratedAutomationD
             maxSubagents?: number;
             timeoutSeconds?: number;
         } | {
-            kind: "browser_recipe";
-            recipeId: string;
-            args?: Record<string, unknown>;
+            kind: "browser_automation";
+            automationId: string;
+            inputs?: Record<string, unknown>;
             timeoutSeconds?: number;
         } | {
             kind: "task_command";

package/dist/src/automations/draft/automation-draft-validator.js

@@ -90,7 +90,7 @@ function summarizeTrigger(trigger) {
 }
 function summarizeAction(action) {
 	if (action.kind === "workflow") return `Starts workflow ${action.workflowId}.`;
-	if (action.kind === "browser_recipe") return `Runs browser automation ${action.recipeId}.`;
+	if (action.kind === "browser_automation") return `Runs browser automation ${action.automationId}.`;
 	if (action.kind === "task_command") return `Applies ${action.command?.type ?? "a command"} to task ${action.taskId}.`;
 	return action.agentId ? `Runs agent ${action.agentId}.` : "Runs the default agent.";
 }

package/dist/src/automations/service/action-executor.d.ts

@@ -4,7 +4,7 @@ export declare class AutomationActionExecutor {
     setDeps(deps: AutomationDeps): void;
     execute(automation: Automation, run: AutomationRun, signal: AbortSignal, hooks?: AutomationActionExecutionHooks): Promise<AutomationActionTask>;
     private executeWithoutTimeout;
-    private executeBrowserRecipe;
+    private executeBrowserAutomation;
     private executeAgent;
     private executeWorkflow;
 }

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

@@ -105,7 +105,7 @@ var AutomationActionExecutor = class {
 			error: "Automation run was cancelled"
 		};
 		if (automation.action.kind === "workflow") return this.executeWorkflow(automation, automation.action, run, signal, hooks);
-		if (automation.action.kind === "browser_recipe") return this.executeBrowserRecipe(automation, automation.action, signal, hooks);
+		if (automation.action.kind === "browser_automation") return this.executeBrowserAutomation(automation, automation.action, signal, hooks);
 		if (automation.action.kind === "task_command") {
 			await hooks.onRunPatch?.({ currentPhase: "action" });
 			const execute = this.deps.executeTaskCommand;
@@ -128,26 +128,26 @@ var AutomationActionExecutor = class {
 		}
 		return this.executeAgent(automation, automation.action, run, signal, hooks, deadlineAtMs);
 	}
-	async executeBrowserRecipe(automation, action, signal, hooks) {
+	async executeBrowserAutomation(automation, action, signal, hooks) {
 		await hooks.onRunPatch?.({ currentPhase: "action" });
 		const safetyMode = automation.safety?.mode ?? "auto_apply";
 		if (safetyMode !== "auto_apply") return {
 			status: "succeeded",
-			summary: `${safetyMode === "suggest_only" ? "Suggest only" : "Ask before applying"}: Browser automation ${action.recipeId} was not run.`
+			summary: `${safetyMode === "suggest_only" ? "Suggest only" : "Ask before applying"}: Browser automation ${action.automationId} was not run.`
 		};
-		const service = this.deps.browserRecipeService;
+		const service = this.deps.browserAutomationService;
 		if (!service) return {
 			status: "failed",
 			error: "Browser automation is not available"
 		};
-		const run = await service.runAndWait(action.recipeId, action.args ?? {}, signal);
+		const run = await service.runAndWait(action.automationId, action.inputs ?? {}, signal);
 		if (run.status === "succeeded") return {
 			status: "succeeded",
-			summary: `Browser automation ${action.recipeId} completed: ${JSON.stringify(run.result ?? null).slice(0, 3500)}`
+			summary: `Browser automation ${action.automationId} completed: ${JSON.stringify(run.result ?? null).slice(0, 3500)}`
 		};
 		return {
 			status: run.status === "cancelled" ? "cancelled" : "failed",
-			error: run.error ?? `Browser automation ${action.recipeId} ${run.status}`
+			error: run.error ?? `Browser automation ${action.automationId} ${run.status}`
 		};
 	}
 	async executeAgent(automation, action, run, signal, hooks, deadlineAtMs) {

package/dist/src/browser/{recipes → automations}/index.d.ts

@@ -1,3 +1,4 @@
 export * from './types.js';
+export * from './schema.js';
 export * from './service.js';
 export * from './runtime-service.js';

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

@@ -0,0 +1,4 @@
+import { BrowserAutomationDefinitionSchema } from "./schema.js";
+import { BrowserAutomationService } from "./service.js";
+import { createRuntimeBrowserAutomationService } from "./runtime-service.js";
+export { BrowserAutomationDefinitionSchema, BrowserAutomationService, createRuntimeBrowserAutomationService };

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

@@ -0,0 +1,13 @@
+import type { BrowserAutomation, BrowserAutomationRun, BrowserAutomationRunEvent } from './types.js';
+export declare const listBrowserAutomations: () => BrowserAutomation[];
+export declare const getBrowserAutomation: (id: string) => BrowserAutomation | null;
+export declare function saveBrowserAutomation(value: BrowserAutomation): void;
+export declare const deleteBrowserAutomation: (id: string) => boolean;
+export declare function saveBrowserAutomationRun(value: BrowserAutomationRun): void;
+export declare const getBrowserAutomationRun: (id: string) => BrowserAutomationRun | null;
+export declare const listBrowserAutomationRuns: (automationId?: string) => BrowserAutomationRun[];
+export declare const listActiveBrowserAutomationRuns: () => BrowserAutomationRun[];
+export declare const hasActiveBrowserAutomationRuns: (automationId: string) => boolean;
+export declare const nextBrowserAutomationRunEventSeq: (runId: string) => number;
+export declare function appendBrowserAutomationRunEvent(value: BrowserAutomationRunEvent): void;
+export declare const listBrowserAutomationRunEvents: (runId: string) => BrowserAutomationRunEvent[];

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

@@ -0,0 +1,60 @@
+import { getSqliteDatabase, runSqliteWriteTransaction } from "../../storage/sqlite/transaction.js";
+import "../../storage/sqlite/index.js";
+//#region src/browser/automations/repository.ts
+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 parseAutomation = (row) => ({
+	id: row.automation_id,
+	revision: row.revision,
+	status: row.status,
+	definition: JSON.parse(row.definition_json),
+	createdAtMs: row.created_at_ms,
+	updatedAtMs: row.updated_at_ms
+});
+const parseRun = (row) => ({
+	id: row.run_id,
+	automationId: row.automation_id,
+	automationRevision: row.automation_revision,
+	definition: JSON.parse(row.definition_json),
+	status: row.status,
+	inputs: JSON.parse(row.inputs_json),
+	result: row.result_json ? JSON.parse(row.result_json) : void 0,
+	error: row.error ?? void 0,
+	createdAtMs: row.created_at_ms,
+	startedAtMs: row.started_at_ms ?? void 0,
+	endedAtMs: row.ended_at_ms ?? void 0,
+	durationMs: row.duration_ms ?? void 0
+});
+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);
+	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));
+}
+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));
+}
+const getBrowserAutomationRun = (id) => {
+	const row = getSqliteDatabase().prepare(`${RUN_SELECT} WHERE run_id = ?`).get(id);
+	return row ? parseRun(row) : null;
+};
+const listBrowserAutomationRuns = (automationId) => (automationId ? getSqliteDatabase().prepare(`${RUN_SELECT} WHERE automation_id = ? ORDER BY created_at_ms DESC`).all(automationId) : getSqliteDatabase().prepare(`${RUN_SELECT} ORDER BY created_at_ms DESC`).all()).map(parseRun);
+const listActiveBrowserAutomationRuns = () => getSqliteDatabase().prepare(`${RUN_SELECT} WHERE status IN ('queued', 'running')`).all().map(parseRun);
+const hasActiveBrowserAutomationRuns = (automationId) => Boolean(getSqliteDatabase().prepare("SELECT 1 FROM browser_automation_runs WHERE automation_id = ? AND status IN ('queued', 'running') LIMIT 1").get(automationId));
+const nextBrowserAutomationRunEventSeq = (runId) => getSqliteDatabase().prepare("SELECT COALESCE(MAX(seq), 0) + 1 AS seq FROM browser_action_audit WHERE run_id = ?").get(runId).seq;
+function appendBrowserAutomationRunEvent(value) {
+	runSqliteWriteTransaction((db) => db.prepare("INSERT INTO browser_action_audit (event_id, run_id, seq, type, data_json, created_at_ms) VALUES (?, ?, ?, ?, ?, ?)").run(value.id, value.runId, value.seq, value.type, value.data === void 0 ? null : JSON.stringify(value.data), value.createdAtMs));
+}
+const listBrowserAutomationRunEvents = (runId) => getSqliteDatabase().prepare("SELECT event_id, run_id, seq, type, data_json, created_at_ms FROM browser_action_audit WHERE run_id = ? ORDER BY seq").all(runId).map((row) => ({
+	id: row.event_id,
+	runId: row.run_id,
+	seq: row.seq,
+	type: row.type,
+	data: row.data_json ? JSON.parse(row.data_json) : void 0,
+	createdAtMs: row.created_at_ms
+}));
+//#endregion
+export { appendBrowserAutomationRunEvent, deleteBrowserAutomation, getBrowserAutomation, getBrowserAutomationRun, hasActiveBrowserAutomationRuns, listActiveBrowserAutomationRuns, listBrowserAutomationRunEvents, listBrowserAutomationRuns, listBrowserAutomations, nextBrowserAutomationRunEventSeq, saveBrowserAutomation, saveBrowserAutomationRun };

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

@@ -0,0 +1,17 @@
+import type { BrowserControlResult } from '@xopcai/browser-control-contract';
+import type { BrowserRuntime } from '../runtime/browser-runtime.js';
+import type { BrowserAutomationDefinition } from './types.js';
+export declare function runBrowserAutomation(input: {
+    definition: BrowserAutomationDefinition;
+    inputs: Record<string, unknown>;
+    runtime: BrowserRuntime;
+    taskKey: string;
+    signal: AbortSignal;
+    onStep: (event: {
+        index: number;
+        action: string;
+        status: 'started' | 'completed' | 'failed';
+        result?: BrowserControlResult;
+    }) => void;
+}): Promise<BrowserControlResult>;
+export declare function resolveBrowserAutomationInputs(definition: BrowserAutomationDefinition, provided: Record<string, unknown>): Record<string, unknown>;

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

@@ -0,0 +1,173 @@
+//#region src/browser/automations/runner.ts
+async function runBrowserAutomation(input) {
+	const startedAt = Date.now();
+	const values = resolveBrowserAutomationInputs(input.definition, input.inputs);
+	let observation;
+	let sessionId;
+	for (let index = 0; index < input.definition.steps.length; index += 1) {
+		const step = input.definition.steps[index];
+		input.onStep({
+			index,
+			action: step.action,
+			status: "started"
+		});
+		try {
+			if (step.action !== "navigate" && !observation) {
+				const observed = await input.runtime.execute(input.taskKey, {
+					action: "observe",
+					sessionId
+				}, input.signal);
+				if (!observed.ok) {
+					input.onStep({
+						index,
+						action: step.action,
+						status: "failed",
+						result: observed
+					});
+					return observed;
+				}
+				observation = observed.receipt.observation;
+				sessionId = observation?.sessionId;
+			}
+			if (step.action === "navigate") assertAllowedDomain(input.definition.allowedDomains, render(step.url, values));
+			const action = buildAction(step, values, observation, sessionId);
+			const result = await input.runtime.execute(input.taskKey, action, input.signal);
+			if (!result.ok) {
+				input.onStep({
+					index,
+					action: step.action,
+					status: "failed",
+					result
+				});
+				return result;
+			}
+			observation = result.receipt.observation ?? observation;
+			sessionId = observation?.sessionId ?? sessionId;
+			if (step.action === "navigate") assertAllowedDomain(input.definition.allowedDomains, observation?.url ?? render(step.url, values));
+			input.onStep({
+				index,
+				action: step.action,
+				status: "completed",
+				result
+			});
+		} catch (error) {
+			const result = automationFailure(step.action === "navigate" ? "BLOCKED_URL" : "INVALID_INPUT", error, observation);
+			input.onStep({
+				index,
+				action: step.action,
+				status: "failed",
+				result
+			});
+			return result;
+		}
+	}
+	return {
+		ok: true,
+		receipt: {
+			action: "sequence",
+			risk: input.definition.risk,
+			durationMs: Date.now() - startedAt,
+			verified: true,
+			observation
+		}
+	};
+}
+function buildAction(step, inputs, observation, sessionId) {
+	if (step.action === "navigate") return {
+		...step,
+		url: render(step.url, inputs),
+		sessionId
+	};
+	if (!observation) throw new Error("Browser observation is unavailable.");
+	const revision = observation.revision;
+	const ref = "target" in step && step.target ? resolveTarget(step.target, observation) : void 0;
+	switch (step.action) {
+		case "click": return {
+			action: "click",
+			sessionId,
+			revision,
+			ref,
+			expect: step.expect
+		};
+		case "fill": return {
+			action: "fill",
+			sessionId,
+			revision,
+			ref,
+			value: render(step.value, inputs),
+			submit: step.submit,
+			expect: step.expect
+		};
+		case "select": return {
+			action: "select",
+			sessionId,
+			revision,
+			ref,
+			value: render(step.value, inputs),
+			expect: step.expect
+		};
+		case "press": return {
+			action: "press",
+			sessionId,
+			revision,
+			ref,
+			key: render(step.key, inputs),
+			expect: step.expect
+		};
+		case "scroll": return {
+			action: "scroll",
+			sessionId,
+			revision,
+			ref,
+			deltaY: step.deltaY,
+			expect: step.expect
+		};
+		case "wait": return {
+			action: "wait",
+			sessionId,
+			revision,
+			ref,
+			condition: step.condition,
+			value: step.value ? render(step.value, inputs) : void 0,
+			timeoutMs: step.timeoutMs
+		};
+	}
+}
+function resolveTarget(target, observation) {
+	const matches = observation.nodes.filter((node) => node.role === target.role && (!target.name || node.name === target.name) && (!target.nameIncludes || node.name.includes(target.nameIncludes)));
+	if (matches.length !== 1) throw new Error(`Semantic target must match exactly one element; matched ${matches.length}: ${JSON.stringify(target)}`);
+	return matches[0].ref;
+}
+function render(value, inputs) {
+	return value.replace(/\$\{input\.([a-zA-Z][a-zA-Z0-9_]*)\}/g, (_match, key) => {
+		if (!(key in inputs)) throw new Error(`Missing automation input: ${key}`);
+		return String(inputs[key]);
+	});
+}
+function resolveBrowserAutomationInputs(definition, provided) {
+	const values = { ...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 && 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;
+	}
+	for (const name of Object.keys(values)) if (!definition.inputs[name]) throw new Error(`Unknown automation input: ${name}`);
+	return values;
+}
+function assertAllowedDomain(allowedDomains, url) {
+	const host = new URL(url).hostname.toLowerCase();
+	if (!allowedDomains.some((domain) => domain.toLowerCase() === host)) throw new Error(`Automation navigated outside its allowed domains: ${host}`);
+}
+function automationFailure(code, error, observation) {
+	return {
+		ok: false,
+		error: {
+			code,
+			message: error instanceof Error ? error.message : String(error),
+			observation
+		}
+	};
+}
+//#endregion
+export { resolveBrowserAutomationInputs, runBrowserAutomation };

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

@@ -0,0 +1,6 @@
+import type { Config } from '../../config/schema.js';
+import { BrowserAutomationService } from './service.js';
+export declare function createRuntimeBrowserAutomationService(deps: {
+    getConfig: () => Config;
+    emit?: (type: string, payload: unknown) => void;
+}): BrowserAutomationService;

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

@@ -0,0 +1,37 @@
+import { BrowserRuntime } from "../runtime/browser-runtime.js";
+import { createBrowserDriver } from "../drivers/create-driver.js";
+import { runBrowserAutomation } from "./runner.js";
+import { BrowserAutomationService } from "./service.js";
+//#region src/browser/automations/runtime-service.ts
+function createRuntimeBrowserAutomationService(deps) {
+	const runtime = new BrowserRuntime({
+		getConfig: () => deps.getConfig().browser,
+		createDriver: () => createBrowserDriver(deps.getConfig().browser),
+		allowedUploadRoots: [process.cwd()],
+		emit: deps.emit
+	});
+	return new BrowserAutomationService(async ({ definition, inputs, signal, onStep }) => {
+		const taskKey = `browser-automation:${crypto.randomUUID()}`;
+		try {
+			const result = await runBrowserAutomation({
+				definition,
+				inputs,
+				runtime,
+				taskKey,
+				signal,
+				onStep
+			});
+			return result.ok ? {
+				ok: true,
+				result: result.receipt
+			} : {
+				ok: false,
+				error: "error" in result ? result.error.message : "Browser automation failed."
+			};
+		} finally {
+			await runtime.closeTaskSession(taskKey);
+		}
+	}, deps.emit);
+}
+//#endregion
+export { createRuntimeBrowserAutomationService };

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

@@ -0,0 +1,144 @@
+import { z } from 'zod';
+export declare const BrowserAutomationDefinitionSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    allowedDomains: z.ZodArray<z.ZodString>;
+    risk: z.ZodEnum<{
+        read: "read";
+        sensitive: "sensitive";
+        destructive: "destructive";
+        draft: "draft";
+        external_effect: "external_effect";
+    }>;
+    inputs: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+        type: z.ZodEnum<{
+            string: "string";
+            number: "number";
+            boolean: "boolean";
+        }>;
+        required: z.ZodOptional<z.ZodBoolean>;
+        default: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+        description: z.ZodOptional<z.ZodString>;
+        choices: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
+    }, z.core.$strict>>>;
+    steps: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        action: z.ZodLiteral<"navigate">;
+        url: z.ZodString;
+        expect: z.ZodOptional<z.ZodObject<{
+            urlIncludes: z.ZodOptional<z.ZodString>;
+            titleIncludes: z.ZodOptional<z.ZodString>;
+            textIncludes: z.ZodOptional<z.ZodString>;
+            ref: z.ZodOptional<z.ZodString>;
+            state: z.ZodOptional<z.ZodEnum<{
+                hidden: "hidden";
+                visible: "visible";
+            }>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>, z.ZodObject<{
+        action: z.ZodLiteral<"click">;
+        target: z.ZodObject<{
+            role: z.ZodString;
+            name: z.ZodOptional<z.ZodString>;
+            nameIncludes: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        expect: z.ZodOptional<z.ZodObject<{
+            urlIncludes: z.ZodOptional<z.ZodString>;
+            titleIncludes: z.ZodOptional<z.ZodString>;
+            textIncludes: z.ZodOptional<z.ZodString>;
+            ref: z.ZodOptional<z.ZodString>;
+            state: z.ZodOptional<z.ZodEnum<{
+                hidden: "hidden";
+                visible: "visible";
+            }>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>, z.ZodObject<{
+        action: z.ZodLiteral<"fill">;
+        target: z.ZodObject<{
+            role: z.ZodString;
+            name: z.ZodOptional<z.ZodString>;
+            nameIncludes: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        value: z.ZodString;
+        submit: z.ZodOptional<z.ZodBoolean>;
+        expect: z.ZodOptional<z.ZodObject<{
+            urlIncludes: z.ZodOptional<z.ZodString>;
+            titleIncludes: z.ZodOptional<z.ZodString>;
+            textIncludes: z.ZodOptional<z.ZodString>;
+            ref: z.ZodOptional<z.ZodString>;
+            state: z.ZodOptional<z.ZodEnum<{
+                hidden: "hidden";
+                visible: "visible";
+            }>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>, z.ZodObject<{
+        action: z.ZodLiteral<"select">;
+        target: z.ZodObject<{
+            role: z.ZodString;
+            name: z.ZodOptional<z.ZodString>;
+            nameIncludes: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        value: z.ZodString;
+        expect: z.ZodOptional<z.ZodObject<{
+            urlIncludes: z.ZodOptional<z.ZodString>;
+            titleIncludes: z.ZodOptional<z.ZodString>;
+            textIncludes: z.ZodOptional<z.ZodString>;
+            ref: z.ZodOptional<z.ZodString>;
+            state: z.ZodOptional<z.ZodEnum<{
+                hidden: "hidden";
+                visible: "visible";
+            }>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>, z.ZodObject<{
+        action: z.ZodLiteral<"press">;
+        target: z.ZodOptional<z.ZodObject<{
+            role: z.ZodString;
+            name: z.ZodOptional<z.ZodString>;
+            nameIncludes: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        key: z.ZodString;
+        expect: z.ZodOptional<z.ZodObject<{
+            urlIncludes: z.ZodOptional<z.ZodString>;
+            titleIncludes: z.ZodOptional<z.ZodString>;
+            textIncludes: z.ZodOptional<z.ZodString>;
+            ref: z.ZodOptional<z.ZodString>;
+            state: z.ZodOptional<z.ZodEnum<{
+                hidden: "hidden";
+                visible: "visible";
+            }>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>, z.ZodObject<{
+        action: z.ZodLiteral<"scroll">;
+        target: z.ZodOptional<z.ZodObject<{
+            role: z.ZodString;
+            name: z.ZodOptional<z.ZodString>;
+            nameIncludes: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        deltaY: z.ZodNumber;
+        expect: z.ZodOptional<z.ZodObject<{
+            urlIncludes: z.ZodOptional<z.ZodString>;
+            titleIncludes: z.ZodOptional<z.ZodString>;
+            textIncludes: z.ZodOptional<z.ZodString>;
+            ref: z.ZodOptional<z.ZodString>;
+            state: z.ZodOptional<z.ZodEnum<{
+                hidden: "hidden";
+                visible: "visible";
+            }>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>, z.ZodObject<{
+        action: z.ZodLiteral<"wait">;
+        condition: z.ZodEnum<{
+            hidden: "hidden";
+            text: "text";
+            visible: "visible";
+            page_idle: "page_idle";
+        }>;
+        value: z.ZodOptional<z.ZodString>;
+        target: z.ZodOptional<z.ZodObject<{
+            role: z.ZodString;
+            name: z.ZodOptional<z.ZodString>;
+            nameIncludes: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        timeoutMs: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>], "action">>;
+}, z.core.$strict>;