taskmeld 0.1.1

package/dist/src/logs/run-log-reader.js

@@ -0,0 +1,141 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readRunLogPage = void 0;
+const node_fs_1 = require("node:fs");
+const node_readline_1 = require("node:readline");
+const guards_1 = require("../utils/guards");
+const MAX_LIMIT = 300;
+const isRunLogLevel = (value) => value === "info" || value === "warn" || value === "error";
+const normalizeLimit = (value) => {
+    // 服务端必须兜底分页，避免前端漏传 limit 时把大型日志一次性读入 V8 堆。
+    if (value === undefined)
+        return MAX_LIMIT;
+    if (!Number.isFinite(value))
+        return MAX_LIMIT;
+    return Math.max(1, Math.min(MAX_LIMIT, Math.trunc(value)));
+};
+const normalizeOffset = (value) => {
+    if (!Number.isFinite(value))
+        return 0;
+    return Math.max(0, Math.trunc(value ?? 0));
+};
+const parseRunLogLine = (line) => {
+    try {
+        const parsed = JSON.parse(line);
+        if (!(0, guards_1.isRecord)(parsed))
+            return null;
+        const id = typeof parsed.id === "string" ? parsed.id.trim() : "";
+        const ts = typeof parsed.ts === "string" ? parsed.ts.trim() : "";
+        const level = parsed.level;
+        const runId = typeof parsed.runId === "string" ? parsed.runId.trim() : "";
+        const text = typeof parsed.text === "string" ? parsed.text : "";
+        if (!id || !ts || !runId || !text || !isRunLogLevel(level))
+            return null;
+        return {
+            id,
+            ts,
+            level,
+            runId,
+            text,
+            ...(parsed.detail === undefined ? {} : { detail: parsed.detail }),
+        };
+    }
+    catch {
+        return null;
+    }
+};
+const stringifyMatchTarget = (entry) => {
+    if (entry.detail === undefined)
+        return entry.text;
+    if (typeof entry.detail === "string")
+        return `${entry.text}\n${entry.detail}`;
+    try {
+        return `${entry.text}\n${JSON.stringify(entry.detail)}`;
+    }
+    catch {
+        return entry.text;
+    }
+};
+const matchesQuery = (entry, query) => {
+    if (entry.runId !== query.runId)
+        return false;
+    if (query.levels && !query.levels.includes(entry.level))
+        return false;
+    if (query.keyword) {
+        const haystack = stringifyMatchTarget(entry).toLowerCase();
+        if (!haystack.includes(query.keyword))
+            return false;
+    }
+    return true;
+};
+const scanRunLogLines = async (logFile, onLine) => {
+    const stream = (0, node_fs_1.createReadStream)(logFile, { encoding: "utf8" });
+    const reader = (0, node_readline_1.createInterface)({
+        input: stream,
+        crlfDelay: Infinity,
+    });
+    try {
+        for await (const line of reader) {
+            if (line.trim().length === 0)
+                continue;
+            onLine(line);
+        }
+    }
+    finally {
+        reader.close();
+    }
+};
+const readRunLogPage = async (logFile, query) => {
+    const limit = normalizeLimit(query.limit);
+    const offset = normalizeOffset(query.offset);
+    const keyword = query.keyword?.trim().toLowerCase() || null;
+    const levels = query.levels && query.levels.length > 0 ? [...new Set(query.levels)] : null;
+    const order = query.order === "asc" ? "asc" : "desc";
+    let parseErrorCount = 0;
+    let total = 0;
+    const matcher = (entry) => matchesQuery(entry, {
+        runId: query.runId,
+        levels,
+        keyword,
+    });
+    await scanRunLogLines(logFile, (line) => {
+        const entry = parseRunLogLine(line);
+        if (!entry) {
+            parseErrorCount += 1;
+            return;
+        }
+        if (matcher(entry))
+            total += 1;
+    });
+    const start = order === "asc"
+        ? offset
+        : Math.max(0, total - offset - limit);
+    const end = order === "asc"
+        ? Math.min(total, offset + limit)
+        : Math.max(0, total - offset);
+    const items = [];
+    let matchedIndex = 0;
+    await scanRunLogLines(logFile, (line) => {
+        if (matchedIndex >= end)
+            return;
+        const entry = parseRunLogLine(line);
+        if (!entry || !matcher(entry))
+            return;
+        if (matchedIndex >= start)
+            items.push(entry);
+        matchedIndex += 1;
+    });
+    if (order === "desc")
+        items.reverse();
+    const nextOffset = offset + items.length < total ? offset + items.length : null;
+    return {
+        items,
+        total,
+        offset,
+        limit,
+        nextOffset,
+        hasMore: nextOffset !== null,
+        parseErrorCount,
+    };
+};
+exports.readRunLogPage = readRunLogPage;

package/dist/src/logs/run-log-service.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRunLogService = void 0;
+const node_fs_1 = require("node:fs");
+const promises_1 = require("node:fs/promises");
+const node_path_1 = require("node:path");
+const run_log_reader_1 = require("./run-log-reader");
+const TIMELINE_LOG_FILE = "timeline.log";
+const createRunLogService = (options) => {
+    const getRunLogPath = (runId) => (0, node_path_1.join)(options.rootDir, runId, TIMELINE_LOG_FILE);
+    const assertRunLogExists = async (runId) => {
+        await (0, promises_1.access)(getRunLogPath(runId), node_fs_1.constants.F_OK);
+    };
+    const queryTimeline = async (query) => {
+        const runId = query.runId.trim();
+        await assertRunLogExists(runId);
+        return (0, run_log_reader_1.readRunLogPage)(getRunLogPath(runId), { ...query, runId });
+    };
+    const readRawTimeline = async (runId) => {
+        const normalizedRunId = runId.trim();
+        await assertRunLogExists(normalizedRunId);
+        return getRunLogPath(normalizedRunId);
+    };
+    const listRuns = async () => {
+        try {
+            const entries = await (0, promises_1.readdir)(options.rootDir, { withFileTypes: true });
+            return entries
+                .filter((entry) => entry.isDirectory())
+                .map((entry) => entry.name)
+                .sort((a, b) => b.localeCompare(a));
+        }
+        catch {
+            return [];
+        }
+    };
+    return {
+        queryTimeline,
+        readRawTimeline,
+        listRuns,
+    };
+};
+exports.createRunLogService = createRunLogService;

package/dist/src/logs/run-log-types.js

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

package/dist/src/pipeline/agent-activity.js

@@ -0,0 +1,191 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAgentActivityTracker = void 0;
+const SESSION_AGENT_PATTERN = /^agent:([^:]+):/i;
+const findStringByKeys = (value, keys, depth = 0) => {
+    if (depth > 5 || value === null || value === undefined)
+        return null;
+    if (typeof value === "string")
+        return value.trim() || null;
+    if (Array.isArray(value)) {
+        for (const item of value) {
+            const found = findStringByKeys(item, keys, depth + 1);
+            if (found)
+                return found;
+        }
+        return null;
+    }
+    if (typeof value !== "object")
+        return null;
+    const record = value;
+    for (const key of keys) {
+        const raw = record[key];
+        if (typeof raw === "string" && raw.trim())
+            return raw.trim();
+    }
+    for (const item of Object.values(record)) {
+        const found = findStringByKeys(item, keys, depth + 1);
+        if (found)
+            return found;
+    }
+    return null;
+};
+const inferLifecycle = (payload) => {
+    const marker = (findStringByKeys(payload, ["status", "state", "phase", "event", "type", "kind"]) ?? "").toLowerCase();
+    if (!marker)
+        return "unknown";
+    if (marker.includes("start") ||
+        marker.includes("running") ||
+        marker.includes("in_progress") ||
+        marker.includes("processing") ||
+        marker.includes("stream")) {
+        return "start";
+    }
+    if (marker.includes("done") ||
+        marker.includes("finish") ||
+        marker.includes("complete") ||
+        marker.includes("success") ||
+        marker.includes("failed") ||
+        marker.includes("error") ||
+        marker.includes("idle") ||
+        marker.includes("stop")) {
+        return "end";
+    }
+    return "unknown";
+};
+const createAgentActivityTracker = (deps) => {
+    const activeAgents = new Set();
+    const toActivityKey = (agentId, runId) => `${runId ?? "global"}::${agentId}`;
+    const runLabel = (runId) => (runId ? `run:${runId}` : "run:unknown");
+    const pushLifecycle = (agentId, runId, lifecycle, source, frame) => {
+        const detail = {
+            source,
+            agentId,
+            runId,
+            lifecycle,
+            seq: frame.seq ?? null,
+            stateVersion: frame.stateVersion ?? null,
+        };
+        if (lifecycle === "start") {
+            deps.pushTimeline(`Agent ${agentId} 开始工作 (${runLabel(runId)}, ${source})`, "info", detail);
+            return;
+        }
+        deps.pushTimeline(`Agent ${agentId} 结束工作 (${runLabel(runId)}, ${source})`, "info", detail);
+    };
+    const refreshAgentActivity = (agentId, source, runId, frame) => {
+        const activityKey = toActivityKey(agentId, runId);
+        if (!activeAgents.has(activityKey)) {
+            activeAgents.add(activityKey);
+            pushLifecycle(agentId, runId, "start", source, frame);
+        }
+    };
+    const endAgentActivity = (agentId, source, runId, frame) => {
+        const endAllByAgent = (labelRunId) => {
+            const keys = [...activeAgents].filter((key) => key.endsWith(`::${agentId}`));
+            for (const key of keys) {
+                activeAgents.delete(key);
+            }
+            if (keys.length > 0) {
+                pushLifecycle(agentId, labelRunId, "end", source, frame);
+            }
+        };
+        if (!runId) {
+            endAllByAgent(null);
+            return;
+        }
+        const activityKey = toActivityKey(agentId, runId);
+        if (activeAgents.has(activityKey)) {
+            activeAgents.delete(activityKey);
+            pushLifecycle(agentId, runId, "end", source, frame);
+            return;
+        }
+        // Some gateways emit different runId formats between start/end events.
+        // Fallback: end all active runs for this agent to avoid stale busy state.
+        endAllByAgent(runId);
+    };
+    const normalizeAgentId = (candidate) => {
+        if (!candidate)
+            return null;
+        const trimmed = candidate.trim();
+        return trimmed || null;
+    };
+    const inferAgentIdFromSessionId = (sessionId) => {
+        const mapped = deps.resolveAgentBySessionId(sessionId);
+        const normalizedMapped = normalizeAgentId(mapped);
+        if (normalizedMapped)
+            return normalizedMapped;
+        const matched = sessionId.match(SESSION_AGENT_PATTERN);
+        if (!matched)
+            return null;
+        return normalizeAgentId(matched[1]);
+    };
+    const resolveAgentFromPayload = (payload) => {
+        // For gateway agent/chat events, sessionKey is the stable source of agent identity.
+        // Do not trust generic payload agentId/runId fields (they may be per-run UUIDs).
+        const sessionId = findStringByKeys(payload, ["sessionKey", "sessionId", "key", "session"]);
+        if (!sessionId)
+            return null;
+        return inferAgentIdFromSessionId(sessionId);
+    };
+    const handleFrame = (frame) => {
+        if (frame.type !== "event")
+            return;
+        const eventFrame = frame;
+        const payload = eventFrame.payload;
+        if (!payload)
+            return;
+        const agentId = resolveAgentFromPayload(payload);
+        if (!agentId)
+            return;
+        const runIdRaw = payload.runId;
+        const runId = typeof runIdRaw === "string" && runIdRaw.trim() ? runIdRaw.trim() : null;
+        if (eventFrame.event === "agent") {
+            const stream = typeof payload.stream === "string" ? payload.stream : "";
+            if (stream !== "lifecycle")
+                return;
+            const lifecycle = inferLifecycle(payload.data);
+            if (lifecycle === "start") {
+                refreshAgentActivity(agentId, "event:agent.lifecycle", runId, eventFrame);
+                return;
+            }
+            if (lifecycle === "end") {
+                endAgentActivity(agentId, "event:agent.lifecycle", runId, eventFrame);
+            }
+            return;
+        }
+        if (eventFrame.event === "sessions.changed") {
+            const phase = findStringByKeys(payload, ["phase"])?.toLowerCase() ?? "";
+            const status = findStringByKeys(payload, ["status"])?.toLowerCase() ?? "";
+            const isStart = phase === "start" || status === "running";
+            const isEnd = phase === "end" ||
+                status === "done" ||
+                status === "idle" ||
+                status === "completed" ||
+                status === "stopped" ||
+                status === "success" ||
+                status === "failed";
+            if (isStart) {
+                refreshAgentActivity(agentId, "event:sessions.changed", runId, eventFrame);
+                return;
+            }
+            if (isEnd) {
+                endAgentActivity(agentId, "event:sessions.changed", runId, eventFrame);
+            }
+            return;
+        }
+        if (eventFrame.event === "chat") {
+            const state = findStringByKeys(payload, ["state"])?.toLowerCase() ?? "";
+            if (state === "final" || state === "done" || state === "end" || state === "completed") {
+                endAgentActivity(agentId, "event:chat.final", runId, eventFrame);
+            }
+        }
+    };
+    const dispose = () => {
+        activeAgents.clear();
+    };
+    return {
+        handleFrame,
+        dispose,
+    };
+};
+exports.createAgentActivityTracker = createAgentActivityTracker;

package/dist/src/pipeline/artifact-storage.js

@@ -0,0 +1,208 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.persistEnvelopeFile = exports.appendMovedArtifactIndexRecord = exports.persistArtifactFile = exports.buildArtifactStorageDirs = void 0;
+const node_crypto_1 = require("node:crypto");
+const promises_1 = require("node:fs/promises");
+const node_path_1 = require("node:path");
+const artifact_index_1 = require("../artifacts/artifact-index");
+const pad2 = (value) => String(value).padStart(2, "0");
+const formatLocalDateBucket = (at) => `${at.getFullYear()}-${pad2(at.getMonth() + 1)}-${pad2(at.getDate())}`;
+const buildArtifactStorageDirs = (rootDir, runId, status, savedAt = new Date(), batchRunId) => {
+    // 运行产物需要按"结果状态/日期/runId"归档，避免目录长期平铺后难以按日排障或批量清理。
+    // envelopes 与 artifacts 分桶存放，是为了把节点回执和实际产物内容分开，减少误读与误删风险。
+    const dateBucket = formatLocalDateBucket(savedAt);
+    const runDir = batchRunId
+        ? (0, node_path_1.join)(rootDir, status, dateBucket, batchRunId, runId)
+        : (0, node_path_1.join)(rootDir, status, dateBucket, runId);
+    return {
+        dateBucket,
+        runDir,
+        envelopesDir: (0, node_path_1.join)(runDir, "envelopes"),
+        artifactsDir: (0, node_path_1.join)(runDir, "artifacts"),
+    };
+};
+exports.buildArtifactStorageDirs = buildArtifactStorageDirs;
+const sanitizeFileSegment = (value) => {
+    const normalized = value
+        .trim()
+        .replace(/[<>:"/\\|?*\x00-\x1F]/g, "_")
+        .replace(/\s+/g, "_")
+        .replace(/\.+$/g, "_");
+    return normalized || "unnamed";
+};
+/**
+ * 产物文件统一写入入口。
+ * 负责：目录创建、原子写入（临时文件 + rename）、真实 SHA-256 哈希计算、索引追加、ArtifactManifest 构造。
+ */
+const persistArtifactFile = async (rootDir, status, ctx, artifact, opts) => {
+    const savedAt = opts?.savedAt ?? new Date();
+    const persistDirs = (0, exports.buildArtifactStorageDirs)(rootDir, ctx.runId, status, savedAt, ctx.batchRunId);
+    await (0, promises_1.mkdir)(persistDirs.artifactsDir, { recursive: true });
+    // 统一的文件序列化格式，kind 字段供读取端分发
+    const fileContent = {
+        schemaVersion: 1,
+        runId: ctx.runId,
+        batchRunId: ctx.batchRunId ?? null,
+        nodeId: ctx.nodeId ?? null,
+        groupId: ctx.groupId ?? null,
+        itemKey: ctx.itemKey ?? null,
+        requestId: ctx.requestId ?? null,
+        kind: ctx.kind,
+        savedAt: savedAt.toISOString(),
+        artifact,
+    };
+    const fileNameSegments = [sanitizeFileSegment(ctx.runId), sanitizeFileSegment(ctx.nodeId ?? ctx.groupId ?? "unknown")];
+    if (opts?.fileNameSuffix)
+        fileNameSegments.push(sanitizeFileSegment(opts.fileNameSuffix));
+    const fileName = `${fileNameSegments.join("-")}.json`;
+    // 原子写入: 先写临时文件，计算 hash，再 rename 到最终路径
+    const tmpFileName = `.tmp-${(0, node_crypto_1.randomUUID)()}.json`;
+    const tmpPath = (0, node_path_1.join)(persistDirs.artifactsDir, tmpFileName);
+    const json = JSON.stringify(fileContent, null, 2);
+    await (0, promises_1.writeFile)(tmpPath, json, "utf8");
+    const hash = `sha256:${(0, node_crypto_1.createHash)("sha256").update(json).digest("hex")}`;
+    const finalPath = (0, node_path_1.join)(persistDirs.artifactsDir, fileName);
+    await (0, promises_1.rename)(tmpPath, finalPath);
+    const fileStat = await (0, promises_1.stat)(finalPath);
+    const manifestId = (0, node_crypto_1.randomUUID)();
+    const createdAt = new Date().toISOString();
+    const updatedAt = fileStat.mtime.toISOString();
+    const relativePath = (0, node_path_1.relative)(rootDir, finalPath).replaceAll("\\", "/");
+    // 追加索引记录（best-effort，失败不阻断产物写入）
+    const pipelineId = ctx.pipelineId;
+    const indexRecord = {
+        schemaVersion: 1,
+        artifactId: manifestId,
+        pipelineId,
+        status,
+        kind: ctx.kind,
+        dateBucket: persistDirs.dateBucket,
+        runId: ctx.runId,
+        batchRunId: ctx.batchRunId ?? null,
+        nodeId: ctx.nodeId ?? null,
+        groupId: ctx.groupId ?? null,
+        itemKey: ctx.itemKey ?? null,
+        requestId: ctx.requestId ?? null,
+        type: artifact.type,
+        artifactSchemaVersion: artifact.schemaVersion,
+        name: artifact.name,
+        relativePath,
+        sizeBytes: fileStat.size,
+        hash,
+        createdAt,
+        updatedAt,
+    };
+    // 追加索引记录：文件已通过 tmp+rename 原子写入磁盘，索引追加失败不丢失产物文件
+    const _ir = await (0, artifact_index_1.appendIndexRecord)(rootDir, indexRecord);
+    void _ir;
+    return {
+        id: manifestId,
+        type: artifact.type,
+        schemaVersion: artifact.schemaVersion,
+        name: artifact.name,
+        path: finalPath,
+        hash,
+        sourceNodeId: ctx.nodeId ?? ctx.groupId ?? "unknown",
+        createdAt,
+    };
+};
+exports.persistArtifactFile = persistArtifactFile;
+/** 产物移动（如 rejected 归档）后补记索引，使查询端通过 artifactId 去重拿到最新位置。 */
+const appendMovedArtifactIndexRecord = async (rootDir, input) => {
+    const targetPath = (0, node_path_1.resolve)(rootDir, input.relativePath);
+    const fileStat = await (0, promises_1.stat)(targetPath);
+    const segments = input.relativePath.split("/").filter(Boolean);
+    const dateBucket = segments[1] ?? formatLocalDateBucket(input.movedAt);
+    const batchRunId = segments[2]?.startsWith("batch-") ? segments[2] : null;
+    const runId = batchRunId ? segments[3] ?? null : segments[2] ?? null;
+    const pipelineId = input.pipelineId;
+    const _ir2 = await (0, artifact_index_1.appendIndexRecord)(rootDir, {
+        schemaVersion: 1,
+        artifactId: input.manifest.id,
+        pipelineId,
+        status: input.status,
+        kind: "artifact",
+        dateBucket,
+        runId,
+        batchRunId,
+        nodeId: input.manifest.sourceNodeId,
+        groupId: null,
+        itemKey: null,
+        requestId: null,
+        type: input.manifest.type,
+        artifactSchemaVersion: input.manifest.schemaVersion,
+        name: input.manifest.name,
+        relativePath: input.relativePath,
+        sizeBytes: fileStat.size,
+        hash: input.manifest.hash,
+        createdAt: input.manifest.createdAt,
+        updatedAt: input.movedAt.toISOString(),
+    });
+};
+exports.appendMovedArtifactIndexRecord = appendMovedArtifactIndexRecord;
+/** 保存 envelope 回执文件到 envelopes 子目录并追加索引，使 kind=envelope 可在列表中查询。 */
+const persistEnvelopeFile = async (rootDir, status, ctx, envelope, opts) => {
+    const savedAt = opts?.savedAt ?? new Date();
+    const persistDirs = (0, exports.buildArtifactStorageDirs)(rootDir, ctx.runId, status, savedAt, ctx.batchRunId);
+    await (0, promises_1.mkdir)(persistDirs.envelopesDir, { recursive: true });
+    const fileName = `${sanitizeFileSegment(ctx.runId)}-${sanitizeFileSegment(ctx.nodeId ?? "unknown")}-${sanitizeFileSegment(ctx.requestId ?? "envelope")}-envelope.json`;
+    const fileContent = {
+        schemaVersion: 1,
+        runId: ctx.runId,
+        batchRunId: ctx.batchRunId ?? null,
+        nodeId: ctx.nodeId ?? null,
+        requestId: ctx.requestId ?? null,
+        kind: "envelope",
+        savedAt: savedAt.toISOString(),
+        envelope,
+    };
+    const tmpFileName = `.tmp-${(0, node_crypto_1.randomUUID)()}.json`;
+    const tmpPath = (0, node_path_1.join)(persistDirs.envelopesDir, tmpFileName);
+    const json = JSON.stringify(fileContent, null, 2);
+    await (0, promises_1.writeFile)(tmpPath, json, "utf8");
+    const hash = `sha256:${(0, node_crypto_1.createHash)("sha256").update(json).digest("hex")}`;
+    const finalPath = (0, node_path_1.join)(persistDirs.envelopesDir, fileName);
+    await (0, promises_1.rename)(tmpPath, finalPath);
+    const fileStat = await (0, promises_1.stat)(finalPath);
+    const manifestId = (0, node_crypto_1.randomUUID)();
+    const createdAt = new Date().toISOString();
+    const updatedAt = fileStat.mtime.toISOString();
+    const relativePathStr = (0, node_path_1.relative)(rootDir, finalPath).replaceAll("\\", "/");
+    const pipelineId = ctx.pipelineId;
+    const indexRecord = {
+        schemaVersion: 1,
+        artifactId: manifestId,
+        pipelineId,
+        status,
+        kind: "envelope",
+        dateBucket: persistDirs.dateBucket,
+        runId: ctx.runId,
+        batchRunId: ctx.batchRunId ?? null,
+        nodeId: ctx.nodeId ?? null,
+        groupId: null,
+        itemKey: null,
+        requestId: ctx.requestId ?? null,
+        type: "structured-output-envelope",
+        artifactSchemaVersion: 1,
+        name: "envelope",
+        relativePath: relativePathStr,
+        sizeBytes: fileStat.size,
+        hash,
+        createdAt,
+        updatedAt,
+    };
+    // 追加索引记录：文件已通过 tmp+rename 原子写入磁盘，索引追加失败不丢失产物文件
+    const _ir = await (0, artifact_index_1.appendIndexRecord)(rootDir, indexRecord);
+    void _ir;
+    return {
+        id: manifestId,
+        type: "structured-output-envelope",
+        schemaVersion: 1,
+        name: "envelope",
+        path: finalPath,
+        hash,
+        sourceNodeId: ctx.nodeId ?? "unknown",
+        createdAt,
+    };
+};
+exports.persistEnvelopeFile = persistEnvelopeFile;