@xopcai/xopc 0.0.426 → 0.0.428

package/dist/src/automations/mcp-source.d.ts

@@ -0,0 +1,60 @@
+import type { ExtensionFactory } from '@earendil-works/pi-coding-agent';
+import { z } from 'zod';
+import type { Config } from '../config/schema.js';
+import type { NativeMcpConfig } from '../agent/mcp/native-mcp.js';
+export declare const AutomationMcpSourceInput: z.ZodObject<{
+    serverId: z.ZodString;
+    toolNames: z.ZodArray<z.ZodString>;
+    toolInputs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodJSONSchema>>>;
+}, z.core.$strict>;
+type Source = {
+    id: string;
+    agentId: string;
+    serverId: string;
+    revision: string;
+    workspaceDir: string;
+    tools: Array<{
+        name: string;
+        digest: string;
+        argumentsHash?: string;
+    }>;
+    createdAtMs: number;
+};
+export declare class AutomationMcpSourceError extends Error {
+}
+export declare function getAutomationMcpSource(id: string, agentId: string): Source;
+export declare function assertAutomationMcpSource(source: Source, config: Config): void;
+/** Discovery is outside SQLite write transactions; the saved reference contains no credentials. */
+export declare function prepareAutomationMcpSource(input: unknown, context: {
+    conversationId?: string;
+    agentId?: string;
+    canConfigure: boolean;
+    readConfig: () => Config;
+    workspaceDir: string;
+    signal?: AbortSignal;
+}): Promise<{
+    sourceId: string;
+    serverId: string;
+    agentId: string;
+    toolNames: string[];
+    fixedInputs: {
+        [k: string]: Record<string, z.core.util.JSONType>;
+    };
+    verified: boolean;
+    accountIdentityVerified: boolean;
+    instruction: string;
+}>;
+/** A run cannot succeed from a model answer alone or silently select a different service. */
+export declare function withAutomationMcpSource<T>(input: {
+    runId: string;
+    conversationId: string;
+    sourceId: string;
+    agentId: string;
+    readConfig: () => Config;
+    signal: AbortSignal;
+}, operation: () => Promise<T>): Promise<T>;
+export declare function boundAutomationMcpSource(runId: string, conversationId: string): Source | undefined;
+export declare function restrictAutomationMcpConfig(runId: string, conversationId: string, loaded: NativeMcpConfig): NativeMcpConfig;
+/** Native pi still executes tools. The guard pins the current contract at each actual call. */
+export declare function createAutomationMcpSourceGuard(runId: string): ExtensionFactory;
+export {};

package/dist/src/automations/mcp-source.js

@@ -0,0 +1,173 @@
+import { getSessionMetadata } from "../storage/sqlite/session-read-repository.js";
+import { init_session_repository } from "../storage/sqlite/session-repository.js";
+import { connectorPrincipalForSession } from "../connectors/principal.js";
+import { DurableState } from "../storage/sqlite/durable-state.js";
+import { isManagedConnectorServer } from "../connectors/materialize.js";
+import { discoverMcpTools } from "../agent/mcp/tool-catalog.js";
+import { mcpConfigRevision } from "../agent/mcp/connection-drafts.js";
+import { createHash } from "node:crypto";
+import { z } from "zod";
+//#region src/automations/mcp-source.ts
+init_session_repository();
+const AutomationMcpSourceInput = z.object({
+	serverId: z.string().min(1).max(64),
+	toolNames: z.array(z.string().min(1).max(300)).min(1).max(10),
+	toolInputs: z.record(z.string(), z.record(z.string(), z.json())).optional()
+}).strict();
+const sources = new DurableState("automation.mcp-source.v1");
+const executions = /* @__PURE__ */ new Map();
+var AutomationMcpSourceError = class extends Error {};
+const fail = (message) => {
+	throw new AutomationMcpSourceError(message);
+};
+const serverFor = (config, id) => Object.hasOwn(config.mcp?.servers ?? {}, id) ? config.mcp.servers[id] : void 0;
+const toolDigest = (tool) => mcpConfigRevision({
+	name: tool.name,
+	schema: tool.inputSchema,
+	annotations: tool.annotations
+});
+function getAutomationMcpSource(id, agentId) {
+	const source = sources.get(id);
+	if (!source || source.agentId !== agentId) return fail("The prepared MCP source is missing or belongs to another assistant. Prepare it again for the selected assistant.");
+	return source;
+}
+function assertAutomationMcpSource(source, config) {
+	const server = serverFor(config, source.serverId);
+	if (!server || server.enabled === false || mcpConfigRevision(server) !== source.revision) fail("The selected MCP source changed, was removed or is disabled. Reconnect and verify that source; no alternative source will be used.");
+}
+/** Discovery is outside SQLite write transactions; the saved reference contains no credentials. */
+async function prepareAutomationMcpSource(input, context) {
+	const args = AutomationMcpSourceInput.parse(input);
+	const session = context.conversationId ? getSessionMetadata(context.conversationId) : void 0;
+	if (!context.canConfigure || !session || session.agentId !== context.agentId || !connectorPrincipalForSession(context.conversationId).isLocalOwner) return fail("An active owner conversation is required to prepare an automation source.");
+	const config = structuredClone(context.readConfig()), server = serverFor(config, args.serverId);
+	if (!server?.url || server.enabled === false || isManagedConnectorServer(server) || server.xopcPlugin) return fail("This workflow supports an enabled custom HTTP MCP connection. Managed connectors and account-specific bindings require their own adapter.");
+	const catalog = await discoverMcpTools(config, context.workspaceDir, args.serverId, { signal: context.signal });
+	const selected = [...new Set(args.toolNames)].sort().map((name) => {
+		const tool = catalog.find((item) => item.name === name);
+		if (!tool || tool.exposure === "hidden" || tool.annotations?.readOnlyHint !== true || tool.annotations.destructiveHint === true) return fail("Select discovered, exposed MCP tools explicitly annotated read-only. No tool permissions will be widened.");
+		return {
+			name,
+			digest: toolDigest(tool),
+			argumentsHash: mcpConfigRevision(args.toolInputs?.[name] ?? {})
+		};
+	});
+	const fields = {
+		agentId: context.agentId,
+		serverId: args.serverId,
+		revision: mcpConfigRevision(server),
+		workspaceDir: context.workspaceDir,
+		tools: selected
+	};
+	const id = `mcp-source-${createHash("sha256").update(JSON.stringify(fields)).digest("hex")}`;
+	const source = {
+		...fields,
+		id,
+		createdAtMs: Date.now()
+	};
+	assertAutomationMcpSource(source, context.readConfig());
+	if (!sources.get(id)) sources.set(id, source);
+	return {
+		sourceId: id,
+		serverId: source.serverId,
+		agentId: source.agentId,
+		toolNames: selected.map((tool) => tool.name),
+		fixedInputs: Object.fromEntries(selected.map((tool) => [tool.name, args.toolInputs?.[tool.name] ?? {}])),
+		verified: false,
+		accountIdentityVerified: false,
+		instruction: "Create a disabled agent automation with action.mcpSourceId set to sourceId. Run an actual trial, inspect its terminal result, then enable the same object only when authorized. This pins the selected server and grant reference, not an independently verified remote account identity. Do not enable explicit-account workflows without their identity adapter."
+	};
+}
+/** A run cannot succeed from a model answer alone or silently select a different service. */
+async function withAutomationMcpSource(input, operation) {
+	const source = getAutomationMcpSource(input.sourceId, input.agentId);
+	assertAutomationMcpSource(source, input.readConfig());
+	const catalog = await discoverMcpTools(input.readConfig(), source.workspaceDir, source.serverId, { signal: input.signal });
+	assertAutomationMcpSource(source, input.readConfig());
+	if (source.tools.some((expected) => !catalog.some((tool) => tool.name === expected.name && tool.exposure !== "hidden" && toolDigest(tool) === expected.digest))) return fail("The selected MCP tool contract changed. Verify a new source before running again.");
+	if (executions.has(input.runId)) return fail("This source-bound run is already executing.");
+	const execution = {
+		source,
+		conversationId: input.conversationId,
+		readConfig: input.readConfig,
+		signal: input.signal,
+		successful: /* @__PURE__ */ new Set(),
+		failed: false
+	};
+	executions.set(input.runId, execution);
+	try {
+		const result = await operation();
+		input.signal.throwIfAborted();
+		assertAutomationMcpSource(source, input.readConfig());
+		if (execution.failed || source.tools.some((tool) => !execution.successful.has(tool.name))) return fail("The selected MCP read did not complete successfully in this run. An assistant answer is not verified source data.");
+		return result;
+	} finally {
+		executions.delete(input.runId);
+	}
+}
+function boundAutomationMcpSource(runId, conversationId) {
+	const execution = executions.get(runId);
+	if (execution && execution.conversationId !== conversationId) return fail("The MCP source belongs to a different execution conversation.");
+	return execution?.source;
+}
+function restrictAutomationMcpConfig(runId, conversationId, loaded) {
+	const source = boundAutomationMcpSource(runId, conversationId);
+	if (!source) return loaded;
+	const entry = loaded.servers.find((server) => server.name === source.serverId && server.config.enabled !== false);
+	if (!entry) return fail("The selected MCP source is not available to this execution.");
+	return {
+		...loaded,
+		errors: [],
+		automationSourceRunId: runId,
+		servers: [{
+			...entry,
+			config: {
+				...entry.config,
+				exposure: entry.config.exposure === "hidden" ? "hidden" : "deferred"
+			}
+		}]
+	};
+}
+/** Native pi still executes tools. The guard pins the current contract at each actual call. */
+function createAutomationMcpSourceGuard(runId) {
+	return (pi) => {
+		pi.on("tool_call", (event) => {
+			const execution = executions.get(runId);
+			if (!execution || execution.signal.aborted) return {
+				block: true,
+				reason: "The bound automation execution ended."
+			};
+			try {
+				assertAutomationMcpSource(execution.source, execution.readConfig());
+				if (event.toolName === "tool_search") return;
+				const expected = execution.source.tools.find((tool) => tool.name === event.toolName);
+				const actual = pi.getAllTools().find((tool) => tool.name === event.toolName);
+				if (!expected || !actual || actual.exposure === "hidden" || toolDigest({
+					name: actual.name,
+					inputSchema: actual.parameters,
+					annotations: actual.annotations
+				}) !== expected.digest || mcpConfigRevision(event.input ?? {}) !== (expected.argumentsHash ?? mcpConfigRevision({}))) {
+					execution.failed = true;
+					return {
+						block: true,
+						reason: "This tool is outside the pinned MCP read contract."
+					};
+				}
+			} catch {
+				execution.failed = true;
+				return {
+					block: true,
+					reason: "The selected MCP source changed. No alternative source is allowed."
+				};
+			}
+		});
+		pi.on("tool_result", (event) => {
+			const execution = executions.get(runId);
+			if (!execution || !execution.source.tools.some((tool) => tool.name === event.toolName)) return;
+			if (event.isError) execution.failed = true;
+			else execution.successful.add(event.toolName);
+		});
+	};
+}
+//#endregion
+export { AutomationMcpSourceError, AutomationMcpSourceInput, assertAutomationMcpSource, boundAutomationMcpSource, createAutomationMcpSourceGuard, getAutomationMcpSource, prepareAutomationMcpSource, restrictAutomationMcpConfig, withAutomationMcpSource };

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

@@ -6,6 +6,7 @@ import { init_model_usage, withModelUsageOrigin } from "../../providers/model-us
 import { init_session_key, resolveConversationId } from "../../routing/session-key.js";
 import { getAutomationRunRequest, listAutomationRuns } from "../storage/automation-run-repository.js";
 import "../storage/index.js";
+import { withAutomationMcpSource } from "../mcp-source.js";
 import { resolveAutomationTimeoutSeconds } from "../domain/defaults.js";
 //#region src/automations/service/action-executor.ts
 init_session_repository();
@@ -279,7 +280,7 @@ var AutomationActionExecutor = class {
 			}),
 			"</automation_handoff>"
 		].join("\n") : "";
-		const response = await agentService.turnDispatcher.processDirect(buildSafetyInstruction(automation, [appendTriggerContext(action.instruction, context.triggerEvent), handoff].filter(Boolean).join("\n\n")), conversationId, {
+		const process = () => agentService.turnDispatcher.processDirect(buildSafetyInstruction(automation, [appendTriggerContext(action.instruction, context.triggerEvent), handoff].filter(Boolean).join("\n\n")), conversationId, {
 			type: "system",
 			source: "automation"
 		}, void 0, void 0, {
@@ -287,6 +288,19 @@ var AutomationActionExecutor = class {
 			runId: run.id,
 			deadlineAtMs
 		});
+		if (action.mcpSourceId && !this.deps.getConfig) return {
+			status: "failed",
+			error: "The selected MCP source cannot be checked in this runtime.",
+			conversationId
+		};
+		const response = action.mcpSourceId ? await withAutomationMcpSource({
+			runId: run.id,
+			conversationId,
+			sourceId: action.mcpSourceId,
+			agentId,
+			readConfig: this.deps.getConfig,
+			signal
+		}, process) : await process();
 		const model = agentService.getModelForSession?.(conversationId);
 		return {
 			status: "succeeded",

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

@@ -1,9 +1,12 @@
+import type { AutomationDeliveryPolicy } from '../domain/types.js';
 import type { Automation, AutomationDeps, AutomationEvent, AutomationMetrics, AutomationProductEventRun, AutomationRun, AutomationRunEvent } from '../domain/types.js';
 import { type CreateAutomationInput, type UpdateAutomationInput } from '../domain/validation.js';
 export declare class AutomationInvalidScheduleError extends Error {
 }
 export declare class AutomationInvalidAgentError extends Error {
 }
+export declare class AutomationInvalidSourceError extends Error {
+}
 export declare class AutomationAlreadyRunningError extends Error {
     readonly automationId: string;
     readonly runningRunId?: string;
@@ -31,16 +34,21 @@ export declare class AutomationService {
         maxConcurrentRuns?: number;
     }): Promise<void>;
     stop(): Promise<void>;
+    bindConversationDelivery(conversationId: string | undefined, input: unknown): AutomationDeliveryPolicy;
     create(input: CreateAutomationInput): Promise<Automation>;
     /** SQLite-only creation; scheduling starts after the caller commits. */
     createAtomically(input: CreateAutomationInput): Automation;
     private applyCreate;
     private assertExecutionAgent;
+    private assertMcpSource;
     private prepareSchedule;
     private pinBrowserVersion;
     list(options?: {
         projectId?: string;
     }): Promise<Automation[]>;
+    executionSummaries(projectId?: string): Record<string, {
+        unreadCount: number;
+    }>;
     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. */
@@ -87,6 +95,10 @@ export declare class AutomationService {
         automationId?: string;
         projectId?: string;
         limit?: number;
+        before?: {
+            createdAtMs: number;
+            id: string;
+        };
     }): Promise<AutomationRun[]>;
     listRunsForProductEvent(options: {
         eventType: string;

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

@@ -1,19 +1,28 @@
 import { createLogger } from "../../utils/logger/index.js";
 import { init_logger } from "../../utils/logger.js";
 import { init_transaction, runSqliteWriteTransaction } from "../../storage/sqlite/transaction.js";
-import { AutomationSchema, CreateAutomationSchema, UpdateAutomationSchema } from "../domain/validation.js";
+import { getSessionMetadata } from "../../storage/sqlite/session-read-repository.js";
+import { init_session_repository } from "../../storage/sqlite/session-repository.js";
+import { normalizeAgentId } from "../../agent-catalog/id.js";
+import { init_agent_scope } from "../../agent/agent-scope.js";
+import { AutomationDeliveryPolicySchema, AutomationSchema, CreateAutomationSchema, UpdateAutomationSchema } from "../domain/validation.js";
 import { deleteAutomation, getAutomation, getDeletedAutomationRevision, listAutomations, saveAutomation, saveAutomations } from "../storage/automation-repository.js";
-import { appendAutomationRunEvent, getAutomationRun, getAutomationRunRequest, listAutomationRunEvents, listAutomationRuns, listAutomationRunsForProductEvent, listUnfinishedAutomationRuns, markAllAutomationRunsRead, markAutomationRunRead, pruneAutomationHistory, saveAutomationRun, saveAutomationRunRequest, touchAutomationRunLease } from "../storage/automation-run-repository.js";
+import { appendAutomationRunEvent, getAutomationExecutionSummaries, getAutomationRun, getAutomationRunRequest, isAutomationConversationShared, listAutomationRunEvents, listAutomationRuns, listAutomationRunsForProductEvent, listUnfinishedAutomationRuns, markAllAutomationRunsRead, markAutomationRunRead, pruneAutomationHistory, saveAutomationRun, saveAutomationRunRequest, touchAutomationRunLease } from "../storage/automation-run-repository.js";
 import "../storage/index.js";
 import { getAutomationEventDeliveryRunId, getAutomationEventForRun, getAutomationEventQueueMetrics, ingestAutomationEvent, listAutomationEventRecords, markAutomationEventDeliveryQueued, replayAutomationEvent } from "../events/event-repository.js";
 import { AutomationEventDispatcher } from "../events/event-dispatcher.js";
 import { AutomationDeliveryRouter, getAutomationResultDeliveryMetrics, listAutomationResultDeliveries, retryAutomationResultDelivery } from "../delivery/delivery-router.js";
+import { mcpConfigRevision } from "../../agent/mcp/connection-drafts.js";
+import { assertAutomationMcpSource, getAutomationMcpSource } from "../mcp-source.js";
+import { weixinPrivateIdentity } from "../../agent/mcp/weixin-setup-scope.js";
 import { computeNextAutomationRunAtMs, timerDelayUntil } from "../domain/schedule.js";
 import { AutomationActionExecutor } from "./action-executor.js";
 import "../delivery/index.js";
 import { randomUUID } from "node:crypto";
 //#region src/automations/service/automation-service.ts
+init_session_repository();
 init_logger();
+init_agent_scope();
 init_transaction();
 const log = createLogger("AutomationService");
 const DEFAULT_MAX_CONCURRENT_RUNS = 5;
@@ -22,6 +31,7 @@ const RUN_LEASE_DURATION_MS = 3e4;
 const RETRY_BASE_DELAY_MS = 1e3;
 var AutomationInvalidScheduleError = class extends Error {};
 var AutomationInvalidAgentError = class extends Error {};
+var AutomationInvalidSourceError = class extends Error {};
 var AutomationAlreadyRunningError = class extends Error {
 	constructor(automationId, runningRunId) {
 		super(`Automation is already running: ${automationId}`);
@@ -44,6 +54,10 @@ var AutomationService = class {
 		onDeadLetter: (input) => this.deps.onReliabilityAttention?.(input)
 	});
 	deliveryRouter = new AutomationDeliveryRouter({
+		deliverWeixin: (conversationId, principalId, run) => {
+			if (!this.deps.onWeixinRunCompleted) throw new Error("Weixin delivery is unavailable.");
+			return this.deps.onWeixinRunCompleted(conversationId, principalId, run);
+		},
 		deliverGatewayEvent: (run, context) => {
 			if (!this.deps.onRunCompleted) throw new Error("Notification service is unavailable. Delivery will retry.");
 			return this.deps.onRunCompleted(run, context);
@@ -89,6 +103,25 @@ var AutomationService = class {
 		await this.deliveryRouter.stop();
 		log.info("Automation service stopped");
 	}
+	bindConversationDelivery(conversationId, input) {
+		const delivery = AutomationDeliveryPolicySchema.parse(input);
+		if (!conversationId || getSessionMetadata(conversationId)?.sourceChannel !== "weixin") return delivery;
+		const scope = this.deps.getConfig && weixinPrivateIdentity(conversationId, this.deps.getConfig());
+		if (!scope) throw new AutomationInvalidSourceError("A paired Weixin conversation is required for this notification.");
+		const destinations = delivery.destinations.filter((item) => item.kind !== "weixin");
+		if (delivery.destinations.some((item) => item.kind === "weixin" && (item.conversationId !== conversationId || item.principalId !== scope.principalId))) throw new AutomationInvalidSourceError("Notifications cannot be redirected to another Weixin identity.");
+		let key = "weixin";
+		while (destinations.some((item) => item.key === key)) key = `_${key}`;
+		return {
+			...delivery,
+			destinations: [...destinations, {
+				key,
+				kind: "weixin",
+				conversationId,
+				principalId: scope.principalId
+			}]
+		};
+	}
 	async create(input) {
 		const automation = this.createAtomically(input);
 		this.refreshSchedule();
@@ -121,6 +154,7 @@ var AutomationService = class {
 		this.assertExecutionAgent(automation);
 		this.prepareSchedule(automation, now);
 		this.pinBrowserVersion(automation);
+		this.assertMcpSource(automation);
 		if (getAutomation(automation.id)) throw new AutomationAlreadyExistsError(automation.id);
 		automation.updatedAtMs = Math.max(automation.updatedAtMs, (getDeletedAutomationRevision(automation.id) ?? -1) + 1);
 		automation.state.nextRunAtMs = computeNextAutomationRunAtMs(automation, now);
@@ -131,6 +165,20 @@ var AutomationService = class {
 		if (automation.action.kind !== "agent" || !automation.action.agentId || !this.deps.isAgentAvailable) return;
 		if (!this.deps.isAgentAvailable(automation.action.agentId)) throw new AutomationInvalidAgentError("Execution assistant is unavailable. Choose an available assistant or use the default.");
 	}
+	assertMcpSource(automation) {
+		if (automation.action.kind !== "agent" || !automation.action.mcpSourceId || !automation.enabled) return;
+		try {
+			const source = getAutomationMcpSource(automation.action.mcpSourceId, normalizeAgentId(automation.action.agentId || this.deps.getDefaultAgentId?.() || "main"));
+			if (!this.deps.getConfig) throw new Error("The selected MCP source cannot be checked in this runtime.");
+			assertAutomationMcpSource(source, this.deps.getConfig());
+			if (!listAutomationRuns({
+				automationId: automation.id,
+				limit: 500
+			}).some((run) => run.status === "succeeded" && mcpConfigRevision(run.actionSnapshot) === mcpConfigRevision(automation.action))) throw new Error("Run and verify this exact source-bound action before enabling its schedule. Save a disabled draft first.");
+		} catch (error) {
+			throw new AutomationInvalidSourceError(error instanceof Error ? error.message : "The MCP source is unavailable.");
+		}
+	}
 	prepareSchedule(automation, now) {
 		if (automation.trigger.kind !== "schedule") return;
 		const schedule = automation.trigger.schedule;
@@ -162,6 +210,9 @@ var AutomationService = class {
 	async list(options) {
 		return listAutomations(options);
 	}
+	executionSummaries(projectId) {
+		return getAutomationExecutionSummaries(projectId);
+	}
 	async get(id) {
 		return getAutomation(id);
 	}
@@ -193,9 +244,11 @@ var AutomationService = class {
 				...parsed.state ?? {}
 			}
 		});
+		if (current.action.kind === "agent" && current.action.mcpSourceId && next.action.kind === "agent" && !next.action.mcpSourceId) next.action.mcpSourceId = current.action.mcpSourceId;
 		if (parsed.action) this.assertExecutionAgent(next);
 		if (parsed.trigger || parsed.enabled === true && next.trigger.kind === "schedule" && next.trigger.schedule.kind === "once") this.prepareSchedule(next, now);
 		this.pinBrowserVersion(next);
+		this.assertMcpSource(next);
 		if ("enabled" in parsed || "trigger" in parsed) next.state.nextRunAtMs = computeNextAutomationRunAtMs(next, now);
 		saveAutomation(next);
 		return next;
@@ -377,7 +430,11 @@ var AutomationService = class {
 		return listAutomationRunsForProductEvent(options);
 	}
 	async getRun(runId) {
-		return getAutomationRun(runId);
+		const run = getAutomationRun(runId);
+		return run ? {
+			...run,
+			conversationShared: Boolean(run.conversationId && isAutomationConversationShared(run.automationId, run.conversationId, runId))
+		} : null;
 	}
 	async listRunEvents(runId) {
 		return listAutomationRunEvents(runId);
@@ -844,4 +901,4 @@ function readAutomationEventFromRunEvent(event) {
 	};
 }
 //#endregion
-export { AutomationAlreadyExistsError, AutomationAlreadyRunningError, AutomationInvalidAgentError, AutomationInvalidScheduleError, AutomationService };
+export { AutomationAlreadyExistsError, AutomationAlreadyRunningError, AutomationInvalidAgentError, AutomationInvalidScheduleError, AutomationInvalidSourceError, AutomationService };

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

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

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

@@ -7,11 +7,20 @@ export declare function saveAutomationRun(run: AutomationRun): void;
 export declare function touchAutomationRunLease(runId: string, leaseOwner: string, heartbeatAtMs: number, leaseExpiresAtMs: number): void;
 export declare function listAutomationRunEvents(runId: string): AutomationRunEvent[];
 export declare function getAutomationRun(runId: string): AutomationRun | null;
-export declare function listAutomationRuns(options?: {
+export interface AutomationRunListOptions {
     automationId?: string;
     projectId?: string;
     limit?: number;
-}): AutomationRun[];
+    before?: {
+        createdAtMs: number;
+        id: string;
+    };
+}
+export declare function listAutomationRuns(options?: AutomationRunListOptions): AutomationRun[];
+export declare function isAutomationConversationShared(automationId: string, conversationId: string, runId: string): boolean;
+export declare function getAutomationExecutionSummaries(projectId?: string): Record<string, {
+    unreadCount: number;
+}>;
 export declare function listAutomationRunsForProductEvent(options: {
     eventType: string;
     source?: string;

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

@@ -117,29 +117,33 @@ function getAutomationRun(runId) {
 }
 function listAutomationRuns(options) {
 	const limit = Math.min(Math.max(options?.limit ?? 50, 1), 500);
-	const db = getSqliteDatabase();
-	const base = `SELECT run_id, automation_id, automation_name, status, trigger_snapshot_json,
-                       action_snapshot_json, manual, created_at_ms, started_at_ms, ended_at_ms,
-                       duration_ms, summary, error, conversation_id, model,
-                       deadline_at_ms, current_phase, cancel_requested_at_ms, cancel_confirmed_at_ms,
-                       termination_json, heartbeat_at_ms, lease_owner, lease_expires_at_ms,
-                       attempt_number, root_run_id, read_at_ms
-                FROM automation_runs`;
-	let rows;
-	if (options?.automationId) rows = db.prepare(`${base} WHERE automation_id = ? ORDER BY created_at_ms DESC LIMIT ?`).all(options.automationId, limit);
-	else if (options?.projectId) rows = db.prepare(`SELECT r.run_id, r.automation_id, r.automation_name, r.status, r.trigger_snapshot_json,
-              r.action_snapshot_json, r.manual, r.created_at_ms, r.started_at_ms, r.ended_at_ms,
-              r.duration_ms, r.summary, r.error, r.conversation_id, r.model,
-              r.deadline_at_ms, r.current_phase, r.cancel_requested_at_ms, r.cancel_confirmed_at_ms,
-              r.termination_json, r.heartbeat_at_ms, r.lease_owner, r.lease_expires_at_ms,
-              r.attempt_number, r.root_run_id, r.read_at_ms
-       FROM automation_runs r
-       JOIN automations a ON a.automation_id = r.automation_id
-       WHERE a.project_id = ?
-       ORDER BY r.created_at_ms DESC
-       LIMIT ?`).all(options.projectId, limit);
-	else rows = db.prepare(`${base} ORDER BY created_at_ms DESC LIMIT ?`).all(limit);
-	return rows.map(rowToRun);
+	const clauses = [];
+	const params = [];
+	if (options?.automationId) {
+		clauses.push("automation_id = ?");
+		params.push(options.automationId);
+	}
+	if (options?.projectId) {
+		clauses.push("EXISTS (SELECT 1 FROM automations a WHERE a.automation_id = automation_runs.automation_id AND a.project_id = ?)");
+		params.push(options.projectId);
+	}
+	if (options?.before) {
+		clauses.push("(created_at_ms < ? OR (created_at_ms = ? AND run_id < ?))");
+		params.push(options.before.createdAtMs, options.before.createdAtMs, options.before.id);
+	}
+	return getSqliteDatabase().prepare(`SELECT * FROM automation_runs
+    ${clauses.length ? `WHERE ${clauses.join(" AND ")}` : ""}
+    ORDER BY created_at_ms DESC, run_id DESC LIMIT ?`).all(...params, limit).map(rowToRun);
+}
+function isAutomationConversationShared(automationId, conversationId, runId) {
+	return Boolean(getSqliteDatabase().prepare("SELECT 1 FROM automation_runs WHERE automation_id = ? AND conversation_id = ? AND run_id != ? LIMIT 1").get(automationId, conversationId, runId));
+}
+function getAutomationExecutionSummaries(projectId) {
+	const rows = getSqliteDatabase().prepare(`SELECT r.automation_id,
+    SUM(CASE WHEN r.ended_at_ms IS NOT NULL AND r.read_at_ms IS NULL THEN 1 ELSE 0 END) AS unread_count
+    FROM automation_runs r JOIN automations a ON a.automation_id = r.automation_id
+    ${projectId ? "WHERE a.project_id = ?" : ""} GROUP BY r.automation_id`).all(...projectId ? [projectId] : []);
+	return Object.fromEntries(rows.map((row) => [row.automation_id, { unreadCount: row.unread_count }]));
 }
 function listAutomationRunsForProductEvent(options) {
 	const limit = Math.min(Math.max(options.limit ?? 10, 1), 100);
@@ -220,4 +224,4 @@ function markAllAutomationRunsRead(options) {
 	return Number(result.changes);
 }
 //#endregion
-export { appendAutomationRunEvent, deleteAutomationRunsForAutomation, getAutomationRun, getAutomationRunRequest, listAutomationRunEvents, listAutomationRuns, listAutomationRunsForProductEvent, listUnfinishedAutomationRuns, markAllAutomationRunsRead, markAutomationRunRead, pruneAutomationHistory, saveAutomationRun, saveAutomationRunRequest, touchAutomationRunLease };
+export { appendAutomationRunEvent, deleteAutomationRunsForAutomation, getAutomationExecutionSummaries, getAutomationRun, getAutomationRunRequest, isAutomationConversationShared, listAutomationRunEvents, listAutomationRuns, listAutomationRunsForProductEvent, listUnfinishedAutomationRuns, markAllAutomationRunsRead, markAutomationRunRead, pruneAutomationHistory, saveAutomationRun, saveAutomationRunRequest, touchAutomationRunLease };

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

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

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

@@ -1,5 +1,6 @@
 import type { BrowserSetup } from './types.js';
 export declare function readBrowserSetup(id: string): BrowserSetup | undefined;
+export declare function listConversationBrowserSetups(conversationId: string): BrowserSetup[];
 export declare function findBrowserSetup(conversationId: string, agentId: string): BrowserSetup | undefined;
 export declare function createBrowserSetup(conversationId: string, agentId: string, configRevision: string): BrowserSetup;
 export declare function saveBrowserSetup(next: BrowserSetup, expectedRevision: number): BrowserSetup;

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

@@ -1,11 +1,16 @@
 import { getSqliteDatabase, init_transaction, runSqliteWriteTransaction } from "../../storage/sqlite/transaction.js";
+import { getSessionMetadata, init_session_read_repository } from "../../storage/sqlite/session-read-repository.js";
 import { randomUUID } from "node:crypto";
 //#region src/browser/setup/repository.ts
 init_transaction();
+init_session_read_repository();
 function readBrowserSetup(id) {
 	const row = getSqliteDatabase().prepare("SELECT payload_json FROM browser_setup_runs WHERE id = ?").get(id);
 	return row ? JSON.parse(row.payload_json) : void 0;
 }
+function listConversationBrowserSetups(conversationId) {
+	return getSqliteDatabase().prepare("SELECT payload_json FROM browser_setup_runs WHERE conversation_id = ?").all(conversationId).map((row) => JSON.parse(row.payload_json));
+}
 function findBrowserSetup(conversationId, agentId) {
 	const row = getSqliteDatabase().prepare("SELECT payload_json FROM browser_setup_runs WHERE conversation_id = ? AND agent_id = ? ORDER BY updated_at DESC, rowid DESC LIMIT 1").get(conversationId, agentId);
 	return row ? JSON.parse(row.payload_json) : void 0;
@@ -19,6 +24,7 @@ function createBrowserSetup(conversationId, agentId, configRevision) {
 			id: randomUUID(),
 			conversationId,
 			agentId,
+			transcriptId: getSessionMetadata(conversationId)?.transcriptId,
 			configRevision,
 			state: "plan_ready",
 			revision: 1,
@@ -39,4 +45,4 @@ function saveBrowserSetup(next, expectedRevision) {
 	return next;
 }
 //#endregion
-export { createBrowserSetup, findBrowserSetup, readBrowserSetup, saveBrowserSetup };
+export { createBrowserSetup, findBrowserSetup, listConversationBrowserSetups, readBrowserSetup, saveBrowserSetup };

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

@@ -31,7 +31,10 @@ export interface BrowserSetupDeps {
 export declare class BrowserSetupService {
     private readonly deps;
     private readonly preparing;
+    private readonly preparationSettled;
     constructor(deps: BrowserSetupDeps);
+    private scopeCurrent;
+    cancelConversation(conversationId: string): Promise<void>;
     private policyRevision;
     endpoints(): {
         endpointId: string;