@xopcai/xopc 0.0.331 → 0.0.333

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

@@ -11,7 +11,7 @@ JSON shape:
     "action": { "kind": "agent", "instruction": "clear instruction for the agent" },
     "safety": { "mode": "suggest_only" },
     "conversationMode": "new_session",
-    "notificationPolicy": "attention",
+    "delivery": { "notificationPolicy": "attention" },
     "reliability": { "executionTimeoutSeconds": 300, "disableAfterConsecutiveFailures": 3 }
   },
   "explanation": "Short explanation",
@@ -52,7 +52,7 @@ Rules:
 - Use cron for daily/weekly schedules. Use standard 5-field cron.
 - Keep executionTimeoutSeconds between 60 and 1800.
 - Use conversationMode "new_session" unless the user explicitly wants each run to continue the same conversation.
-- Use notificationPolicy "attention" unless the user explicitly requests every-run notifications or no notifications.
+- Use delivery.notificationPolicy "attention" unless the user explicitly requests every-run notifications or no notifications.
 - Language for user-facing copy: ${params.language ?? "en"}.
 
 User request:
@@ -85,8 +85,7 @@ JSON shape:
     "action": "optional complete action object",
     "safety": "optional complete safety object",
     "conversationMode": "optional new_session or continuous",
-    "notificationPolicy": "optional attention, all, or none",
-    "completionWebhookUrl": "optional HTTPS URL",
+    "delivery": { "notificationPolicy": "optional attention, all, or none", "destinations": [{ "key": "stable key", "kind": "gateway_event or webhook", "endpoint": "HTTPS URL for webhook", "secretId": "outbound secret id for webhook" }] },
     "reliability": "optional complete reliability object",
     "enabled": true
   },

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

@@ -37,6 +37,9 @@ var AutomationDraftService = class {
 				maxTokens: 2048,
 				temperature: attempt === 0 ? .2 : .1,
 				signal
+			}, void 0, {
+				operation: "automation.generate_draft",
+				trigger: attempt === 0 ? "user" : "retry"
 			}));
 			try {
 				return buildAutomationDraftResponse(parseGeneratedAutomationDraft(lastText), attempt);
@@ -90,6 +93,9 @@ var AutomationDraftService = class {
 				maxTokens: 2048,
 				temperature: attempt === 0 ? .15 : .05,
 				signal
+			}, void 0, {
+				operation: "automation.generate_draft",
+				trigger: attempt === 0 ? "user" : "retry"
 			}));
 			try {
 				return parseGeneratedAutomationRepairDraft(lastText, attempt);

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

@@ -12,7 +12,28 @@ export declare function buildAutomationDraftResponse(draft: GeneratedAutomationD
     automation: {
         name: string;
         conversationMode: "new_session" | "continuous";
-        notificationPolicy: "attention" | "all" | "none";
+        delivery: {
+            notificationPolicy: "attention" | "all" | "none";
+            destinations: ({
+                key: string;
+                kind: "gateway_event";
+            } | {
+                key: string;
+                kind: "webhook";
+                secretId: string;
+                endpoint?: string;
+            } | {
+                key: string;
+                kind: "file";
+                targetId: string;
+                pathTemplate: string;
+            } | {
+                key: string;
+                kind: "card";
+                channelId: string;
+                templateId: string;
+            })[];
+        };
         projectId?: string;
         action?: {
             kind: "agent";
@@ -102,6 +123,9 @@ export declare function buildAutomationDraftResponse(draft: GeneratedAutomationD
                     outputDestinations: Record<string, unknown>[];
                 };
             };
+        } | {
+            kind: "system";
+            capability: "home.advisor.refresh" | "memory.temporal_sweep" | "memory.daily_reconciliation" | "memory.weekly_knowledge";
         };
         trigger?: {
             kind: "manual";
@@ -132,14 +156,18 @@ export declare function buildAutomationDraftResponse(draft: GeneratedAutomationD
         safety?: {
             mode: "suggest_only" | "ask_before_apply" | "auto_apply";
         };
-        completionWebhookUrl?: string;
         reliability?: {
             executionTimeoutSeconds?: number;
-            timeoutSeconds?: number;
             retryCount?: number;
             maxConcurrentRuns?: number;
             disableAfterConsecutiveFailures?: number;
         };
+        management?: {
+            owner: string;
+            editable: ("enabled" | "trigger")[];
+            runnable: boolean;
+            deletable: boolean;
+        };
         id?: string;
         enabled?: boolean;
         state?: {

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

@@ -54,9 +54,9 @@ function simulateAutomation(input) {
 	const triggerSummary = summarizeTrigger(automation.trigger);
 	const actionSummary = summarizeAction(automation.action);
 	if (automation.action.kind === "agent" && /delete|remove|send|post|publish|付款|删除|发送|发布/i.test(automation.action.instruction)) requiredConfirmations.push("Agent instruction may perform an external or destructive action.");
-	if (automation.completionWebhookUrl) {
-		safetyNotes.push("The completion webhook will call an external URL after each run.");
-		requiredConfirmations.push("External webhook call should be reviewed before publishing.");
+	if (automation.delivery.destinations.some((destination) => destination.kind === "webhook")) {
+		safetyNotes.push("The result webhook will call an external URL after each run.");
+		requiredConfirmations.push("External result delivery should be reviewed before publishing.");
 	}
 	const safetyMode = automation.safety?.mode ?? "auto_apply";
 	if (safetyMode === "suggest_only") safetyNotes.push("Suggest-only safety mode will generate recommendations without applying changes.");
@@ -92,11 +92,12 @@ function summarizeAction(action) {
 	if (action.kind === "workflow") return `Starts workflow ${action.workflowId}.`;
 	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}.`;
+	if (action.kind === "system") return `Runs system capability ${action.capability}.`;
 	return action.agentId ? `Runs agent ${action.agentId}.` : "Runs the default agent.";
 }
 function repairPatchNeedsApproval(patch) {
 	if (patch.safety?.mode === "auto_apply") return true;
-	if (patch.completionWebhookUrl) return true;
+	if (patch.delivery?.destinations.some((destination) => destination.kind === "webhook")) return true;
 	if (patch.trigger?.kind === "webhook") return true;
 	if (patch.action?.kind === "agent") return /delete|remove|send|post|publish|付款|删除|发送|发布/i.test(patch.action.instruction);
 	return false;

package/dist/src/automations/events/event-catalog.d.ts

@@ -0,0 +1,14 @@
+import { type ZodType } from 'zod';
+import type { AutomationEventEnvelope } from '../domain/types.js';
+export interface BusinessEventDefinition<TPayload extends Record<string, unknown> = Record<string, unknown>> {
+    type: string;
+    source: string;
+    schemaVersion: number;
+    payloadSchema: ZodType<TPayload>;
+    defaultTrust: Extract<AutomationEventEnvelope['trust'], 'system' | 'user' | 'connector'>;
+    description: string;
+    subjectKind: string;
+}
+export declare function registerBusinessEvent<TPayload extends Record<string, unknown>>(definition: BusinessEventDefinition<TPayload>): void;
+export declare function validateCatalogedBusinessEvent(event: AutomationEventEnvelope): void;
+export declare function listBusinessEventDefinitions(): BusinessEventDefinition[];

package/dist/src/automations/events/event-catalog.js

@@ -0,0 +1,117 @@
+import { z } from "zod";
+//#region src/automations/events/event-catalog.ts
+const definitions = /* @__PURE__ */ new Map();
+function catalogKey(type, source, schemaVersion) {
+	return `${source}\0${type}\0${schemaVersion}`;
+}
+function registerBusinessEvent(definition) {
+	const key = catalogKey(definition.type, definition.source, definition.schemaVersion);
+	if (definitions.has(key)) throw new Error(`Business event is already registered: ${definition.source}/${definition.type}@${definition.schemaVersion}`);
+	definitions.set(key, definition);
+}
+function validateCatalogedBusinessEvent(event) {
+	const definition = definitions.get(catalogKey(event.type, event.source, event.schemaVersion));
+	if (!definition) return;
+	if (event.subject?.kind !== definition.subjectKind) throw new Error(`Business event subject must be ${definition.subjectKind}: ${event.type}`);
+	definition.payloadSchema.parse(event.payload);
+}
+function listBusinessEventDefinitions() {
+	return [...definitions.values()].toSorted((left, right) => `${left.source}/${left.type}`.localeCompare(`${right.source}/${right.type}`));
+}
+const objectPayload = z.record(z.string(), z.unknown());
+for (const definition of [
+	[
+		"tasks",
+		"task.changed.v2",
+		"task",
+		"A Task changed."
+	],
+	[
+		"tasks",
+		"task.deleted.v1",
+		"task",
+		"A Task was deleted."
+	],
+	[
+		"notes",
+		"note.created",
+		"note",
+		"A Note was created."
+	],
+	[
+		"notes",
+		"note.updated",
+		"note",
+		"A Note changed."
+	],
+	[
+		"notes",
+		"note.deleted",
+		"note",
+		"A Note was deleted."
+	],
+	[
+		"projects",
+		"project.created",
+		"project",
+		"A Project was created."
+	],
+	[
+		"projects",
+		"project.changed",
+		"project",
+		"A Project changed."
+	],
+	[
+		"projects",
+		"project.deleted",
+		"project",
+		"A Project was deleted."
+	],
+	[
+		"scenes",
+		"scene.created",
+		"scene",
+		"A Scene was created."
+	],
+	[
+		"scenes",
+		"scene.changed",
+		"scene",
+		"A Scene changed."
+	],
+	[
+		"scenes",
+		"scene.deleted",
+		"scene",
+		"A Scene was deleted."
+	],
+	[
+		"discussions",
+		"discussion.completed",
+		"discussion",
+		"A Discussion completed."
+	],
+	[
+		"sessions",
+		"session.transcript.updated",
+		"session",
+		"A Session transcript changed."
+	],
+	[
+		"workflows",
+		"workflow.run.completed",
+		"workflow_run",
+		"A Workflow run completed."
+	]
+]) registerBusinessEvent({
+	source: definition[0],
+	type: definition[1],
+	subjectKind: definition[2],
+	description: definition[3],
+	schemaVersion: 1,
+	payloadSchema: objectPayload,
+	defaultTrust: "system"
+});
+//#endregion
+export { listBusinessEventDefinitions, registerBusinessEvent, validateCatalogedBusinessEvent };

package/dist/src/automations/events/event-dispatcher.d.ts

@@ -0,0 +1,27 @@
+import type { AutomationEventEnvelope, AutomationRun } from '../domain/types.js';
+import type { AutomationService } from '../service/automation-service.js';
+export declare class AutomationEventDispatcher {
+    private readonly automationService;
+    private readonly options;
+    private timer?;
+    private active?;
+    private stopping;
+    private readonly owner;
+    private readonly abortController;
+    constructor(automationService: AutomationService, options?: {
+        onEvent?: (event: AutomationEventEnvelope, signal?: AbortSignal) => void | Promise<void>;
+        onDeadLetter?: (input: {
+            phase: 'event_projection' | 'event_delivery';
+            eventId: string;
+            automationId?: string;
+            error: string;
+        }) => void;
+        intervalMs?: number;
+    });
+    start(): void;
+    stop(): Promise<void>;
+    dispatch(): Promise<number>;
+    runCompleted(run: AutomationRun): void;
+    private runDispatch;
+    private projectEvents;
+}

package/dist/src/automations/events/event-dispatcher.js

@@ -0,0 +1,140 @@
+import { createLogger } from "../../utils/logger/index.js";
+import { init_logger } from "../../utils/logger.js";
+import { init_transaction, runSqliteWriteTransaction } from "../../storage/sqlite/transaction.js";
+import { getAutomation } from "../storage/automation-repository.js";
+import "../storage/index.js";
+import { claimAutomationEventDeliveries, claimAutomationEventsForProjection, completeAutomationEventDelivery, completeAutomationEventProjection, deferAutomationEventDelivery, expireAutomationEventProjectionLeases, failAutomationEventProjection, markAutomationEventDeliveryQueued, reconcileAutomationEventDeliveries, releaseAutomationEventDelivery, releaseAutomationEventProjection, skipAutomationEventDelivery } from "./event-repository.js";
+import { randomUUID } from "node:crypto";
+//#region src/automations/events/event-dispatcher.ts
+init_transaction();
+init_logger();
+const log = createLogger("AutomationEventDispatcher");
+const DELIVERY_SCAN_BUDGET = 500;
+var AutomationEventDispatcher = class {
+	timer;
+	active;
+	stopping = false;
+	owner = `automation-event:${process.pid}:${randomUUID()}`;
+	abortController = new AbortController();
+	constructor(automationService, options = {}) {
+		this.automationService = automationService;
+		this.options = options;
+	}
+	start() {
+		if (this.timer) return;
+		this.stopping = false;
+		reconcileAutomationEventDeliveries();
+		this.dispatch();
+		this.timer = setInterval(() => void this.dispatch(), this.options.intervalMs ?? 1e3);
+		this.timer.unref?.();
+	}
+	async stop() {
+		this.stopping = true;
+		if (this.timer) clearInterval(this.timer);
+		this.timer = void 0;
+		this.abortController.abort(/* @__PURE__ */ new Error("Automation event dispatcher stopped"));
+		await this.active?.catch(() => void 0);
+	}
+	dispatch() {
+		if (this.stopping) return Promise.resolve(0);
+		this.active ??= this.runDispatch().finally(() => {
+			this.active = void 0;
+		});
+		return this.active;
+	}
+	runCompleted(run) {
+		completeAutomationEventDelivery(run.id, run.status);
+		if (!this.stopping) this.dispatch();
+	}
+	async runDispatch() {
+		await this.projectEvents();
+		const availableSlots = this.automationService.availableRunSlots();
+		if (availableSlots <= 0 || this.stopping) return 0;
+		let queued = 0;
+		const deliveries = claimAutomationEventDeliveries(this.owner, DELIVERY_SCAN_BUDGET);
+		for (const [index, delivery] of deliveries.entries()) {
+			if (queued >= availableSlots || this.stopping) {
+				for (const remaining of deliveries.slice(index)) releaseAutomationEventDelivery(remaining.event.id, remaining.automationId, this.owner, 0);
+				break;
+			}
+			const automation = getAutomation(delivery.automationId);
+			if (!automation || !automation.enabled) {
+				skipAutomationEventDelivery(delivery.event.id, delivery.automationId, "Automation is unavailable", this.owner);
+				continue;
+			}
+			if (automation.state.runningRunId) {
+				releaseAutomationEventDelivery(delivery.event.id, automation.id, this.owner);
+				continue;
+			}
+			try {
+				const run = runSqliteWriteTransaction(() => {
+					const next = this.automationService.queueRunAtomically(automation.id, {
+						manual: false,
+						event: delivery.event
+					});
+					markAutomationEventDeliveryQueued(delivery.event.id, automation.id, next.id, this.owner);
+					return next;
+				});
+				this.automationService.dispatchQueuedRun(run.id);
+				queued += 1;
+			} catch (error) {
+				if (error instanceof Error && error.name === "AutomationAlreadyRunningError") {
+					releaseAutomationEventDelivery(delivery.event.id, automation.id, this.owner);
+					continue;
+				}
+				const status = deferAutomationEventDelivery(delivery.event.id, automation.id, this.owner, error);
+				if (status === "dead_letter") this.options.onDeadLetter?.({
+					phase: "event_delivery",
+					eventId: delivery.event.id,
+					automationId: automation.id,
+					error: error instanceof Error ? error.message : String(error)
+				});
+				log.warn({
+					err: error,
+					eventId: delivery.event.id,
+					automationId: automation.id,
+					status
+				}, status === "dead_letter" ? "Automation event delivery moved to dead letter" : "Automation event delivery will retry");
+			}
+		}
+		return queued;
+	}
+	async projectEvents() {
+		for (const expired of expireAutomationEventProjectionLeases()) {
+			this.options.onDeadLetter?.({
+				phase: "event_projection",
+				...expired
+			});
+			log.warn(expired, "Automation event projection moved to dead letter after lease expiry");
+		}
+		for (const event of claimAutomationEventsForProjection(this.owner)) {
+			if (this.stopping) {
+				releaseAutomationEventProjection(event.id, this.owner);
+				continue;
+			}
+			try {
+				await this.options.onEvent?.(event, this.abortController.signal);
+				completeAutomationEventProjection(event.id, this.owner);
+			} catch (error) {
+				if (this.stopping || this.abortController.signal.aborted) {
+					releaseAutomationEventProjection(event.id, this.owner);
+					continue;
+				}
+				const status = failAutomationEventProjection(event.id, this.owner, error);
+				if (status === "dead_letter") this.options.onDeadLetter?.({
+					phase: "event_projection",
+					eventId: event.id,
+					error: error instanceof Error ? error.message : String(error)
+				});
+				log.warn({
+					err: error,
+					eventId: event.id,
+					eventType: event.type,
+					status
+				}, status === "dead_letter" ? "Automation event projection moved to dead letter" : "Automation event projection will retry");
+			}
+		}
+	}
+};
+//#endregion
+export { AutomationEventDispatcher };

package/dist/src/automations/events/event-repository.d.ts

@@ -0,0 +1,59 @@
+import type { AutomationEvent, AutomationEventDeliveryStatus, AutomationEventEnvelope, AutomationEventProjectionStatus, AutomationEventRecord, AutomationRunStatus } from '../domain/types.js';
+export interface ClaimedAutomationEventDelivery {
+    event: AutomationEventEnvelope;
+    automationId: string;
+    attempts: number;
+    owner: string;
+}
+export interface AutomationEventIngestResult {
+    event: AutomationEventEnvelope;
+    created: boolean;
+    deliveryCount: number;
+}
+export interface AutomationEventIngestOptions {
+    targetAutomationIds?: string[];
+}
+export interface AutomationEventPublisher {
+    publish(input: AutomationEvent, options?: AutomationEventIngestOptions): AutomationEventIngestResult;
+}
+export declare function ingestAutomationEvent(input: AutomationEvent, options?: AutomationEventIngestOptions): AutomationEventIngestResult;
+export declare const automationEventPublisher: AutomationEventPublisher;
+export declare function listAutomationEvents(input?: {
+    type?: string;
+    source?: string;
+    subjectKind?: string;
+    subjectId?: string;
+    limit?: number;
+    newestFirst?: boolean;
+}): AutomationEventEnvelope[];
+export declare function listAutomationEventRecords(input?: {
+    type?: string;
+    source?: string;
+    limit?: number;
+}): AutomationEventRecord[];
+export declare function claimAutomationEventsForProjection(owner: string, limit?: number, leaseMs?: number): AutomationEventEnvelope[];
+export declare function expireAutomationEventProjectionLeases(): Array<{
+    eventId: string;
+    error: string;
+}>;
+export declare function completeAutomationEventProjection(eventId: string, owner: string): void;
+export declare function releaseAutomationEventProjection(eventId: string, owner: string): void;
+export declare function failAutomationEventProjection(eventId: string, owner: string, error: unknown): AutomationEventProjectionStatus;
+export declare function claimAutomationEventDeliveries(owner: string, limit: number, leaseMs?: number): ClaimedAutomationEventDelivery[];
+export declare function releaseAutomationEventDelivery(eventId: string, automationId: string, owner: string, delayMs?: number): void;
+export declare function getAutomationEventDeliveryRunId(eventId: string, automationId: string): string | null;
+export declare function getAutomationEventForRun(runId: string): AutomationEventEnvelope | null;
+export declare function markAutomationEventDeliveryQueued(eventId: string, automationId: string, runId: string, owner?: string): void;
+export declare function deferAutomationEventDelivery(eventId: string, automationId: string, owner: string, error: unknown): AutomationEventDeliveryStatus;
+export declare function skipAutomationEventDelivery(eventId: string, automationId: string, reason: string, owner?: string): void;
+export declare function completeAutomationEventDelivery(runId: string, runStatus: AutomationRunStatus): void;
+export declare function reconcileAutomationEventDeliveries(): number;
+export declare function replayAutomationEvent(eventId: string): boolean;
+export declare function getAutomationEventQueueMetrics(): {
+    pending: number;
+    oldestPendingAgeMs: number;
+    projectionDeadLetters: number;
+    pendingDeliveries: number;
+    deliveryDeadLetters: number;
+    activeLeases: number;
+};