@oomol-lab/open-flow 0.1.0-beta.80 → 0.1.0-beta.82

package/dist/common/authoring.d.ts

@@ -82,6 +82,7 @@ export declare function authoringNode(content: RevisionContent, ref: string): {
     })[];
 };
 export declare function readAuthoring(content: RevisionContent, query?: AuthoringRead): {
+    nodes?: undefined;
     text: {
         node: string;
         field: "code" | "prompt";
@@ -92,7 +93,6 @@ export declare function readAuthoring(content: RevisionContent, query?: Authorin
         nextStart?: number | undefined;
         truncated: boolean;
     };
-    nodes?: undefined;
     edges?: undefined;
 } | {
     text?: undefined;

package/dist/common/control-api-conformance.js

@@ -9474,6 +9474,27 @@ function assertDocumentHttpAuthBindings(content) {
 	for (const graphNode of Object.values(content.graph.nodes)) if (graphNode.kind == "task" && "executor" in graphNode.task && ["openapi", "http-request"].includes(graphNode.task.executor.kind)) assertHttpAuthBindings(graphNode.inputs);
 }
 //#endregion
+//#region src/flow/common/condition.ts
+function clearConditionBinding(operand) {
+	return operand.kind == "source" && operand.source.kind == "binding" ? { kind: "value" } : operand;
+}
+function clearConditionBindings(node) {
+	return {
+		...node,
+		cases: node.cases.map((item) => ({
+			...item,
+			groups: item.groups.map((group) => ({
+				...group,
+				expressions: group.expressions.map((expression) => ({
+					...expression,
+					left: clearConditionBinding(expression.left),
+					...expression.right == null ? {} : { right: clearConditionBinding(expression.right) }
+				}))
+			}))
+		}))
+	};
+}
+//#endregion
 //#region src/flow/common/change.ts
 /** Lossless upgrade of readable content. Historical content and its encoding stay unchanged. */
 function upgradeRevisionContent(content) {
@@ -9582,6 +9603,31 @@ function findEngineContract(contract) {
 	};
 }
 //#endregion
+//#region src/flow/common/workflowReferences.ts
+/** Workflow declarations share discovery across authoring, admission and resource indexing. */
+function nodeWorkflowReferences(node) {
+	if (node.kind != "task") return [];
+	if ("moduleId" in node.task) return (node.task.capabilities ?? []).flatMap((item, index) => item.kind == "workflow" ? [{
+		target: item,
+		path: `task/capabilities/${index}`,
+		tool: item.name
+	}] : []);
+	if (node.task.executor.kind == "workflow") return [{
+		target: {
+			...node.task.executor,
+			inputs: node.task.inputs.filter((port) => "handle" in port),
+			outputs: node.task.outputs.filter((port) => "handle" in port)
+		},
+		path: "task/executor"
+	}];
+	if (node.task.executor.kind == "agent") return node.task.executor.tools.flatMap((item, index) => item.kind == "workflow" ? [{
+		target: item,
+		path: `task/executor/tools/${index}`,
+		tool: item.name
+	}] : []);
+	return [];
+}
+//#endregion
 //#region src/workflow/common/workflow.ts
 var portSchema = object({
 	handle: string$1().min(1),
@@ -10495,12 +10541,12 @@ function decodeLiveDetails(value) {
 		publication: current,
 		status,
 		enabled: source.enabled,
-		entries: decodeEntries(source.entries, current),
+		entries: decodeEntries$1(source.entries, current),
 		version: 1
 	};
 }
 /** Both producers and consumers enforce the same published-entry invariants. */
-function decodeEntries(values, current) {
+function decodeEntries$1(values, current) {
 	const parsed = array(entrySchema).safeParse(values);
 	if (!parsed.success) return invalidResponse();
 	const ids = /* @__PURE__ */ new Set();
@@ -10547,11 +10593,109 @@ function providerIconAppearance(metadata, position) {
 	};
 }
 //#endregion
+//#region src/trigger/common/config.ts
+/** Deployment-bound selections owned by the Trigger configuration contract. */
+function clearTriggerExternalConfig(key, config) {
+	const fields = key == "jira.on_issue_event" || key == "intercom.on_conversation_event" || key == "sentry.on_issue_alert" || key == "zoom.on_recording_ready" || key == "fireflies.on_meeting_ready" ? ["sourceId", "eventTypes"] : key == "slackbot.on_event" ? [
+		"sourceId",
+		"eventTypes",
+		"channelIds"
+	] : key == "feishu_app_bot.on_event" ? [
+		"sourceId",
+		"eventTypes",
+		"resource",
+		"chatIds"
+	] : key == "linear.on_issue_changed" ? ["teamId", "stateIds"] : [];
+	return {
+		...config,
+		...Object.fromEntries(fields.map((field) => [field, { kind: "unset" }]))
+	};
+}
+//#endregion
+//#region src/flow/common/connectionUsage.ts
+function clearNodeConnections(graph, connectionId) {
+	return {
+		...graph,
+		nodes: Object.fromEntries(Object.entries(graph.nodes).map(([id, node]) => {
+			if ((node.kind == "poll" || node.kind == "integration") && (connectionId == null || node.connectionId == connectionId)) {
+				const { connectionId: _, ...remaining } = node;
+				return [id, remaining];
+			}
+			if (node.kind != "task") return [id, node];
+			if ("executor" in node.task) {
+				const executor = node.task.executor;
+				const clear = (value) => {
+					if (value.connectionId === "") return value;
+					if (connectionId != null && value.connectionId != connectionId) return value;
+					const { connectionId: _, ...rest } = value;
+					return rest;
+				};
+				if (executor.kind == "connector") return [id, {
+					...node,
+					task: {
+						...node.task,
+						executor: clear(executor)
+					}
+				}];
+				if (executor.kind == "agent") return [id, {
+					...node,
+					task: {
+						...node.task,
+						executor: {
+							...executor,
+							tools: executor.tools.map(clear),
+							...executor.notification == null ? {} : { notification: clear(executor.notification) }
+						}
+					}
+				}];
+				return [id, node];
+			}
+			const capabilities = node.task.capabilities?.map((capability) => {
+				if (capability.kind == "workflow" || capability.kind == "http") return capability;
+				if (!("mode" in capability)) {
+					if ("action" in capability) {
+						const { connectionId: selected, ...rest } = capability;
+						return {
+							...rest,
+							connections: capability.connections.filter((item) => connectionId != null && item.connectionId != connectionId),
+							...selected != null && connectionId != null && selected != connectionId ? { connectionId: selected } : {}
+						};
+					}
+					return {
+						...capability,
+						...connectionId == null && (capability.connectionHints?.length ?? 0) > 0 ? { actionHints: [.../* @__PURE__ */ new Set([...capability.actionHints ?? [], ...capability.connectionHints.map((hint) => hint.action)])] } : {},
+						...capability.connectionHints == null ? {} : { connectionHints: capability.connectionHints.filter((item) => connectionId != null && item.connectionId != connectionId) }
+					};
+				}
+				if (capability.mode != "independent") return capability;
+				return {
+					...capability,
+					actions: capability.actions.map((action) => {
+						if (action.connectionId === "") return action;
+						if (connectionId != null && action.connectionId != connectionId) return action;
+						const { connectionId: _, ...remaining } = action;
+						return remaining;
+					})
+				};
+			});
+			return [id, capabilities == null ? node : {
+				...node,
+				task: {
+					...node.task,
+					capabilities
+				}
+			}];
+		}))
+	};
+}
+//#endregion
 //#region src/flow/common/workflowFile.ts
 var envelope = strictObject({
 	kind: literal("open-flow-workflow"),
 	version: literal(1),
 	name: string$1().optional(),
+	icon: string$1().optional(),
+	description: string$1().optional(),
 	content: unknown(),
 	presentation: record$3(string$1(), json$4()).optional()
 });
@@ -10564,6 +10708,126 @@ function decodeWorkflowFile(value) {
 		content: decodeRevisionContent(file.content)
 	};
 }
+function cleanInput(input) {
+	if (input.kind != "sources" || !input.sources.some((source) => source.kind == "binding")) return input;
+	const sources = input.sources.filter((source) => source.kind != "binding");
+	return sources.length == 0 ? { kind: "unset" } : {
+		kind: "sources",
+		sources
+	};
+}
+/** Clear only owned structured references, never strings in code or business values. */
+function cleanWorkflowFile(value) {
+	const file = decodeWorkflowFile(value);
+	const original = file.content.document.graph;
+	const graph = clearNodeConnections(original);
+	const nodes = Object.fromEntries(Object.entries(graph.nodes).map(([id, source]) => {
+		let node = source;
+		if ("inputs" in node) node = {
+			...node,
+			inputs: Object.fromEntries(Object.entries(node.inputs).map(([key, input]) => [key, cleanInput(input)]))
+		};
+		if (node.kind == "outputs") node = {
+			...node,
+			outputMappings: Object.fromEntries(Object.entries(node.outputMappings).map(([key, input]) => [key, cleanInput(input)]))
+		};
+		if (node.kind == "condition") node = clearConditionBindings(node);
+		if (node.kind == "error" && node.sourceFlowIds != null) node = {
+			...node,
+			sourceFlowIds: []
+		};
+		if (node.kind == "poll" || node.kind == "integration") node = {
+			...node,
+			config: clearTriggerExternalConfig(node.definition.key, node.config)
+		};
+		return [id, node];
+	}));
+	return {
+		file: {
+			...file,
+			content: {
+				...file.content,
+				document: {
+					...file.content.document,
+					bindings: {},
+					graph: {
+						...graph,
+						nodes
+					}
+				}
+			}
+		},
+		summary: {
+			changedNodeIds: Object.keys(nodes).filter((id) => !dequal(nodes[id], original.nodes[id])),
+			removedBindings: Object.keys(file.content.document.bindings).length
+		}
+	};
+}
+//#endregion
+//#region src/flow/common/workflowBundle.ts
+var entries = array(strictObject({
+	flowId: string$1().min(1),
+	file: unknown()
+})).min(1);
+var bundleSchema = strictObject({
+	kind: literal("open-flow-workflow-bundle"),
+	version: literal(1),
+	entryFlowId: string$1().min(1),
+	workflows: entries
+});
+var previewSchema = strictObject({
+	version: literal(1),
+	entryFlowId: string$1().min(1),
+	workflows: entries,
+	unavailableFlowIds: array(string$1().min(1))
+});
+function decodeEntries(value, entryFlowId, unavailableFlowIds = []) {
+	const workflows = value.map(({ flowId, file }) => ({
+		flowId,
+		file: decodeWorkflowFile(file)
+	}));
+	const ids = new Set(workflows.map(({ flowId }) => flowId));
+	if (ids.size != workflows.length || !ids.has(entryFlowId)) throw new TypeError("Workflow identities must be unique and include the entry workflow.");
+	const unavailable = new Set(unavailableFlowIds);
+	if (unavailable.size != unavailableFlowIds.length || unavailableFlowIds.some((id) => ids.has(id))) throw new TypeError("Invalid unavailable workflow identities.");
+	for (const { file } of workflows) for (const node of Object.values(file.content.document.graph.nodes)) for (const { target } of nodeWorkflowReferences(node)) if (target.flowId && !ids.has(target.flowId) && !unavailable.has(target.flowId)) throw new TypeError("A referenced workflow is missing from the bundle.");
+	return workflows;
+}
+function decodeWorkflowBundle(value) {
+	checkJsonDepth(value, -4);
+	const bundle = bundleSchema.parse(value);
+	return {
+		...bundle,
+		workflows: decodeEntries(bundle.workflows, bundle.entryFlowId)
+	};
+}
+function decodeWorkflowExportPreview(value) {
+	checkJsonDepth(value, -4);
+	const preview = previewSchema.parse(value);
+	return {
+		...preview,
+		workflows: decodeEntries(preview.workflows, preview.entryFlowId, preview.unavailableFlowIds)
+	};
+}
+function cleanWorkflowBundle(value) {
+	const bundle = decodeWorkflowBundle(value);
+	return {
+		...bundle,
+		workflows: bundle.workflows.map(({ flowId, file }) => ({
+			flowId,
+			file: cleanWorkflowFile(file).file
+		}))
+	};
+}
+function workflowBundleFromPreview(preview) {
+	if (preview.unavailableFlowIds.length) throw new TypeError("Some referenced workflows are unavailable.");
+	return cleanWorkflowBundle({
+		kind: "open-flow-workflow-bundle",
+		version: 1,
+		entryFlowId: preview.entryFlowId,
+		workflows: preview.workflows
+	});
+}
 new TextEncoder();
 //#endregion
 //#region src/control/common/providerAccess.ts
@@ -11308,6 +11572,8 @@ function flow(value) {
 		resourceReferences: resourceReferences(source.resourceReferences),
 		flowId: string(source.flowId),
 		name: string(source.name),
+		...source.icon === void 0 ? {} : { icon: string(source.icon) },
+		...source.description === void 0 ? {} : { description: string(source.description) },
 		status,
 		updatedAt: string(source.updatedAt),
 		version: 1
@@ -11794,6 +12060,18 @@ function decodeTagListItem(value) {
 }
 //#endregion
 //#region src/control/common/api.ts
+function decodeWorkflowBundleImportResult(value) {
+	const source = record$1(value);
+	if (source.version != 1 || !Array.isArray(source.flows) || source.flows.length == 0) return invalidResponse();
+	const entry = flow(source.flow);
+	const flows = source.flows.map(flow);
+	if (new Set(flows.map((item) => item.flowId)).size != flows.length || !flows.some((item) => item.flowId == entry.flowId)) return invalidResponse();
+	return {
+		version: 1,
+		flow: entry,
+		flows
+	};
+}
 function decodeRunEvent(value) {
 	const source = record$1(value);
 	const sequence = integer(source.sequence);
@@ -12108,6 +12386,32 @@ var ControlClient = class {
 			return invalidResponse();
 		}
 	}
+	async getFlowExportPreview(flowId) {
+		const value = await this.request(`/v1/flows/${segment(flowId)}/export-preview`);
+		try {
+			return decodeWorkflowExportPreview(value);
+		} catch {
+			return invalidResponse();
+		}
+	}
+	async exportFlowBundle(flowId) {
+		const preview = await this.getFlowExportPreview(flowId);
+		if (preview.unavailableFlowIds.length) throw new ApiError(400, "flow.invalid", "Some referenced workflows are unavailable.");
+		return workflowBundleFromPreview(preview);
+	}
+	async importFlowBundle(file, options = {}) {
+		return decodeWorkflowBundleImportResult(await this.request("/v1/flows/import-bundle", {
+			method: "POST",
+			headers: { "Idempotency-Key": options.idempotencyKey ?? `flow-${randomId()}` },
+			body: JSON.stringify({
+				file,
+				name: options.name,
+				teamId: options.teamId,
+				tagIds: options.tagIds,
+				version: 1
+			})
+		}));
+	}
 	async importFlow(file, options = {}) {
 		return flow(await this.request("/v1/flows/import", {
 			method: "POST",

package/dist/common/control-api.d.ts

@@ -27,8 +27,10 @@ import type { ResultQuery } from './run-results.js';
 import { decodeResultList, decodeResultRead } from './run-results.js';
 export { readResult, parseResultQuery, decodeResultList, decodeResultRead, type ResultCall, type ResultInfo, type ResultPage, type ResultQuery, } from './run-results.js';
 import type { RunStatus } from './run-lifecycle.js';
+import type { WorkflowBundle, WorkflowExportPreview } from './flow-workflowBundle.js';
 import type { WorkflowFile } from './flow-workflowFile.js';
 export type { WorkflowFile, WorkflowCleanupSummary } from './flow-workflowFile.js';
+export type { WorkflowBundle, WorkflowExportPreview } from './flow-workflowBundle.js';
 import type { InputPortDefinition, JsonValue, PortDefinition, RevisionContent, TriggerKeySnapshot, WaitAction } from './flow-change.js';
 import type { FlowResourceReferences } from './flow-semantics.js';
 export type { JsonValue, TriggerKeySnapshot, WaitAction } from './flow-change.js';
@@ -63,8 +65,16 @@ export interface FlowResources {
 }
 export interface FlowUpdate {
     readonly name?: string;
+    readonly icon?: string | null;
+    readonly description?: string | null;
     readonly tagIds?: readonly string[];
 }
+export interface WorkflowBundleImportResult {
+    readonly version: 1;
+    readonly flow: Flow;
+    readonly flows: readonly Flow[];
+}
+export declare function decodeWorkflowBundleImportResult(value: unknown): WorkflowBundleImportResult;
 export interface FlowQuery {
     readonly query?: string;
     readonly tagIds?: readonly string[];
@@ -93,6 +103,8 @@ export interface Flow {
     /** Connector Team scope used by the OOMOL resource cache. */
     readonly connectorTeamId?: string;
     readonly name: string;
+    readonly icon?: string;
+    readonly description?: string;
     readonly status: 'active' | 'retiring';
     readonly updatedAt: string;
     readonly version: 1;
@@ -828,6 +840,14 @@ export declare class ControlClient {
     putVariable(name: string, value: string): Promise<Variable>;
     deleteVariable(name: string): Promise<void>;
     exportFlow(flowId: string): Promise<WorkflowFile>;
+    getFlowExportPreview(flowId: string): Promise<WorkflowExportPreview>;
+    exportFlowBundle(flowId: string): Promise<WorkflowBundle>;
+    importFlowBundle(file: WorkflowBundle, options?: {
+        readonly name?: string;
+        readonly teamId?: string;
+        readonly idempotencyKey?: string;
+        readonly tagIds?: readonly string[];
+    }): Promise<WorkflowBundleImportResult>;
     importFlow(file: WorkflowFile, options?: {
         readonly name?: string;
         readonly teamId?: string;