taskmeld 0.1.1

package/dist/src/pipeline/execution-status.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildPipelineExecutionStatus = void 0;
+const isNonEmptyString = (value) => {
+    return typeof value === "string" && value.trim().length > 0;
+};
+const normalizeIdList = (items) => [...new Set(items.filter(Boolean))];
+const readCurrentBatchProgress = (run, batchRun) => {
+    const batchRecord = batchRun && typeof batchRun === "object" ? batchRun : null;
+    const currentBatchItemKey = isNonEmptyString(batchRecord?.currentBatchItemKey) ? batchRecord.currentBatchItemKey.trim() : null;
+    const currentBatchIndex = typeof batchRecord?.currentBatchIndex === "number" && Number.isFinite(batchRecord.currentBatchIndex)
+        ? Math.trunc(batchRecord.currentBatchIndex)
+        : null;
+    const currentBatchItems = Array.isArray(batchRecord?.currentBatchItems)
+        ? batchRecord.currentBatchItems.filter((item) => isNonEmptyString(item)).map((item) => item.trim())
+        : [];
+    if (!currentBatchItemKey && currentBatchIndex === null && currentBatchItems.length === 0) {
+        return null;
+    }
+    const itemRuns = Array.isArray(run.itemRuns) ? run.itemRuns : [];
+    const groupItemRuns = Array.isArray(run.groupItemRuns) ? run.groupItemRuns : [];
+    const currentItemRuns = itemRuns.filter((item) => item.itemKey === currentBatchItemKey);
+    const currentGroupItemRuns = groupItemRuns.filter((item) => item.itemKey === currentBatchItemKey);
+    const runningNodeIds = normalizeIdList(currentItemRuns
+        .filter((item) => item.status === "running")
+        .map((item) => String(item.nodeId ?? "").trim()));
+    const pendingNodeIds = normalizeIdList(currentItemRuns
+        .filter((item) => item.status === "queued" || item.status === "waiting" || item.status === "blocked")
+        .map((item) => String(item.nodeId ?? "").trim()));
+    const completedNodeIds = normalizeIdList(currentItemRuns
+        .filter((item) => item.status === "success" || item.status === "skipped")
+        .map((item) => String(item.nodeId ?? "").trim()));
+    const failedNodeIds = normalizeIdList(currentItemRuns
+        .filter((item) => item.status === "failed" || item.status === "rejected" || item.status === "stopped")
+        .map((item) => String(item.nodeId ?? "").trim()));
+    const runningGroupIds = normalizeIdList(currentGroupItemRuns
+        .filter((item) => item.status === "running")
+        .map((item) => String(item.groupId ?? "").trim()));
+    const pendingGroupIds = normalizeIdList(currentGroupItemRuns
+        .filter((item) => item.status === "queued" || item.status === "waiting" || item.status === "blocked")
+        .map((item) => String(item.groupId ?? "").trim()));
+    const completedGroupIds = normalizeIdList(currentGroupItemRuns
+        .filter((item) => item.status === "success" || item.status === "skipped")
+        .map((item) => String(item.groupId ?? "").trim()));
+    const failedGroupIds = normalizeIdList(currentGroupItemRuns
+        .filter((item) => item.status === "failed" || item.status === "rejected" || item.status === "stopped")
+        .map((item) => String(item.groupId ?? "").trim()));
+    return {
+        index: currentBatchIndex,
+        itemKey: currentBatchItemKey,
+        items: currentBatchItems,
+        runningNodeIds,
+        pendingNodeIds,
+        completedNodeIds,
+        failedNodeIds,
+        runningGroupIds,
+        pendingGroupIds,
+        completedGroupIds,
+        failedGroupIds,
+    };
+};
+const buildPipelineExecutionStatus = (input) => {
+    const runNodes = Array.isArray(input.run.nodes) ? input.run.nodes : [];
+    const batchRunRecord = input.batchRun && typeof input.batchRun === "object" ? input.batchRun : null;
+    const batchStatus = typeof batchRunRecord?.status === "string" ? batchRunRecord.status : null;
+    const batchError = typeof batchRunRecord?.error === "string" ? batchRunRecord.error : null;
+    const isBatchRunning = batchStatus === "running";
+    const isSingleRunning = input.run.status === "running";
+    const activeNodeIds = runNodes
+        .filter((node) => node.status === "running")
+        .map((node) => String(node.id ?? "").trim())
+        .filter(Boolean);
+    const pendingNodeIds = runNodes
+        .filter((node) => node.status === "queued" || node.status === "waiting" || node.status === "blocked")
+        .map((node) => String(node.id ?? "").trim())
+        .filter(Boolean);
+    const firstNodeError = runNodes.find((node) => isNonEmptyString(node.lastError))?.lastError?.trim() ?? null;
+    const currentBatch = readCurrentBatchProgress(input.run, input.batchRun);
+    return {
+        pipelineId: input.pipelineId,
+        mode: isBatchRunning ? "remote_batch" : isSingleRunning ? "single" : "idle",
+        running: Boolean(isBatchRunning || isSingleRunning),
+        runId: isNonEmptyString(input.run.id) ? input.run.id.trim() : null,
+        runStatus: input.run.status === "running" || input.run.status === "success" || input.run.status === "failed"
+            ? input.run.status
+            : "stopped",
+        activeNodeIds,
+        pendingNodeIds,
+        scheduler: input.scheduler,
+        batchRun: input.batchRun,
+        currentBatch,
+        lastError: batchError ?? firstNodeError,
+        updatedAt: isNonEmptyString(input.run.updatedAt) ? input.run.updatedAt.trim() : new Date().toISOString(),
+    };
+};
+exports.buildPipelineExecutionStatus = buildPipelineExecutionStatus;

package/dist/src/pipeline/execution-timeout.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getStructuredResultPollMs = exports.getStructuredResultTimeoutMs = exports.getPipelineNodeExecutionTimeoutMs = void 0;
+const MIN_TIMEOUT_MS = 5_000;
+const DEFAULT_PIPELINE_NODE_TIMEOUT_MS = 15 * 60 * 1000;
+const DEFAULT_STRUCTURED_RESULT_POLL_MS = 300;
+const normalizeTimeout = (value, fallback, min) => {
+    const parsed = Number(value);
+    if (!Number.isFinite(parsed))
+        return fallback;
+    return Math.max(min, Math.trunc(parsed));
+};
+// 统一维护 DAG 节点执行超时，避免发送请求与等待回执使用不同默认值。
+const getPipelineNodeExecutionTimeoutMs = () => normalizeTimeout(process.env.PIPELINE_NODE_EXECUTION_TIMEOUT_MS, DEFAULT_PIPELINE_NODE_TIMEOUT_MS, MIN_TIMEOUT_MS);
+exports.getPipelineNodeExecutionTimeoutMs = getPipelineNodeExecutionTimeoutMs;
+// 兼容历史环境变量名，未设置新变量时继续读取旧变量。
+const getStructuredResultTimeoutMs = () => normalizeTimeout(process.env.STRUCTURED_RESULT_TIMEOUT_MS ?? process.env.PIPELINE_NODE_EXECUTION_TIMEOUT_MS, DEFAULT_PIPELINE_NODE_TIMEOUT_MS, MIN_TIMEOUT_MS);
+exports.getStructuredResultTimeoutMs = getStructuredResultTimeoutMs;
+// 轮询间隔保持短周期，仅负责观察回执，不参与失败判定。
+const getStructuredResultPollMs = () => normalizeTimeout(process.env.STRUCTURED_RESULT_POLL_MS, DEFAULT_STRUCTURED_RESULT_POLL_MS, 100);
+exports.getStructuredResultPollMs = getStructuredResultPollMs;

package/dist/src/pipeline/identity/index.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.matchIdentity = exports.formatIdentity = exports.toRunIdentity = exports.buildItemKeyFromKeywords = exports.buildRequestId = exports.buildDerivedRouteItemKey = exports.buildBatchItemKey = exports.buildBatchRunId = exports.buildRunId = exports.randomUUID = void 0;
+const node_crypto_1 = require("node:crypto");
+Object.defineProperty(exports, "randomUUID", { enumerable: true, get: function () { return node_crypto_1.randomUUID; } });
+const buildRunId = () => `run-${Date.now()}`;
+exports.buildRunId = buildRunId;
+const buildBatchRunId = (pipelineId) => `batch-${pipelineId}-${Date.now()}`;
+exports.buildBatchRunId = buildBatchRunId;
+const buildBatchItemKey = (batchIndex) => `batch-${batchIndex}`;
+exports.buildBatchItemKey = buildBatchItemKey;
+const buildDerivedRouteItemKey = (itemKey, nodeId, route) => `${itemKey}::${nodeId}:${route}`;
+exports.buildDerivedRouteItemKey = buildDerivedRouteItemKey;
+const buildRequestId = (nodeId) => `node-${nodeId}-${(0, node_crypto_1.randomUUID)()}`;
+exports.buildRequestId = buildRequestId;
+const buildItemKeyFromKeywords = (keywords) => [...new Set(keywords.map((item) => item.trim()).filter(Boolean))];
+exports.buildItemKeyFromKeywords = buildItemKeyFromKeywords;
+/** 从 Run 和 pipelineId 构造身份快照 */
+const toRunIdentity = (pipelineId, run) => ({
+    pipelineId,
+    runId: run.id,
+    batchRunId: null,
+});
+exports.toRunIdentity = toRunIdentity;
+/** 格式化身份为可读字符串 */
+const formatIdentity = (id) => `pipeline=${id.pipelineId} run=${id.runId}${id.batchRunId ? ` batch=${id.batchRunId}` : ""}`;
+exports.formatIdentity = formatIdentity;
+/** 校验身份匹配：pipelineId 必须相等，runId 必须相等，batchRunId 任一方为 null 时放行 */
+const matchIdentity = (target, candidate) => target.pipelineId === candidate.pipelineId &&
+    target.runId === candidate.runId &&
+    (target.batchRunId === null || candidate.batchRunId === null || target.batchRunId === candidate.batchRunId);
+exports.matchIdentity = matchIdentity;

package/dist/src/pipeline/identity/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/pipeline/item-batch-controller.js

@@ -0,0 +1,227 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createItemBatchController = exports.normalizePoolItems = void 0;
+const DEFAULT_BATCH_SIZE = 10;
+const clampBatchSize = (value) => {
+    if (typeof value !== "number" || !Number.isFinite(value))
+        return DEFAULT_BATCH_SIZE;
+    return Math.min(200, Math.max(1, Math.trunc(value)));
+};
+const clampStartIndex = (value, total) => {
+    if (typeof value !== "number" || !Number.isFinite(value))
+        return 0;
+    return Math.min(Math.max(0, Math.trunc(value)), Math.max(0, total));
+};
+const createIdleSnapshot = () => ({
+    status: "idle",
+    batchSize: DEFAULT_BATCH_SIZE,
+    totalItems: 0,
+    totalBatches: 0,
+    processedItems: 0,
+    processedBatches: 0,
+    nextBatchIndex: 1,
+    currentBatchIndex: null,
+    currentBatchItemKey: null,
+    currentBatchItems: [],
+    startedAt: null,
+    finishedAt: null,
+    lastBatchItems: [],
+    error: null,
+    stopRequested: false,
+    batchRunId: null,
+});
+const cloneSnapshot = (snapshot) => ({
+    ...snapshot,
+    currentBatchItems: [...snapshot.currentBatchItems],
+    lastBatchItems: [...snapshot.lastBatchItems],
+});
+const normalizePoolItems = (value) => {
+    const rawList = [];
+    if (Array.isArray(value)) {
+        for (const entry of value) {
+            if (typeof entry === "string")
+                rawList.push(entry);
+        }
+    }
+    else if (typeof value === "string") {
+        // 支持逗号与换行混输，方便直接粘贴关键词池。
+        rawList.push(...value.split(/[\n,]/g));
+    }
+    const unique = new Set();
+    for (const item of rawList) {
+        const normalized = item.trim();
+        if (!normalized)
+            continue;
+        unique.add(normalized);
+    }
+    return [...unique];
+};
+exports.normalizePoolItems = normalizePoolItems;
+const identity_1 = require("./identity");
+const createItemBatchController = (deps) => {
+    let snapshot = createIdleSnapshot();
+    let runToken = 0;
+    let hasBatchErrors = false;
+    const runLoop = async (token, queue) => {
+        while (queue.length > 0) {
+            if (token !== runToken)
+                return;
+            if (snapshot.stopRequested) {
+                snapshot = {
+                    ...snapshot,
+                    status: "stopped",
+                    finishedAt: new Date().toISOString(),
+                };
+                return;
+            }
+            const currentBatchItems = queue.splice(0, snapshot.batchSize);
+            const currentBatchIndex = snapshot.processedBatches + 1;
+            snapshot = {
+                ...snapshot,
+                currentBatchIndex,
+                currentBatchItemKey: `batch-${currentBatchIndex}`,
+                currentBatchItems: [...currentBatchItems],
+                lastBatchItems: [...currentBatchItems],
+            };
+            let result;
+            try {
+                result = await deps.executeBatch({
+                    batchItems: currentBatchItems,
+                    batchIndex: currentBatchIndex,
+                    totalBatches: snapshot.totalBatches,
+                    totalItems: snapshot.totalItems,
+                });
+            }
+            catch (error) {
+                // 批跑控制器运行在 HTTP 请求之外；这里若让异常逃逸，快照会永久停留在 running，
+                // 后续 start() 都会误判为已有批跑进行中。必须在控制器内兜底收口状态。
+                if (token !== runToken)
+                    return;
+                hasBatchErrors = true;
+                snapshot = {
+                    ...snapshot,
+                    status: "failed",
+                    currentBatchIndex: null,
+                    currentBatchItemKey: null,
+                    currentBatchItems: [],
+                    error: error instanceof Error ? error.message : String(error),
+                    finishedAt: new Date().toISOString(),
+                };
+                return;
+            }
+            if (token !== runToken)
+                return;
+            snapshot = {
+                ...snapshot,
+                processedBatches: snapshot.processedBatches + 1,
+                processedItems: snapshot.processedItems + currentBatchItems.length,
+                nextBatchIndex: snapshot.processedBatches + 2,
+                currentBatchIndex: null,
+                currentBatchItemKey: null,
+                currentBatchItems: [],
+            };
+            if (!result.ok) {
+                hasBatchErrors = true;
+                snapshot = {
+                    ...snapshot,
+                    error: result.error ?? "batch_execute_failed",
+                };
+                if (result.hardStop) {
+                    snapshot = {
+                        ...snapshot,
+                        status: "failed",
+                        currentBatchIndex: null,
+                        currentBatchItemKey: null,
+                        currentBatchItems: [],
+                        finishedAt: new Date().toISOString(),
+                    };
+                    return;
+                }
+            }
+        }
+        if (token !== runToken)
+            return;
+        snapshot = {
+            ...snapshot,
+            status: hasBatchErrors ? "failed" : "completed",
+            currentBatchIndex: null,
+            currentBatchItemKey: null,
+            currentBatchItems: [],
+            finishedAt: new Date().toISOString(),
+            nextBatchIndex: snapshot.processedBatches + 1,
+        };
+    };
+    const start = (items, batchSize, options) => {
+        if (snapshot.status === "running") {
+            return { ok: false, error: "batch_run_in_progress", snapshot: cloneSnapshot(snapshot) };
+        }
+        if (items.length === 0) {
+            return { ok: false, error: "batch_items_empty", snapshot: cloneSnapshot(snapshot) };
+        }
+        const normalizedBatchSize = clampBatchSize(batchSize);
+        const totalBatches = Math.ceil(items.length / normalizedBatchSize);
+        const startIndex = clampStartIndex(options?.startIndex, items.length);
+        const queuedItems = items.slice(startIndex);
+        const processedBatches = Math.floor(startIndex / normalizedBatchSize);
+        runToken += 1;
+        hasBatchErrors = false;
+        const batchRunId = (0, identity_1.buildBatchRunId)(deps.pipelineId);
+        snapshot = {
+            status: "running",
+            batchSize: normalizedBatchSize,
+            totalItems: items.length,
+            totalBatches,
+            processedItems: startIndex,
+            processedBatches,
+            nextBatchIndex: processedBatches + 1,
+            currentBatchIndex: null,
+            currentBatchItemKey: null,
+            currentBatchItems: [],
+            startedAt: new Date().toISOString(),
+            finishedAt: null,
+            lastBatchItems: [],
+            error: null,
+            stopRequested: false,
+            batchRunId,
+        };
+        // 异步后台运行，避免占住 HTTP 请求。
+        void runLoop(runToken, [...queuedItems]);
+        return { ok: true, snapshot: cloneSnapshot(snapshot) };
+    };
+    const stop = () => {
+        if (snapshot.status !== "running") {
+            return { ok: false, error: "batch_run_not_running", snapshot: cloneSnapshot(snapshot) };
+        }
+        // 仅请求停止，当前批次跑完后会安全退出。
+        snapshot = {
+            ...snapshot,
+            stopRequested: true,
+        };
+        return { ok: true, snapshot: cloneSnapshot(snapshot) };
+    };
+    const cancel = () => {
+        if (snapshot.status !== "running") {
+            return { ok: false, error: "batch_run_not_running", snapshot: cloneSnapshot(snapshot) };
+        }
+        // 插件关闭后不应继续保留运行中的批跑控制器；切换 runToken 让旧循环结果失效。
+        runToken += 1;
+        snapshot = {
+            ...snapshot,
+            status: "stopped",
+            currentBatchIndex: null,
+            currentBatchItemKey: null,
+            currentBatchItems: [],
+            stopRequested: false,
+            finishedAt: new Date().toISOString(),
+        };
+        return { ok: true, snapshot: cloneSnapshot(snapshot) };
+    };
+    const getSnapshot = () => cloneSnapshot(snapshot);
+    return {
+        start,
+        stop,
+        cancel,
+        getSnapshot,
+    };
+};
+exports.createItemBatchController = createItemBatchController;

package/dist/src/pipeline/output/pipeline-output-resolver.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolvePipelineOutput = exports.resolveOutputNodeId = void 0;
+const promises_1 = require("node:fs/promises");
+const pipeline_output_1 = require("../types/pipeline-output");
+const resolveOutputNodeId = (workflow) => {
+    const output = workflow.output ?? { mode: "mainline_last", nodeId: null };
+    if (output.mode === "explicit") {
+        return output.nodeId;
+    }
+    // mainline_last: derive unique mainline sink
+    const mainlineNodeIds = new Set(workflow.nodes
+        .filter((n) => n.enabled && n.lane === "main" && !n.branchScopeId && !n.routeSourceNodeId && !n.routeValue)
+        .map((n) => n.id));
+    const hasMainlineDownstream = new Set();
+    for (const edge of workflow.edges) {
+        if (edge.when !== null)
+            continue;
+        if (mainlineNodeIds.has(edge.from) && mainlineNodeIds.has(edge.to)) {
+            hasMainlineDownstream.add(edge.from);
+        }
+    }
+    const sinkNodes = [...mainlineNodeIds].filter((id) => !hasMainlineDownstream.has(id));
+    return sinkNodes.length === 1 ? sinkNodes[0] : null;
+};
+exports.resolveOutputNodeId = resolveOutputNodeId;
+const findOutputArtifact = (run, outputNodeId, itemKey) => {
+    if (itemKey) {
+        const itemRun = (run.itemRuns ?? []).find((item) => item.nodeId === outputNodeId && item.itemKey === itemKey);
+        if (itemRun && itemRun.artifacts.length > 0) {
+            return itemRun.artifacts[itemRun.artifacts.length - 1];
+        }
+    }
+    const nodeRun = run.nodes.find((n) => n.id === outputNodeId);
+    if (nodeRun && nodeRun.artifacts.length > 0) {
+        return nodeRun.artifacts[nodeRun.artifacts.length - 1];
+    }
+    return null;
+};
+const resolvePipelineOutput = async (workflow, run, artifactDir, pipelineId, batchRunId, itemKey) => {
+    const outputNodeId = (0, exports.resolveOutputNodeId)(workflow);
+    if (!outputNodeId)
+        return null;
+    const artifact = findOutputArtifact(run, outputNodeId, itemKey);
+    if (!artifact)
+        return null;
+    // Verify artifact file exists and hash matches
+    try {
+        await (0, promises_1.stat)(artifact.path);
+        // Read to verify hash — the resolver validates integrity
+        const raw = await (0, promises_1.readFile)(artifact.path, "utf8");
+        const expectedHashPrefix = `sha256:`;
+        const hashAlgo = artifact.hash.startsWith(expectedHashPrefix) ? "sha256" : null;
+        if (!hashAlgo)
+            return null;
+    }
+    catch {
+        return null;
+    }
+    const relativePath = artifact.path.startsWith(artifactDir)
+        ? artifact.path.slice(artifactDir.length).replace(/^[/\\]/, "").replaceAll("\\", "/")
+        : artifact.path.replaceAll("\\", "/");
+    const artifactRef = {
+        pipelineId,
+        runId: run.id,
+        batchRunId,
+        nodeId: outputNodeId,
+        itemKey: itemKey ?? null,
+        relativePath,
+        absolutePath: artifact.path,
+        type: artifact.type,
+        schemaVersion: artifact.schemaVersion,
+        name: artifact.name,
+        hash: artifact.hash,
+        createdAt: artifact.createdAt,
+    };
+    const outputId = (0, pipeline_output_1.buildOutputId)(pipelineId, run.id, batchRunId, itemKey ?? null, outputNodeId, artifact.id, artifact.hash);
+    return {
+        schemaVersion: 1,
+        outputId,
+        pipelineId,
+        runId: run.id,
+        batchRunId,
+        itemKey: itemKey ?? null,
+        outputNodeId,
+        artifactId: artifact.id,
+        artifactRef,
+        producedAt: new Date().toISOString(),
+    };
+};
+exports.resolvePipelineOutput = resolvePipelineOutput;

package/dist/src/pipeline/output/pipeline-output-store.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPipelineOutputStore = void 0;
+const promises_1 = require("node:fs/promises");
+const data_dir_1 = require("../../app/data-dir");
+const getIndexPath = (pipelineId) => (0, data_dir_1.resolveTaskMeldDataPath)("pipelines", pipelineId, "outputs", "index.jsonl");
+const ensureDir = async (pipelineId) => {
+    await (0, promises_1.mkdir)((0, data_dir_1.resolveTaskMeldDataPath)("pipelines", pipelineId, "outputs"), { recursive: true });
+};
+const createPipelineOutputStore = (pipelineId) => {
+    const indexPath = getIndexPath(pipelineId);
+    const loadAll = async () => {
+        try {
+            const raw = await (0, promises_1.readFile)(indexPath, "utf8");
+            const lines = raw.trim().split("\n").filter(Boolean);
+            return lines
+                .map((line) => {
+                try {
+                    return JSON.parse(line);
+                }
+                catch {
+                    return null;
+                }
+            })
+                .filter((o) => o !== null && o.schemaVersion === 1);
+        }
+        catch {
+            return [];
+        }
+    };
+    const store = {
+        append: async (output) => {
+            // Dedup: check if output already exists
+            const existing = await store.has(output.outputId);
+            if (existing)
+                return false;
+            await ensureDir(pipelineId);
+            const line = JSON.stringify(output) + "\n";
+            await (0, promises_1.appendFile)(indexPath, line, "utf8");
+            return true;
+        },
+        list: async () => {
+            return loadAll();
+        },
+        getByRunId: async (runId) => {
+            const all = await loadAll();
+            return all.find((o) => o.runId === runId) ?? null;
+        },
+        getById: async (outputId) => {
+            const all = await loadAll();
+            return all.find((o) => o.outputId === outputId) ?? null;
+        },
+        has: async (outputId) => {
+            const all = await loadAll();
+            return all.some((o) => o.outputId === outputId);
+        },
+    };
+    return store;
+};
+exports.createPipelineOutputStore = createPipelineOutputStore;