@themoltnet/node-red-contrib-core 0.10.0 → 0.12.0

package/dist/nodes/task-artifact-stage.js

@@ -0,0 +1,54 @@
+import { t as withAgent } from "./agent-call.js";
+import { t as bool } from "./query-utils.js";
+import { c as resolveMaxBytes, l as resolveTeamId, s as resolveField, u as resolveUploadBody } from "./task-artifact-utils.js";
+//#region src/nodes/task-artifact-stage.ts
+var init = (RED) => {
+	function TaskArtifactStageNode(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-artifact-stage: no moltnet-agent configured");
+					const teamId = resolveTeamId(msg, def.teamId, agentNode, bool(def.allowMsgTeamOverride) ?? false);
+					if (!teamId) throw new Error("task-artifact-stage: teamId is required");
+					const body = resolveUploadBody(msg, resolveMaxBytes(def.maxBytes), "task-artifact-stage");
+					const query = {
+						contentType: resolveField(msg, "contentType", def.contentType),
+						contentEncoding: resolveField(msg, "contentEncoding", def.contentEncoding)
+					};
+					this.status({
+						fill: "blue",
+						shape: "dot",
+						text: "staging..."
+					});
+					const artifact = await withAgent(agentNode, (agent) => agent.tasks.artifacts.stage(body, query, { teamId }));
+					const out = RED.util.cloneMessage({
+						...msg,
+						payload: void 0
+					});
+					out.payload = artifact;
+					out.artifact = artifact;
+					this.status({
+						fill: "green",
+						shape: "dot",
+						text: artifact.cid
+					});
+					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-artifact-stage", TaskArtifactStageNode);
+};
+//#endregion
+export { init as default };

package/dist/nodes/task-artifact-upload.js

@@ -1,6 +1,6 @@
 import { t as withAgent } from "./agent-call.js";
 import { t as bool } from "./query-utils.js";
-import { a as requireAttemptContext, c as resolveUploadBody, o as resolveField, s as resolveMaxBytes } from "./task-artifact-utils.js";
+import { a as requireAttemptContext, c as resolveMaxBytes, s as resolveField, u as resolveUploadBody } from "./task-artifact-utils.js";
 //#region src/nodes/task-artifact-upload.ts
 var init = (RED) => {
 	function TaskArtifactUploadNode(def) {

package/dist/nodes/task-artifact-utils.js

@@ -17,8 +17,22 @@ function resolveTeamId(msg, configured, agentNode, allowMsgTeamOverride) {
 	return nonEmpty(payloadRecord(msg).teamId) ?? nonEmpty(configured) ?? agentNode.teamId;
 }
 function resolveAttemptN(msg, configured) {
+	return resolveAttemptSelection(msg, configured).attemptN;
+}
+function resolveAttemptSelection(msg, configured) {
 	const payload = payloadRecord(msg);
-	return positiveInt(msg.attemptN) ?? positiveInt(payload.attemptN) ?? positiveInt(recordField(payload.attempt, "attemptN")) ?? positiveInt(recordField(payload.artifact, "attemptN")) ?? positiveInt(configured);
+	const candidate = [
+		msg.attemptN,
+		payload.attemptN,
+		recordField(payload.attempt, "attemptN"),
+		recordField(payload.artifact, "attemptN"),
+		configured
+	].find(isSupplied);
+	if (candidate === void 0) return { supplied: false };
+	return {
+		supplied: true,
+		attemptN: positiveInt(candidate)
+	};
 }
 function requireArtifactContext(nodeName, msg, configuredTaskId, configuredTeamId, agentNode, allowMsgTeamOverride) {
 	const taskId = resolveTaskId(msg, configuredTaskId);
@@ -59,9 +73,8 @@ function resolveUploadBody(msg, maxBytes, nodeName = "task-artifact-upload") {
 	}
 	const record = payloadRecord(msg);
 	if (typeof record.contentBase64 === "string") {
-		const normalized = record.contentBase64.replace(/\s/g, "");
-		if (decodedBase64Length(normalized) > maxBytes) throw tooLarge("upload", maxBytes, nodeName);
-		return Buffer.from(normalized, "base64");
+		if (decodedBase64Length(record.contentBase64) > maxBytes) throw tooLarge("upload", maxBytes, nodeName);
+		return Buffer.from(record.contentBase64, "base64");
 	}
 	const content = record.content ?? record.body;
 	if (Buffer.isBuffer(content)) return enforceMaxBytes(content, maxBytes, nodeName);
@@ -139,11 +152,26 @@ function pushChunk(chunks, chunk, bytes, maxBytes, nodeName) {
 }
 function decodedBase64Length(value) {
 	if (!value) return 0;
-	const padding = value.endsWith("==") ? 2 : value.endsWith("=") ? 1 : 0;
-	return Math.floor(value.length * 3 / 4) - padding;
+	let characters = 0;
+	let previous = "";
+	let last = "";
+	for (let index = 0; index < value.length; index += 1) {
+		if (isBase64Whitespace(value.charCodeAt(index))) continue;
+		characters += 1;
+		previous = last;
+		last = value[index];
+	}
+	const padding = last === "=" ? previous === "=" ? 2 : 1 : 0;
+	return Math.max(0, Math.floor(characters * 3 / 4) - padding);
+}
+function isSupplied(value) {
+	return value !== void 0 && value !== null && value !== "";
+}
+function isBase64Whitespace(code) {
+	return code === 32 || code >= 9 && code <= 13;
 }
 function tooLarge(operation, maxBytes, nodeName) {
 	return /* @__PURE__ */ new Error(`${nodeName}: ${operation} body exceeds ${maxBytes} bytes`);
 }
 //#endregion
-export { requireAttemptContext as a, resolveUploadBody as c, requireArtifactContext as i, payloadRecord as n, resolveField as o, recordField as r, resolveMaxBytes as s, collectArtifactBody as t };
+export { requireAttemptContext as a, resolveMaxBytes as c, requireArtifactContext as i, resolveTeamId as l, payloadRecord as n, resolveAttemptSelection as o, recordField as r, resolveField as s, collectArtifactBody as t, resolveUploadBody as u };

package/dist/nodes/task-builder.js

@@ -75,7 +75,8 @@ var init = (RED) => {
 				}
 				if (def.referencesFrom) {
 					const ref = RED.util.getMessageProperty(msg, def.referencesFrom);
-					if (ref && ref.outputCid) builder.references(ref, def.referencesRole ?? "context");
+					if (ref?.artifact || ref?.artifactSource === "staged" || ref?.cid) builder.artifactReference(ref, def.referencesRole ?? "context");
+					else if (ref?.outputCid) builder.references(ref, def.referencesRole ?? "context");
 				}
 				if (def.submitOutputGate) builder.requireSubmitOutput();
 				if (def.schemaCid) builder.requireSchema(def.schemaCid);

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({