@themoltnet/node-red-contrib-core 0.9.0 → 0.11.0

package/dist/nodes/task-cancel.html

@@ -0,0 +1,77 @@
+<script type="text/javascript">
+  RED.nodes.registerType('moltnet-task-cancel', {
+    category: 'moltnet',
+    color: '#00d4c8',
+    paletteLabel: 'task: cancel',
+    defaults: {
+      name: { value: '' },
+      agent: { value: '', type: 'moltnet-agent', required: true },
+      taskId: { value: '' },
+      reason: { value: '' },
+      skipMissing: { value: false },
+      ignoreErrors: { value: false },
+    },
+    inputs: 1,
+    outputs: 1,
+    icon: 'font-awesome/fa-ban',
+    label: function () {
+      return this.name || 'task: cancel';
+    },
+  });
+</script>
+
+<script type="text/html" data-template-name="moltnet-task-cancel">
+  <div class="form-row">
+    <label for="node-input-name"><i class="fa fa-tag"></i> Name</label>
+    <input type="text" id="node-input-name" />
+  </div>
+  <div class="form-row">
+    <label for="node-input-agent"><i class="fa fa-user"></i> Agent</label>
+    <input type="text" id="node-input-agent" />
+  </div>
+  <div class="form-row">
+    <label for="node-input-taskId"><i class="fa fa-hashtag"></i> Task ID</label>
+    <input
+      type="text"
+      id="node-input-taskId"
+      placeholder="msg.taskId / msg.payload rows"
+    />
+  </div>
+  <div class="form-row">
+    <label for="node-input-reason"><i class="fa fa-comment"></i> Reason</label>
+    <input type="text" id="node-input-reason" placeholder="workflow failed" />
+  </div>
+  <div class="form-row">
+    <label>&nbsp;</label>
+    <input
+      type="checkbox"
+      id="node-input-skipMissing"
+      style="display:inline-block; width:auto; vertical-align:top;"
+    />
+    <span>Pass through when no task id is available</span>
+  </div>
+  <div class="form-row">
+    <label>&nbsp;</label>
+    <input
+      type="checkbox"
+      id="node-input-ignoreErrors"
+      style="display:inline-block; width:auto; vertical-align:top;"
+    />
+    <span>Keep the original message if cancel fails</span>
+  </div>
+</script>
+
+<script type="text/html" data-help-name="moltnet-task-cancel">
+  <p>Cancels one or more MoltNet tasks.</p>
+  <p>
+    Task ids are resolved from <code>msg.taskId</code>,
+    <code>msg.taskIds</code>, <code>msg.payload.taskId</code>,
+    <code>msg.payload.id</code>, <code>msg.payload.failure.taskId</code>, an
+    array on <code>msg.payload</code>, or the configured Task ID.
+  </p>
+  <p>
+    The original <code>msg.payload</code> is preserved. Cancelled task rows are
+    written to <code>msg.cancelledTasks</code>; ignored cancel failures are
+    written to <code>msg.cancelErrors</code>.
+  </p>
+</script>

package/dist/nodes/task-cancel.js

@@ -0,0 +1,135 @@
+import { t as withAgent } from "./agent-call.js";
+//#region src/nodes/task-cancel.ts
+var TERMINAL_STATUSES = new Set([
+	"completed",
+	"failed",
+	"cancelled",
+	"expired"
+]);
+var init = (RED) => {
+	function TaskCancelNode(def) {
+		RED.nodes.createNode(this, def);
+		const agentNode = def.agent ? RED.nodes.getNode(def.agent) : null;
+		this.on("input", (msg, send, done) => {
+			const run = async () => {
+				try {
+					if (!agentNode || typeof agentNode.getAgent !== "function") throw new Error("task-cancel: no moltnet-agent configured");
+					const taskIds = resolveTaskIds(msg, def.taskId);
+					if (taskIds.length === 0) {
+						if (def.skipMissing) {
+							const out = RED.util.cloneMessage(msg);
+							out.cancelledTasks = [];
+							out.cancelErrors = [];
+							this.status({
+								fill: "yellow",
+								shape: "ring",
+								text: "no task id"
+							});
+							send(out);
+							done();
+							return;
+						}
+						throw new Error("task-cancel: taskId is required");
+					}
+					this.status({
+						fill: "blue",
+						shape: "dot",
+						text: `cancelling ${taskIds.length}`
+					});
+					const reason = resolveReason(msg, def.reason);
+					const cancelled = [];
+					const errors = [];
+					await withAgent(agentNode, async (agent) => {
+						for (const taskId of taskIds) try {
+							const task = await agent.tasks.cancel(taskId, { reason });
+							cancelled.push(task);
+						} catch (error) {
+							const message = errorMessage(error);
+							if (!def.ignoreErrors) throw error;
+							errors.push({
+								taskId,
+								message
+							});
+						}
+					});
+					const out = RED.util.cloneMessage(msg);
+					out.cancelledTasks = cancelled;
+					out.cancelErrors = errors;
+					if (cancelled.length === 1) out.cancelledTask = cancelled[0];
+					if (taskIds.length === 1) out.taskId = taskIds[0];
+					this.status({
+						fill: errors.length > 0 ? "yellow" : "green",
+						shape: errors.length > 0 ? "ring" : "dot",
+						text: errors.length > 0 ? `cancelled ${cancelled.length}, ${errors.length} error(s)` : `cancelled ${cancelled.length}`
+					});
+					send(out);
+					done();
+				} catch (err) {
+					this.status({
+						fill: "red",
+						shape: "ring",
+						text: "error"
+					});
+					done(err instanceof Error ? err : new Error(String(err)));
+				}
+			};
+			run();
+		});
+	}
+	RED.nodes.registerType("moltnet-task-cancel", TaskCancelNode);
+};
+function resolveTaskIds(msg, configured) {
+	const ids = /* @__PURE__ */ new Set();
+	addId(ids, msg.taskId);
+	addIds(ids, msg.taskIds);
+	collectFromPayload(ids, msg.payload);
+	addId(ids, configured);
+	return [...ids];
+}
+function collectFromPayload(ids, value) {
+	if (!value) return;
+	if (typeof value === "string") {
+		addId(ids, value);
+		return;
+	}
+	if (Array.isArray(value)) {
+		for (const item of value) collectFromPayload(ids, item);
+		return;
+	}
+	if (typeof value !== "object") return;
+	const record = value;
+	addId(ids, record.taskId);
+	addId(ids, record.id);
+	addIds(ids, record.taskIds);
+	addIds(ids, record.ids);
+	if (Array.isArray(record.tasks)) addIds(ids, record.tasks);
+	if (record.failure && typeof record.failure === "object") addId(ids, record.failure.taskId);
+	if (typeof record.status === "string" && TERMINAL_STATUSES.has(record.status)) return;
+}
+function addIds(ids, value) {
+	if (!Array.isArray(value)) return;
+	for (const item of value) collectFromPayload(ids, item);
+}
+function addId(ids, value) {
+	if (typeof value === "string" && value.trim()) ids.add(value.trim());
+}
+function resolveReason(msg, configured) {
+	if (configured && configured.trim()) return configured.trim();
+	const payload = msg.payload;
+	if (payload && typeof payload === "object") {
+		const p = payload;
+		if (p.failure && typeof p.failure === "object") {
+			const error = p.failure.error;
+			if (error && typeof error === "object") {
+				const message = error.message;
+				if (typeof message === "string" && message.trim()) return `workflow failed: ${message.trim()}`;
+			}
+		}
+	}
+	return "workflow failed";
+}
+function errorMessage(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+//#endregion
+export { init as default };

package/dist/nodes/task-wait.html

@@ -16,6 +16,9 @@
       agent: { value: '', type: 'moltnet-agent', required: true },
       taskId: { value: '' },
       pollIntervalSec: { value: 5, validate: RED.validators.number() },
+      // Legacy field used by older example flows. Keeping it in defaults lets
+      // the editor migrate existing nodes instead of showing them as broken.
+      intervalMs: { value: undefined, required: false },
       timeoutSec: { value: 1800, validate: RED.validators.number() },
       tail: { value: false },
       kinds: { value: '' },
@@ -28,6 +31,14 @@
       return this.name || 'task: wait';
     },
     oneditprepare: function () {
+      if (
+        (this.pollIntervalSec === undefined ||
+          this.pollIntervalSec === null ||
+          this.pollIntervalSec === '') &&
+        typeof this.intervalMs === 'number'
+      ) {
+        $('#node-input-pollIntervalSec').val(this.intervalMs / 1000);
+      }
       // Render one checkbox per message kind. `kinds` is stored as a
       // comma-separated string (the runtime contract); empty = all kinds.
       const selected = (this.kinds || '')
@@ -56,6 +67,7 @@
       toggle();
     },
     oneditsave: function () {
+      this.intervalMs = undefined;
       const all = $('.mn-kind').length;
       const checked = $('.mn-kind:checked')
         .map(function () {

package/dist/nodes/task-wait.js

@@ -7,7 +7,8 @@ var init = (RED) => {
 	function TaskWaitNode(def) {
 		RED.nodes.createNode(this, def);
 		const agentNode = def.agent ? RED.nodes.getNode(def.agent) : null;
-		const pollMs = Math.max(1, def.pollIntervalSec || DEFAULT_POLL_SEC) * 1e3;
+		const pollSec = def.pollIntervalSec ?? (typeof def.intervalMs === "number" ? def.intervalMs / 1e3 : void 0);
+		const pollMs = Math.max(1, pollSec || DEFAULT_POLL_SEC) * 1e3;
 		const timeoutMs = (def.timeoutSec ?? DEFAULT_TIMEOUT_SEC) > 0 ? (def.timeoutSec ?? DEFAULT_TIMEOUT_SEC) * 1e3 : 0;
 		const kindAllow = parseKinds(def.kinds);
 		const active = /* @__PURE__ */ new Map();
@@ -24,6 +25,7 @@ var init = (RED) => {
 					if (!agentNode || typeof agentNode.getAgent !== "function") throw new Error("task-wait: no moltnet-agent configured");
 					const taskId = resolveTaskId(msg, def.taskId);
 					if (!taskId) throw new Error("task-wait: taskId is required");
+					msg.taskId = taskId;
 					taskIdForStatus = taskId;
 					label = describeWait(taskId, msg, label);
 					active.set(taskId, label);
@@ -61,6 +63,7 @@ var init = (RED) => {
 								...snapshot,
 								correlationId
 							} : snapshot;
+							resultMsg.taskId = taskId;
 							if (correlationId) resultMsg.correlationId = correlationId;
 							active.delete(taskId);
 							this.status({

package/dist/nodes/tasks-create.js

@@ -34,6 +34,7 @@ var init = (RED) => {
 					const task = await withAgent(agentNode, (agent) => agent.tasks.create(createBody, { teamId }));
 					const out = RED.util.cloneMessage(msg);
 					if (correlationId) out.correlationId = correlationId;
+					out.taskId = task.id;
 					out.payload = task;
 					active.delete(invocationId);
 					this.status({