@xopcai/xopc 0.0.312 → 0.0.314

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

@@ -5,6 +5,10 @@ export declare class AutomationAlreadyRunningError extends Error {
     readonly runningRunId?: string;
     constructor(automationId: string, runningRunId?: string);
 }
+export declare class AutomationAlreadyExistsError extends Error {
+    readonly automationId: string;
+    constructor(automationId: string);
+}
 export declare class AutomationService {
     private readonly executor;
     private timer;
@@ -21,16 +25,37 @@ export declare class AutomationService {
     }): Promise<void>;
     stop(): Promise<void>;
     create(input: CreateAutomationInput): Promise<Automation>;
+    /** SQLite-only creation; scheduling starts after the caller commits. */
+    createAtomically(input: CreateAutomationInput): Automation;
+    private applyCreate;
     list(options?: {
         projectId?: string;
     }): Promise<Automation[]>;
     get(id: string): Promise<Automation | null>;
     update(id: string, patch: UpdateAutomationInput): Promise<Automation | null>;
+    /** SQLite-only mutation; callers must refresh scheduling after their outer transaction commits. */
+    updateAtomically(id: string, patch: UpdateAutomationInput): Automation | null;
+    refreshSchedule(): void;
+    private applyUpdate;
     remove(id: string): Promise<boolean>;
+    /** Persist deletion and cancellation intent together; never abort within a transaction. */
+    removeAtomically(id: string): {
+        removed: boolean;
+        automation?: Automation;
+        cancelRunId?: string;
+    };
+    finishRemoval(cancelRunId?: string): void;
     pause(id: string): Promise<Automation | null>;
     resume(id: string): Promise<Automation | null>;
     runNow(id: string): Promise<AutomationRun>;
     rerunFromRun(runId: string): Promise<AutomationRun>;
+    queueRerunAtomically(runId: string): AutomationRun;
+    queueRunAtomically(id: string, opts?: {
+        manual: boolean;
+        event?: AutomationEvent;
+    }): AutomationRun;
+    /** Claim before invoking external work; replays never restart running or completed runs. */
+    dispatchQueuedRun(runId: string): void;
     triggerEvent(event: AutomationEvent): Promise<AutomationRun[]>;
     listRuns(options?: {
         automationId?: string;
@@ -51,11 +76,17 @@ export declare class AutomationService {
         projectId?: string;
     }): Promise<number>;
     cancelRun(runId: string): Promise<boolean>;
+    dispatchCancellation(runId: string): void;
+    cancelRunAtomically(runId: string): {
+        cancelled: boolean;
+        confirmed: boolean;
+    };
     getMetrics(): Promise<AutomationMetrics>;
     private recomputeNextRuns;
     private armTimer;
     private onTimer;
     private startRun;
+    private persistQueuedRun;
     private executeRun;
     private recoverInterruptedRuns;
     private waitForRetry;

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

@@ -1,12 +1,12 @@
 import { createLogger } from "../../utils/logger/index.js";
 import { init_logger } from "../../utils/logger.js";
 import { init_transaction, runSqliteWriteTransaction } from "../../storage/sqlite/transaction.js";
-import { computeNextAutomationRunAtMs, timerDelayUntil } from "../domain/schedule.js";
 import { AutomationSchema, CreateAutomationSchema, UpdateAutomationSchema } from "../domain/validation.js";
-import { AutomationActionExecutor } from "./action-executor.js";
-import { deleteAutomation, getAutomation, listAutomations, saveAutomation, saveAutomations } from "../storage/automation-repository.js";
-import { appendAutomationRunEvent, getAutomationRun, listAutomationRunEvents, listAutomationRuns, listAutomationRunsForProductEvent, markAllAutomationRunsRead, markAutomationRunRead, saveAutomationRun, touchAutomationRunLease } from "../storage/automation-run-repository.js";
+import { deleteAutomation, getAutomation, getDeletedAutomationRevision, listAutomations, saveAutomation, saveAutomations } from "../storage/automation-repository.js";
+import { appendAutomationRunEvent, getAutomationRun, getAutomationRunRequest, listAutomationRunEvents, listAutomationRuns, listAutomationRunsForProductEvent, listUnfinishedAutomationRuns, markAllAutomationRunsRead, markAutomationRunRead, saveAutomationRun, saveAutomationRunRequest, touchAutomationRunLease } from "../storage/automation-run-repository.js";
 import "../storage/index.js";
+import { computeNextAutomationRunAtMs, timerDelayUntil } from "../domain/schedule.js";
+import { AutomationActionExecutor } from "./action-executor.js";
 import { randomUUID } from "node:crypto";
 //#region src/automations/service/automation-service.ts
 init_logger();
@@ -31,6 +31,13 @@ var AutomationAlreadyRunningError = class extends Error {
 		this.name = "AutomationAlreadyRunningError";
 	}
 };
+var AutomationAlreadyExistsError = class extends Error {
+	constructor(automationId) {
+		super(`Automation already exists: ${automationId}`);
+		this.automationId = automationId;
+		this.name = "AutomationAlreadyExistsError";
+	}
+};
 var AutomationService = class {
 	executor = new AutomationActionExecutor();
 	timer = null;
@@ -68,6 +75,15 @@ var AutomationService = class {
 		log.info("Automation service stopped");
 	}
 	async create(input) {
+		const automation = this.createAtomically(input);
+		this.refreshSchedule();
+		return automation;
+	}
+	/** SQLite-only creation; scheduling starts after the caller commits. */
+	createAtomically(input) {
+		return runSqliteWriteTransaction(() => this.applyCreate(input));
+	}
+	applyCreate(input) {
 		const parsed = CreateAutomationSchema.parse(input);
 		const now = Date.now();
 		const automation = AutomationSchema.parse({
@@ -81,9 +97,10 @@ var AutomationService = class {
 			createdAtMs: now,
 			updatedAtMs: now
 		});
+		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);
-		this.armTimer();
 		return automation;
 	}
 	async list(options) {
@@ -93,6 +110,18 @@ var AutomationService = class {
 		return getAutomation(id);
 	}
 	async update(id, patch) {
+		const automation = this.updateAtomically(id, patch);
+		this.refreshSchedule();
+		return automation;
+	}
+	/** SQLite-only mutation; callers must refresh scheduling after their outer transaction commits. */
+	updateAtomically(id, patch) {
+		return runSqliteWriteTransaction(() => this.applyUpdate(id, patch));
+	}
+	refreshSchedule() {
+		this.armTimer();
+	}
+	applyUpdate(id, patch) {
 		const parsed = UpdateAutomationSchema.parse(patch);
 		const current = getAutomation(id);
 		if (!current) return null;
@@ -102,7 +131,7 @@ var AutomationService = class {
 			...parsed,
 			id: current.id,
 			createdAtMs: current.createdAtMs,
-			updatedAtMs: now,
+			updatedAtMs: Math.max(now, current.updatedAtMs + 1),
 			state: {
 				...current.state,
 				...parsed.state ?? {}
@@ -110,15 +139,47 @@ var AutomationService = class {
 		});
 		if ("enabled" in parsed || "trigger" in parsed) next.state.nextRunAtMs = computeNextAutomationRunAtMs(next, now);
 		saveAutomation(next);
-		this.armTimer();
 		return next;
 	}
 	async remove(id) {
-		const automation = getAutomation(id);
-		if (automation?.state.runningRunId) this.activeRuns.get(automation.state.runningRunId)?.abort();
-		const removed = deleteAutomation(id);
-		if (removed) this.armTimer();
-		return removed;
+		const result = this.removeAtomically(id);
+		this.finishRemoval(result.cancelRunId);
+		return result.removed;
+	}
+	/** Persist deletion and cancellation intent together; never abort within a transaction. */
+	removeAtomically(id) {
+		return runSqliteWriteTransaction(() => {
+			const automation = getAutomation(id);
+			if (!automation) return { removed: false };
+			const run = automation.state.runningRunId ? getAutomationRun(automation.state.runningRunId) : null;
+			let cancelRunId;
+			if (run?.automationId === id && [
+				"queued",
+				"running",
+				"cancelling"
+			].includes(run.status)) {
+				cancelRunId = run.id;
+				if (run.status !== "cancelling") {
+					const cancelling = {
+						...run,
+						status: "cancelling",
+						currentPhase: "cancelling",
+						cancelRequestedAtMs: Date.now()
+					};
+					saveAutomationRun(cancelling);
+					this.appendRunEvent(cancelling, "run.cancel_requested", "Automation deletion requested cancellation", { reason: "automation_deleted" });
+				}
+			}
+			return {
+				removed: deleteAutomation(id),
+				automation,
+				cancelRunId
+			};
+		});
+	}
+	finishRemoval(cancelRunId) {
+		if (cancelRunId) this.activeRuns.get(cancelRunId)?.abort(/* @__PURE__ */ new Error("Automation was deleted by the user"));
+		this.refreshSchedule();
 	}
 	async pause(id) {
 		return this.update(id, { enabled: false });
@@ -127,22 +188,66 @@ var AutomationService = class {
 		return this.update(id, { enabled: true });
 	}
 	async runNow(id) {
-		const automation = getAutomation(id);
-		if (!automation) throw new Error(`Automation not found: ${id}`);
-		if (automation.state.runningRunId) throw new AutomationAlreadyRunningError(id, automation.state.runningRunId);
-		return this.startRun(automation, { manual: true });
+		const run = this.queueRunAtomically(id);
+		this.dispatchQueuedRun(run.id);
+		return run;
 	}
 	async rerunFromRun(runId) {
-		const previous = getAutomationRun(runId);
-		if (!previous) throw new Error(`Automation run not found: ${runId}`);
-		const automation = getAutomation(previous.automationId);
-		if (!automation) throw new Error(`Automation not found: ${previous.automationId}`);
-		if (automation.state.runningRunId) throw new AutomationAlreadyRunningError(automation.id, automation.state.runningRunId);
-		const triggerEvent = listAutomationRunEvents(runId).map((event) => readAutomationEventFromRunEvent(event)).find((event) => event !== null);
-		return this.startRun(automation, triggerEvent ? {
-			manual: false,
-			event: triggerEvent
-		} : { manual: true });
+		const run = this.queueRerunAtomically(runId);
+		this.dispatchQueuedRun(run.id);
+		return run;
+	}
+	queueRerunAtomically(runId) {
+		return runSqliteWriteTransaction(() => {
+			const previous = getAutomationRun(runId);
+			if (!previous) throw new Error(`Automation run not found: ${runId}`);
+			const event = listAutomationRunEvents(runId).map(readAutomationEventFromRunEvent).find((item) => item !== null);
+			return this.queueRunAtomically(previous.automationId, event ? {
+				manual: false,
+				event
+			} : { manual: true });
+		});
+	}
+	queueRunAtomically(id, opts = { manual: true }) {
+		return runSqliteWriteTransaction(() => {
+			const automation = getAutomation(id);
+			if (!automation) throw new Error(`Automation not found: ${id}`);
+			if (automation.state.runningRunId) throw new AutomationAlreadyRunningError(id, automation.state.runningRunId);
+			return this.persistQueuedRun(automation, opts);
+		});
+	}
+	/** Claim before invoking external work; replays never restart running or completed runs. */
+	dispatchQueuedRun(runId) {
+		const claimed = runSqliteWriteTransaction(() => {
+			const run = getAutomationRun(runId);
+			if (!run || run.status !== "queued") return null;
+			const current = getAutomation(run.automationId);
+			if (!current || current.state.runningRunId !== run.id) return null;
+			const automation = getAutomationRunRequest(run.id);
+			if (!automation) throw new Error(`Execution configuration is missing for run: ${run.id}`);
+			const now = Date.now();
+			const next = {
+				...run,
+				status: "running",
+				startedAtMs: now,
+				currentPhase: "action",
+				heartbeatAtMs: now,
+				leaseOwner: this.leaseOwner,
+				leaseExpiresAtMs: now + RUN_LEASE_DURATION_MS
+			};
+			saveAutomationRun(next);
+			return {
+				automation,
+				run: next
+			};
+		});
+		if (!claimed) return;
+		this.executeRun(claimed.automation, claimed.run).catch((err) => {
+			log.error({
+				err,
+				runId
+			}, "Queued automation run failed");
+		});
 	}
 	async triggerEvent(event) {
 		const normalized = {
@@ -177,22 +282,65 @@ var AutomationService = class {
 		return markAllAutomationRunsRead(options);
 	}
 	async cancelRun(runId) {
-		const controller = this.activeRuns.get(runId);
-		if (!controller) return false;
-		const now = Date.now();
-		const current = getAutomationRun(runId);
-		if (current && current.status === "running") {
-			const cancelling = {
+		const result = this.cancelRunAtomically(runId);
+		if (result.cancelled) this.dispatchCancellation(runId);
+		return result.cancelled;
+	}
+	dispatchCancellation(runId) {
+		this.activeRuns.get(runId)?.abort(/* @__PURE__ */ new Error("Automation run was cancelled by the user"));
+		this.refreshSchedule();
+	}
+	cancelRunAtomically(runId) {
+		return runSqliteWriteTransaction(() => {
+			const current = getAutomationRun(runId);
+			if (!current || ![
+				"queued",
+				"running",
+				"cancelling"
+			].includes(current.status)) return {
+				cancelled: false,
+				confirmed: false
+			};
+			const now = Date.now();
+			if (current.status !== "queued") {
+				if (current.status === "running") {
+					const cancelling = {
+						...current,
+						status: "cancelling",
+						currentPhase: "cancelling",
+						cancelRequestedAtMs: now
+					};
+					saveAutomationRun(cancelling);
+					this.appendRunEvent(cancelling, "run.cancel_requested", "Automation cancellation requested", { reason: "user_cancelled" });
+				}
+				return {
+					cancelled: true,
+					confirmed: false
+				};
+			}
+			const cancelled = {
 				...current,
-				status: "cancelling",
-				currentPhase: "cancelling",
-				cancelRequestedAtMs: now
+				status: "cancelled",
+				currentPhase: "completed",
+				endedAtMs: now,
+				cancelRequestedAtMs: now,
+				cancelConfirmedAtMs: now,
+				termination: {
+					reason: "user_cancelled",
+					component: "automation",
+					cancellationConfirmed: true
+				}
 			};
-			saveAutomationRun(cancelling);
-			this.appendRunEvent(cancelling, "run.cancel_requested", "Automation cancellation requested", { reason: "user_cancelled" });
-		}
-		controller.abort(/* @__PURE__ */ new Error("Automation run was cancelled by the user"));
-		return true;
+			saveAutomationRun(cancelled);
+			this.appendRunEvent(cancelled, "run.cancel_requested", "Queued automation cancellation requested");
+			this.appendRunEvent(cancelled, "run.cancel_confirmed", "Queued automation cancelled before execution");
+			this.appendRunEvent(cancelled, "run.completed", "Automation run cancelled", { status: "cancelled" });
+			this.finishAutomationRun(current.automationId, runId, "cancelled", void 0, now);
+			return {
+				cancelled: true,
+				confirmed: true
+			};
+		});
 	}
 	async getMetrics() {
 		const automations = listAutomations();
@@ -235,7 +383,7 @@ var AutomationService = class {
 			clearTimeout(this.timer);
 			this.timer = null;
 		}
-		const next = listAutomations().filter((automation) => automation.enabled && automation.state.nextRunAtMs != null).toSorted((a, b) => (a.state.nextRunAtMs ?? 0) - (b.state.nextRunAtMs ?? 0))[0];
+		const next = listAutomations().filter((automation) => automation.enabled && automation.state.nextRunAtMs != null && !automation.state.runningRunId).toSorted((a, b) => (a.state.nextRunAtMs ?? 0) - (b.state.nextRunAtMs ?? 0))[0];
 		if (!next?.state.nextRunAtMs) return;
 		this.timer = setTimeout(() => {
 			this.onTimer();
@@ -259,6 +407,11 @@ var AutomationService = class {
 		}
 	}
 	async startRun(automation, opts) {
+		const run = this.queueRunAtomically(automation.id, opts);
+		this.dispatchQueuedRun(run.id);
+		return run;
+	}
+	persistQueuedRun(automation, opts) {
 		const now = Date.now();
 		const run = {
 			id: randomUUID(),
@@ -279,27 +432,20 @@ var AutomationService = class {
 			safety: automation.safety ?? { mode: "auto_apply" },
 			event: opts.event
 		});
-		const nextAutomation = {
+		saveAutomation({
 			...automation,
 			state: {
 				...automation.state,
 				runningRunId: run.id
 			}
-		};
-		saveAutomation(nextAutomation);
-		this.executeRun(nextAutomation, run).catch((err) => {
-			log.error({
-				err,
-				automationId: automation.id,
-				runId: run.id
-			}, `Automation run failed: ${err instanceof Error ? err.message : String(err)}`);
 		});
+		saveAutomationRunRequest(run.id, automation);
 		return run;
 	}
 	async executeRun(automation, initialRun) {
 		const controller = new AbortController();
 		this.activeRuns.set(initialRun.id, controller);
-		const startedAtMs = Date.now();
+		const startedAtMs = initialRun.startedAtMs ?? Date.now();
 		let run = {
 			...initialRun,
 			status: "running",
@@ -400,7 +546,7 @@ var AutomationService = class {
 				};
 				this.appendRunEvent(run, task.termination.cancellationConfirmed ? "run.cancel_confirmed" : "run.cancellation_unconfirmed", task.termination.cancellationConfirmed ? "Automation cancellation confirmed" : "Automation cancellation was not confirmed within the cleanup grace period", { termination: task.termination });
 			}
-			if (status === "timeout" || status === "cancelled") {} else if ((automation.safety?.mode ?? "auto_apply") !== "auto_apply" && automation.completionWebhookUrl) this.appendRunEvent(run, "completion_hook.completed", "Completion webhook skipped by safety mode", { safety: automation.safety ?? { mode: "auto_apply" } });
+			if (controller.signal.aborted || status === "timeout" || status === "cancelled") {} else if ((automation.safety?.mode ?? "auto_apply") !== "auto_apply" && automation.completionWebhookUrl) this.appendRunEvent(run, "completion_hook.completed", "Completion webhook skipped by safety mode", { safety: automation.safety ?? { mode: "auto_apply" } });
 			else if (automation.completionWebhookUrl) {
 				activePhase = "completion_hook";
 				run = {
@@ -413,6 +559,11 @@ var AutomationService = class {
 				this.appendRunEvent(run, "completion_hook.completed", "Completion webhook completed");
 			}
 		} catch (err) {
+			const persistedRun = getAutomationRun(run.id);
+			if (persistedRun) run = {
+				...run,
+				...persistedRun
+			};
 			error = err instanceof Error ? err.message : String(err);
 			const deadlineExceeded = err instanceof AutomationDeadlineExceededError || run.deadlineAtMs !== void 0 && Date.now() >= run.deadlineAtMs;
 			status = controller.signal.aborted ? "cancelled" : deadlineExceeded ? "timeout" : "failed";
@@ -453,8 +604,9 @@ var AutomationService = class {
 					durationMs: run.durationMs,
 					error
 				});
-				this.finishAutomationRun(automation.id, status, error, endedAtMs);
+				this.finishAutomationRun(automation.id, run.id, status, error, endedAtMs);
 			});
+			this.refreshSchedule();
 			try {
 				this.deps.onRunCompleted?.(run);
 			} catch (err) {
@@ -467,25 +619,12 @@ var AutomationService = class {
 		}
 	}
 	async recoverInterruptedRuns() {
-		const recoverable = listAutomationRuns({ limit: 500 }).filter((run) => run.status === "queued" || run.status === "running" || run.status === "cancelling");
+		const recoverable = listUnfinishedAutomationRuns();
 		for (const run of recoverable) {
 			const automation = getAutomation(run.automationId);
-			if (run.status === "queued" && automation) {
-				const claimed = {
-					...automation,
-					state: {
-						...automation.state,
-						runningRunId: run.id
-					}
-				};
-				saveAutomation(claimed);
+			if (run.status === "queued" && automation?.state.runningRunId === run.id && getAutomationRunRequest(run.id)) {
 				this.appendRunEvent(run, "run.recovered", "Queued automation run recovered after restart", { previousLeaseOwner: run.leaseOwner });
-				this.executeRun(claimed, run).catch((err) => {
-					log.error({
-						err,
-						runId: run.id
-					}, "Recovered automation run failed");
-				});
+				this.dispatchQueuedRun(run.id);
 				continue;
 			}
 			const now = Date.now();
@@ -516,7 +655,7 @@ var AutomationService = class {
 				status,
 				error
 			});
-			if (automation) this.finishAutomationRun(automation.id, status, error, now);
+			if (automation) this.finishAutomationRun(automation.id, run.id, status, error, now);
 		}
 	}
 	waitForRetry(delayMs, signal) {
@@ -544,9 +683,9 @@ var AutomationService = class {
 			createdAtMs: Date.now()
 		});
 	}
-	finishAutomationRun(automationId, status, error, finishedAtMs) {
+	finishAutomationRun(automationId, runId, status, error, finishedAtMs) {
 		const current = getAutomation(automationId);
-		if (!current) return;
+		if (!current || current.state.runningRunId !== runId) return;
 		const consecutiveFailures = status === "failed" || status === "timeout" ? (current.state.consecutiveFailures ?? 0) + 1 : 0;
 		const disableAfter = current.reliability?.disableAfterConsecutiveFailures;
 		const shouldDisable = disableAfter != null && consecutiveFailures >= disableAfter;
@@ -560,12 +699,11 @@ var AutomationService = class {
 				lastError: error,
 				consecutiveFailures
 			},
-			updatedAtMs: shouldDisable ? finishedAtMs : current.updatedAtMs
+			updatedAtMs: shouldDisable ? Math.max(finishedAtMs, current.updatedAtMs + 1) : current.updatedAtMs
 		};
 		delete next.state.runningRunId;
 		next.state.nextRunAtMs = computeNextAutomationRunAtMs(next, finishedAtMs);
 		saveAutomation(next);
-		this.armTimer();
 	}
 	async postCompletionWebhook(url, run, signal) {
 		const remainingMs = run.deadlineAtMs === void 0 ? 3e4 : Math.max(1, run.deadlineAtMs - Date.now());
@@ -611,4 +749,4 @@ function readAutomationEventFromRunEvent(event) {
 	};
 }
 //#endregion
-export { AutomationAlreadyRunningError, AutomationService };
+export { AutomationAlreadyExistsError, AutomationAlreadyRunningError, AutomationService };

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

@@ -1,3 +1,3 @@
 import { AutomationActionExecutor } from "./action-executor.js";
-import { AutomationAlreadyRunningError, AutomationService } from "./automation-service.js";
-export { AutomationActionExecutor, AutomationAlreadyRunningError, AutomationService };
+import { AutomationAlreadyExistsError, AutomationAlreadyRunningError, AutomationService } from "./automation-service.js";
+export { AutomationActionExecutor, AutomationAlreadyExistsError, AutomationAlreadyRunningError, AutomationService };

package/dist/src/automations/storage/automation-repository.d.ts

@@ -6,3 +6,5 @@ export declare function getAutomation(automationId: string): Automation | null;
 export declare function saveAutomation(automation: Automation): void;
 export declare function saveAutomations(automations: Automation[]): void;
 export declare function deleteAutomation(automationId: string): boolean;
+/** Keep revisions distinct when a caller recreates a previously deleted identity. */
+export declare function getDeletedAutomationRevision(automationId: string): number | undefined;

package/dist/src/automations/storage/automation-repository.js

@@ -59,8 +59,16 @@ function saveAutomations(automations) {
 }
 function deleteAutomation(automationId) {
 	return runSqliteWriteTransaction((db) => {
+		db.prepare(`INSERT INTO automation_deleted_revisions (automation_id, revision)
+      SELECT automation_id, updated_at_ms FROM automations WHERE automation_id = ?
+      ON CONFLICT(automation_id) DO UPDATE SET revision = MAX(revision, excluded.revision)`).run(automationId);
 		return db.prepare(`DELETE FROM automations WHERE automation_id = ?`).run(automationId).changes > 0;
 	});
 }
+/** Keep revisions distinct when a caller recreates a previously deleted identity. */
+function getDeletedAutomationRevision(automationId) {
+	const row = getSqliteDatabase().prepare("SELECT revision FROM automation_deleted_revisions WHERE automation_id = ?").get(automationId);
+	return row ? Number(row.revision) : void 0;
+}
 //#endregion
-export { deleteAutomation, getAutomation, listAutomations, saveAutomation, saveAutomations };
+export { deleteAutomation, getAutomation, getDeletedAutomationRevision, listAutomations, saveAutomation, saveAutomations };

package/dist/src/automations/storage/automation-run-repository.d.ts

@@ -1,4 +1,7 @@
-import type { AutomationProductEventRun, AutomationRun, AutomationRunEvent } from '../domain/types.js';
+import type { Automation, AutomationProductEventRun, AutomationRun, AutomationRunEvent } from '../domain/types.js';
+export declare function saveAutomationRunRequest(runId: string, automation: Automation): void;
+export declare function getAutomationRunRequest(runId: string): Automation | null;
+export declare function listUnfinishedAutomationRuns(): AutomationRun[];
 export declare function appendAutomationRunEvent(event: AutomationRunEvent): void;
 export declare function saveAutomationRun(run: AutomationRun): void;
 export declare function touchAutomationRunLease(runId: string, leaseOwner: string, heartbeatAtMs: number, leaseExpiresAtMs: number): void;

package/dist/src/automations/storage/automation-run-repository.js

@@ -1,4 +1,5 @@
 import { getSqliteDatabase, init_transaction, runSqliteWriteTransaction } from "../../storage/sqlite/transaction.js";
+import { AutomationSchema } from "../domain/validation.js";
 //#region src/automations/storage/automation-run-repository.ts
 init_transaction();
 const MAX_RUNS_PER_AUTOMATION = 2e3;
@@ -48,13 +49,24 @@ function rowToEvent(row) {
 function trimRuns(db, automationId) {
 	const countRow = db.prepare(`SELECT COUNT(*) AS count FROM automation_runs WHERE automation_id = ?`).get(automationId);
 	if (countRow.count <= MAX_RUNS_PER_AUTOMATION) return;
-	const staleRunIds = db.prepare(`SELECT run_id FROM automation_runs WHERE automation_id = ?
+	const staleRunIds = db.prepare(`SELECT run_id FROM automation_runs WHERE automation_id = ? AND status NOT IN ('queued', 'running', 'cancelling')
        ORDER BY created_at_ms ASC LIMIT ?`).all(automationId, countRow.count - TRIM_TO_RUNS);
 	for (const { run_id: runId } of staleRunIds) {
+		db.prepare("DELETE FROM automation_run_requests WHERE run_id = ?").run(runId);
 		db.prepare(`DELETE FROM automation_run_events WHERE run_id = ?`).run(runId);
 		db.prepare(`DELETE FROM automation_runs WHERE run_id = ?`).run(runId);
 	}
 }
+function saveAutomationRunRequest(runId, automation) {
+	getSqliteDatabase().prepare("INSERT INTO automation_run_requests (run_id, automation_json) VALUES (?, ?)").run(runId, JSON.stringify(automation));
+}
+function getAutomationRunRequest(runId) {
+	const row = getSqliteDatabase().prepare("SELECT automation_json FROM automation_run_requests WHERE run_id = ?").get(runId);
+	return row ? AutomationSchema.parse(JSON.parse(String(row.automation_json))) : null;
+}
+function listUnfinishedAutomationRuns() {
+	return getSqliteDatabase().prepare("SELECT * FROM automation_runs WHERE status IN ('queued', 'running', 'cancelling') ORDER BY created_at_ms ASC").all().map(rowToRun);
+}
 function appendAutomationRunEvent(event) {
 	runSqliteWriteTransaction((db) => {
 		db.prepare(`INSERT INTO automation_run_events (
@@ -163,12 +175,13 @@ function listAutomationRunsForProductEvent(options) {
 }
 function deleteAutomationRunsForAutomation(automationId) {
 	runSqliteWriteTransaction((db) => {
+		db.prepare("DELETE FROM automation_run_requests WHERE run_id IN (SELECT run_id FROM automation_runs WHERE automation_id = ?)").run(automationId);
 		db.prepare(`DELETE FROM automation_run_events WHERE automation_id = ?`).run(automationId);
 		db.prepare(`DELETE FROM automation_runs WHERE automation_id = ?`).run(automationId);
 	});
 }
 function markAutomationRunRead(runId, readAtMs = Date.now()) {
-	return getSqliteDatabase().prepare(`UPDATE automation_runs SET read_at_ms = ? WHERE run_id = ? AND ended_at_ms IS NOT NULL`).run(readAtMs, runId).changes > 0;
+	return getSqliteDatabase().prepare(`UPDATE automation_runs SET read_at_ms = COALESCE(read_at_ms, ?) WHERE run_id = ? AND ended_at_ms IS NOT NULL`).run(readAtMs, runId).changes > 0;
 }
 function markAllAutomationRunsRead(options) {
 	const projectId = options?.projectId?.trim();
@@ -183,4 +196,4 @@ function markAllAutomationRunsRead(options) {
 	return Number(result.changes);
 }
 //#endregion
-export { appendAutomationRunEvent, deleteAutomationRunsForAutomation, getAutomationRun, listAutomationRunEvents, listAutomationRuns, listAutomationRunsForProductEvent, markAllAutomationRunsRead, markAutomationRunRead, saveAutomationRun, touchAutomationRunLease };
+export { appendAutomationRunEvent, deleteAutomationRunsForAutomation, getAutomationRun, getAutomationRunRequest, listAutomationRunEvents, listAutomationRuns, listAutomationRunsForProductEvent, listUnfinishedAutomationRuns, markAllAutomationRunsRead, markAutomationRunRead, saveAutomationRun, saveAutomationRunRequest, touchAutomationRunLease };

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

@@ -1,3 +1,3 @@
-import { deleteAutomation, getAutomation, listAutomations, saveAutomation, saveAutomations } from "./automation-repository.js";
-import { appendAutomationRunEvent, deleteAutomationRunsForAutomation, getAutomationRun, listAutomationRunEvents, listAutomationRuns, listAutomationRunsForProductEvent, markAllAutomationRunsRead, markAutomationRunRead, saveAutomationRun, touchAutomationRunLease } from "./automation-run-repository.js";
-export { appendAutomationRunEvent, deleteAutomation, deleteAutomationRunsForAutomation, getAutomation, getAutomationRun, listAutomationRunEvents, listAutomationRuns, listAutomationRunsForProductEvent, listAutomations, markAllAutomationRunsRead, markAutomationRunRead, saveAutomation, saveAutomationRun, saveAutomations, touchAutomationRunLease };
+import { deleteAutomation, getAutomation, getDeletedAutomationRevision, listAutomations, saveAutomation, saveAutomations } from "./automation-repository.js";
+import { appendAutomationRunEvent, deleteAutomationRunsForAutomation, getAutomationRun, getAutomationRunRequest, listAutomationRunEvents, listAutomationRuns, listAutomationRunsForProductEvent, listUnfinishedAutomationRuns, markAllAutomationRunsRead, markAutomationRunRead, saveAutomationRun, saveAutomationRunRequest, touchAutomationRunLease } from "./automation-run-repository.js";
+export { appendAutomationRunEvent, deleteAutomation, deleteAutomationRunsForAutomation, getAutomation, getAutomationRun, getAutomationRunRequest, getDeletedAutomationRevision, listAutomationRunEvents, listAutomationRuns, listAutomationRunsForProductEvent, listAutomations, listUnfinishedAutomationRuns, markAllAutomationRunsRead, markAutomationRunRead, saveAutomation, saveAutomationRun, saveAutomationRunRequest, saveAutomations, touchAutomationRunLease };

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

@@ -7,8 +7,8 @@ export declare const BrowserAutomationDefinitionSchema: z.ZodObject<{
     risk: z.ZodEnum<{
         read: "read";
         draft: "draft";
-        sensitive: "sensitive";
         destructive: "destructive";
+        sensitive: "sensitive";
         external_effect: "external_effect";
     }>;
     inputs: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{

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

@@ -25,7 +25,7 @@ export declare class BrowserAutomationService {
         id: string;
         name: string;
         allowedDomains: string[];
-        risk: "read" | "draft" | "sensitive" | "destructive" | "external_effect";
+        risk: "read" | "draft" | "destructive" | "sensitive" | "external_effect";
         inputs: Record<string, {
             type: "string" | "number" | "boolean";
             required?: boolean;

package/dist/src/browser/observation/format.js

@@ -15,6 +15,10 @@ function formatBrowserObservation(observation) {
 	const { added, changed, removed } = observation.changes;
 	if (added.length || changed.length || removed.length) lines.push(`Changes: +${added.length} ~${changed.length} -${removed.length}`);
 	if (observation.visual) lines.push("Visual screenshot attached.");
+	if (observation.truncation) {
+		const omitted = observation.truncation.omittedNodeCount;
+		lines.push(`Transport note: observation was reduced for delivery${omitted ? `; ${omitted} interactive elements omitted` : ""}.`);
+	}
 	return lines.join("\n");
 }
 function formatNode(node) {

package/dist/src/capabilities/adapters/http.d.ts

@@ -0,0 +1,4 @@
+import type { Context } from 'hono';
+import { type CapabilityContext } from '../runtime/dispatcher.js';
+export declare function capabilityHttpContext(c: Context): CapabilityContext;
+export declare function capabilityHttpError(c: Context, error: unknown): Response;