@xopcai/xopc 0.0.179 → 0.0.187

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

@@ -39,6 +39,67 @@ export declare function buildAutomationDraftResponse(draft: GeneratedAutomationD
             recipeId: string;
             args?: Record<string, unknown>;
             timeoutSeconds?: number;
+        } | {
+            kind: "task_command";
+            taskId: string;
+            command?: {
+                type: "mark_ready";
+            } | {
+                type: "start";
+                executor?: {
+                    kind: "agent";
+                    agentId: string;
+                } | {
+                    kind: "workflow";
+                    workflowId: string;
+                    workflowVersion?: string;
+                    input?: unknown;
+                } | {
+                    kind: "human";
+                    actorId: string;
+                } | {
+                    kind: "external";
+                    provider: string;
+                    config: unknown;
+                };
+                scheduleAt?: number;
+            } | {
+                type: "request_review";
+            } | {
+                type: "close";
+                resolution: "cancelled" | "done" | "duplicate" | "wont_do";
+            } | {
+                type: "reopen";
+                phase: "active" | "ready";
+            } | {
+                type: "add_wait";
+                wait: {
+                    kind: "paused" | "approval" | "dependency" | "user_input" | "external_event" | "scheduled_time" | "retry_backoff";
+                    reason: string;
+                    condition: Record<string, unknown>;
+                    resumeAt?: number;
+                };
+            } | {
+                type: "resolve_wait";
+                waitId: string;
+                resolution?: unknown;
+            } | {
+                type: "delegate";
+                agentId?: string;
+            } | {
+                type: "revise_contract";
+                contract: {
+                    objective: string;
+                    expectedOutputs: string[];
+                    acceptanceCriteria: string[];
+                    constraints: string[];
+                    approvalRequired: string[];
+                    assumptions: string[];
+                    risks: string[];
+                    acceptancePolicy: "manual" | "verified_auto" | "verified_then_review";
+                    outputDestinations: Record<string, unknown>[];
+                };
+            };
         };
         description?: string;
         trigger?: {
@@ -78,6 +139,7 @@ export declare function buildAutomationDraftResponse(draft: GeneratedAutomationD
             url: string;
         };
         reliability?: {
+            executionTimeoutSeconds?: number;
             timeoutSeconds?: number;
             retryCount?: number;
             maxConcurrentRuns?: number;
@@ -89,7 +151,7 @@ export declare function buildAutomationDraftResponse(draft: GeneratedAutomationD
             nextRunAtMs?: number;
             runningRunId?: string;
             lastRunAtMs?: number;
-            lastRunStatus?: "queued" | "running" | "failed" | "cancelled" | "timeout" | "succeeded";
+            lastRunStatus?: "failed" | "succeeded" | "running" | "queued" | "cancelled" | "timeout" | "cancelling";
             lastError?: string;
             consecutiveFailures?: number;
         };

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

@@ -91,6 +91,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 === "task_command") return `Applies ${action.command?.type ?? "a command"} to task ${action.taskId}.`;
 	return action.agentId ? `Runs agent ${action.agentId}.` : "Runs the default agent.";
 }
 function repairPatchNeedsApproval(patch) {

package/dist/src/automations/index.js

@@ -1,9 +1,9 @@
-import { onAutomationProductEvent, publishAutomationProductEvent } from "./product-events.js";
-import { DEFAULT_AUTOMATION_TIMEOUT_SECONDS } from "./domain/defaults.js";
+import { DEFAULT_AUTOMATION_TIMEOUT_SECONDS, DEFAULT_BROWSER_AUTOMATION_TIMEOUT_SECONDS, defaultAutomationTimeoutSeconds, resolveAutomationTimeoutSeconds } from "./domain/defaults.js";
 import { computeNextAutomationRunAtMs, computeNextScheduleRunAtMs, timerDelayUntil } from "./domain/schedule.js";
 import { AutomationActionSchema, AutomationAfterRunSchema, AutomationReliabilitySchema, AutomationSafetyPolicySchema, AutomationScheduleSchema, AutomationSchema, AutomationStateSchema, AutomationTriggerSchema, CreateAutomationSchema, UpdateAutomationSchema } from "./domain/validation.js";
 import "./domain/index.js";
 import { AutomationActionExecutor } from "./service/action-executor.js";
 import { AutomationAlreadyRunningError, AutomationService } from "./service/automation-service.js";
 import "./service/index.js";
-export { AutomationActionExecutor, AutomationActionSchema, AutomationAfterRunSchema, AutomationAlreadyRunningError, AutomationReliabilitySchema, AutomationSafetyPolicySchema, AutomationScheduleSchema, AutomationSchema, AutomationService, AutomationStateSchema, AutomationTriggerSchema, CreateAutomationSchema, DEFAULT_AUTOMATION_TIMEOUT_SECONDS, UpdateAutomationSchema, computeNextAutomationRunAtMs, computeNextScheduleRunAtMs, onAutomationProductEvent, publishAutomationProductEvent, timerDelayUntil };
+import { onAutomationProductEvent, publishAutomationProductEvent } from "./product-events.js";
+export { AutomationActionExecutor, AutomationActionSchema, AutomationAfterRunSchema, AutomationAlreadyRunningError, AutomationReliabilitySchema, AutomationSafetyPolicySchema, AutomationScheduleSchema, AutomationSchema, AutomationService, AutomationStateSchema, AutomationTriggerSchema, CreateAutomationSchema, DEFAULT_AUTOMATION_TIMEOUT_SECONDS, DEFAULT_BROWSER_AUTOMATION_TIMEOUT_SECONDS, UpdateAutomationSchema, computeNextAutomationRunAtMs, computeNextScheduleRunAtMs, defaultAutomationTimeoutSeconds, onAutomationProductEvent, publishAutomationProductEvent, resolveAutomationTimeoutSeconds, timerDelayUntil };

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

@@ -1,8 +1,8 @@
-import type { Automation, AutomationActionOutcome, AutomationDeps, AutomationRun } from '../domain/types.js';
+import type { Automation, AutomationActionExecutionHooks, AutomationActionTask, AutomationDeps, AutomationRun } from '../domain/types.js';
 export declare class AutomationActionExecutor {
     private deps;
     setDeps(deps: AutomationDeps): void;
-    execute(automation: Automation, run: AutomationRun, signal: AbortSignal): Promise<AutomationActionOutcome>;
+    execute(automation: Automation, run: AutomationRun, signal: AbortSignal, hooks?: AutomationActionExecutionHooks): Promise<AutomationActionTask>;
     private executeWithoutTimeout;
     private executeBrowserRecipe;
     private executeAgent;

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

@@ -2,35 +2,71 @@ import { createLogger } from "../../utils/logger/index.js";
 import { init_logger } from "../../utils/logger.js";
 import { init_agent_scope, normalizeAgentId } from "../../agent/agent-scope.js";
 import { buildSessionKey, init_session_key } from "../../routing/session-key.js";
-import "../domain/defaults.js";
+import { resolveAutomationTimeoutSeconds } from "../domain/defaults.js";
 import crypto from "node:crypto";
 //#region src/automations/service/action-executor.ts
 init_agent_scope();
 init_session_key();
 init_logger();
 const log = createLogger("Automation:ActionExecutor");
-function withTimeout(promise, timeoutMs, signal) {
-	return new Promise((resolve, reject) => {
-		if (signal.aborted) {
-			reject(/* @__PURE__ */ new Error("Automation run was cancelled"));
-			return;
+const CANCELLATION_GRACE_MS = 1e4;
+var AutomationExecutionStoppedError = class extends Error {
+	constructor(status, cancellationConfirmed, deadlineAtMs, timeoutMs) {
+		super(status === "timeout" ? `Automation timed out after ${timeoutMs}ms` : "Automation run was cancelled");
+		this.status = status;
+		this.cancellationConfirmed = cancellationConfirmed;
+		this.deadlineAtMs = deadlineAtMs;
+		this.name = "AutomationExecutionStoppedError";
+	}
+};
+async function waitForCancellation(promise) {
+	let timer;
+	try {
+		return await Promise.race([promise.then(() => true, () => true), new Promise((resolve) => {
+			timer = setTimeout(() => resolve(false), CANCELLATION_GRACE_MS);
+		})]);
+	} finally {
+		if (timer) clearTimeout(timer);
+	}
+}
+async function executeWithDeadline(operation, timeoutMs, parentSignal, deadlineAtMs) {
+	const controller = new AbortController();
+	let stoppedAs;
+	const stop = (status, reason) => {
+		if (controller.signal.aborted) return;
+		stoppedAs = status;
+		controller.abort(reason);
+	};
+	const onParentAbort = () => stop("cancelled", parentSignal.reason);
+	parentSignal.addEventListener("abort", onParentAbort, { once: true });
+	if (parentSignal.aborted) onParentAbort();
+	const timer = setTimeout(() => stop("timeout", /* @__PURE__ */ new Error(`Automation timed out after ${timeoutMs}ms`)), Math.max(0, deadlineAtMs - Date.now()));
+	const operationPromise = operation(controller.signal);
+	const rejectForAbort = () => {
+		throw controller.signal.reason ?? /* @__PURE__ */ new Error("Automation run was cancelled");
+	};
+	let removeDeadlineAbortListener;
+	const abortPromise = new Promise((_, reject) => {
+		const rejectPromise = () => reject(controller.signal.reason ?? /* @__PURE__ */ new Error("Automation run was cancelled"));
+		if (controller.signal.aborted) rejectPromise();
+		else {
+			controller.signal.addEventListener("abort", rejectPromise, { once: true });
+			removeDeadlineAbortListener = () => controller.signal.removeEventListener("abort", rejectPromise);
 		}
-		const timer = setTimeout(() => reject(/* @__PURE__ */ new Error(`Automation timed out after ${timeoutMs}ms`)), timeoutMs);
-		const onAbort = () => {
-			clearTimeout(timer);
-			reject(/* @__PURE__ */ new Error("Automation run was cancelled"));
-		};
-		signal.addEventListener("abort", onAbort, { once: true });
-		promise.then((value) => {
-			clearTimeout(timer);
-			signal.removeEventListener("abort", onAbort);
-			resolve(value);
-		}, (err) => {
-			clearTimeout(timer);
-			signal.removeEventListener("abort", onAbort);
-			reject(err);
-		});
 	});
+	try {
+		const result = await Promise.race([operationPromise, abortPromise]);
+		if (stoppedAs) rejectForAbort();
+		return result;
+	} catch (err) {
+		if (!stoppedAs) throw err;
+		const cancellationConfirmed = await waitForCancellation(operationPromise);
+		throw new AutomationExecutionStoppedError(stoppedAs, cancellationConfirmed, deadlineAtMs, timeoutMs);
+	} finally {
+		clearTimeout(timer);
+		parentSignal.removeEventListener("abort", onParentAbort);
+		removeDeadlineAbortListener?.();
+	}
 }
 var AutomationActionExecutor = class {
 	deps = {};
@@ -40,26 +76,61 @@ var AutomationActionExecutor = class {
 			...deps
 		};
 	}
-	async execute(automation, run, signal) {
-		const timeoutMs = (automation.action.timeoutSeconds ?? automation.reliability?.timeoutSeconds ?? 0) > 0 ? (automation.action.timeoutSeconds ?? automation.reliability?.timeoutSeconds) * 1e3 : 300 * 1e3;
-		return withTimeout(this.executeWithoutTimeout(automation, run, signal), timeoutMs, signal).catch((err) => {
+	async execute(automation, run, signal, hooks = {}) {
+		const configuredTimeoutMs = resolveAutomationTimeoutSeconds(automation.action, automation.reliability) * 1e3;
+		const deadlineAtMs = run.deadlineAtMs ?? Date.now() + configuredTimeoutMs;
+		const timeoutMs = Math.max(1, deadlineAtMs - Date.now());
+		await hooks.onRunPatch?.({ deadlineAtMs });
+		return executeWithDeadline((deadlineSignal) => this.executeWithoutTimeout(automation, run, deadlineSignal, hooks, deadlineAtMs), timeoutMs, signal, deadlineAtMs).catch((err) => {
 			const message = err instanceof Error ? err.message : String(err);
+			if (err instanceof AutomationExecutionStoppedError) return {
+				status: err.status,
+				error: message,
+				deadlineAtMs: err.deadlineAtMs,
+				termination: {
+					reason: err.status === "timeout" ? "deadline_exceeded" : "user_cancelled",
+					component: "automation",
+					cancellationConfirmed: err.cancellationConfirmed
+				}
+			};
 			return {
 				status: message.toLowerCase().includes("cancelled") ? "cancelled" : message.toLowerCase().includes("timed out") ? "timeout" : "failed",
-				error: message
+				error: message,
+				deadlineAtMs
 			};
 		});
 	}
-	async executeWithoutTimeout(automation, run, signal) {
+	async executeWithoutTimeout(automation, run, signal, hooks, deadlineAtMs) {
 		if (signal.aborted) return {
 			status: "cancelled",
 			error: "Automation run was cancelled"
 		};
-		if (automation.action.kind === "workflow") return this.executeWorkflow(automation, automation.action, run);
-		if (automation.action.kind === "browser_recipe") return this.executeBrowserRecipe(automation, automation.action, signal);
-		return this.executeAgent(automation, automation.action);
+		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 === "task_command") {
+			await hooks.onRunPatch?.({ currentPhase: "action" });
+			const execute = this.deps.executeTaskCommand;
+			if (!execute) return {
+				status: "failed",
+				error: "Task command executor is unavailable"
+			};
+			const result = execute({
+				taskId: automation.action.taskId,
+				idempotencyKey: `automation:${automation.id}:${run.id}`,
+				command: automation.action.command
+			});
+			return result.ok ? {
+				status: "succeeded",
+				summary: result.runId ? `TaskRun ${result.runId} queued` : "Task command applied"
+			} : {
+				status: "failed",
+				error: result.reason ?? "Task command failed"
+			};
+		}
+		return this.executeAgent(automation, automation.action, run, signal, hooks, deadlineAtMs);
 	}
-	async executeBrowserRecipe(automation, action, signal) {
+	async executeBrowserRecipe(automation, action, signal, hooks) {
+		await hooks.onRunPatch?.({ currentPhase: "action" });
 		const safetyMode = automation.safety?.mode ?? "auto_apply";
 		if (safetyMode !== "auto_apply") return {
 			status: "succeeded",
@@ -80,7 +151,7 @@ var AutomationActionExecutor = class {
 			error: run.error ?? `Browser automation ${action.recipeId} ${run.status}`
 		};
 	}
-	async executeAgent(automation, action) {
+	async executeAgent(automation, action, run, signal, hooks, deadlineAtMs) {
 		const agentService = this.deps.agentService;
 		if (!agentService?.turnDispatcher?.processDirect) return {
 			status: "failed",
@@ -94,6 +165,10 @@ var AutomationActionExecutor = class {
 			peerId: `${automation.id}-${crypto.randomUUID().slice(0, 8)}`
 		});
 		const effectiveWorkingDirectory = action.workingDirectory ?? (automation.projectId ? this.deps.getProjectWorkspaceRoot?.(automation.projectId) : void 0);
+		await hooks.onRunPatch?.({
+			sessionKey,
+			currentPhase: "action"
+		});
 		await agentService.sessionConfig?.applyAutomationWorkingDirectory?.(sessionKey, effectiveWorkingDirectory);
 		if (agentService.sessionConfig?.applyAutomationModelOverride) {
 			if (!await agentService.sessionConfig.applyAutomationModelOverride(sessionKey, action.model) && action.model) log.warn({
@@ -102,7 +177,11 @@ var AutomationActionExecutor = class {
 				model: action.model
 			}, "Automation model override invalid; using agent default");
 		}
-		const response = await agentService.turnDispatcher.processDirect(buildSafetyInstruction(automation, action.instruction), sessionKey);
+		const response = await agentService.turnDispatcher.processDirect(buildSafetyInstruction(automation, action.instruction), sessionKey, void 0, void 0, {
+			signal,
+			runId: run.id,
+			deadlineAtMs
+		});
 		const model = agentService.getModelForSession?.(sessionKey);
 		return {
 			status: "succeeded",
@@ -111,7 +190,7 @@ var AutomationActionExecutor = class {
 			model
 		};
 	}
-	async executeWorkflow(automation, action, run) {
+	async executeWorkflow(automation, action, run, signal, hooks) {
 		const safetyMode = automation.safety?.mode ?? "auto_apply";
 		if (safetyMode === "suggest_only") return {
 			status: "succeeded",
@@ -148,20 +227,71 @@ var AutomationActionExecutor = class {
 			status: "failed",
 			error: result.message
 		};
-		return {
+		await hooks.onRunPatch?.({
+			sessionKey: result.sessionKey,
+			workflowRunId: result.runId,
+			currentPhase: "action"
+		});
+		if (!workflowRunService.readWorkflowRunView) return {
 			status: "succeeded",
 			summary: `Started workflow run ${result.runId}`,
 			sessionKey: result.sessionKey,
 			workflowRunId: result.runId
 		};
+		while (!signal.aborted) {
+			const view = await workflowRunService.readWorkflowRunView(agentId, result.runId);
+			if (!view) return {
+				status: "failed",
+				error: `Workflow run ${result.runId} disappeared`
+			};
+			const workflowStatus = view.run.status;
+			if (workflowStatus === "succeeded") return {
+				status: "succeeded",
+				summary: `Workflow run ${result.runId} completed`,
+				sessionKey: result.sessionKey,
+				workflowRunId: result.runId
+			};
+			if (workflowStatus === "failed" || workflowStatus === "cancelled" || workflowStatus === "timeout") return {
+				status: workflowStatus,
+				error: view.run.error?.message ?? `Workflow run ${result.runId} ${workflowStatus}`,
+				sessionKey: result.sessionKey,
+				workflowRunId: result.runId
+			};
+			await waitForSignalOrDelay(signal, 500);
+		}
+		await workflowRunService.cancelWorkflowRun?.({
+			agentId,
+			runId: result.runId,
+			reason: "Parent automation was cancelled or reached its deadline"
+		});
+		return {
+			status: "cancelled",
+			error: "Parent automation stopped while the workflow was running",
+			sessionKey: result.sessionKey,
+			workflowRunId: result.runId
+		};
 	}
 };
+function waitForSignalOrDelay(signal, delayMs) {
+	return new Promise((resolve) => {
+		const timer = setTimeout(() => {
+			signal.removeEventListener("abort", onAbort);
+			resolve();
+		}, delayMs);
+		const onAbort = () => {
+			clearTimeout(timer);
+			resolve();
+		};
+		if (signal.aborted) onAbort();
+		else signal.addEventListener("abort", onAbort, { once: true });
+	});
+}
 function buildSafetyInstruction(automation, instruction) {
 	const mode = automation.safety?.mode ?? "auto_apply";
 	if (mode === "suggest_only") return [
 		"Automation safety mode: Suggest only.",
 		"Only analyze the situation and produce a concise recommendation.",
-		"Do not modify files, notes, goals, workflows, external systems, or persistent state.",
+		"Do not modify files, notes, Tasks, workflows, external systems, or persistent state.",
 		"If a change seems useful, describe the exact change for the user to review.",
 		"",
 		instruction

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

@@ -15,6 +15,8 @@ export declare class AutomationService {
     private deps;
     private maxConcurrentRuns;
     private readonly activeRuns;
+    private readonly heartbeatTimers;
+    private readonly leaseOwner;
     constructor(signals?: ProactiveSignalPublisher);
     setDeps(deps: AutomationDeps): void;
     initialize(options?: {
@@ -54,6 +56,8 @@ export declare class AutomationService {
     private onTimer;
     private startRun;
     private executeRun;
+    private recoverInterruptedRuns;
+    private waitForRetry;
     private appendRunEvent;
     private finishAutomationRun;
     private postAfterRunWebhook;