taskmeld 0.1.1

package/dist/src/app/pipeline-runtime.js

@@ -0,0 +1,202 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPipelineRuntime = void 0;
+const http_utils_1 = require("../server/http-utils");
+const template_1 = require("../pipeline/template");
+const execution_timeout_1 = require("../pipeline/execution-timeout");
+const runtime_model_1 = require("../pipeline/runtime-model");
+const array_1 = require("../utils/array");
+const workflow_graph_1 = require("../pipeline/workflow-graph");
+const runtime_store_1 = require("./runtime-store");
+const execution_1 = require("../pipeline/execution");
+const scheduler_service_1 = require("../pipeline/scheduler-service");
+const createPipelineRuntime = (options) => {
+    const graph = (0, workflow_graph_1.createWorkflowGraph)((0, template_1.loadWorkflowDefinitionWithStorage)({ workflowFilePath: options.workflowFilePath }), (0, template_1.loadPipelineTemplateWithStorage)({ workflowFilePath: options.workflowFilePath }));
+    const initialRun = (0, runtime_model_1.seedRunWithItems)(graph.getTemplateNodes(), options.defaultItemKeys);
+    let schedulerStateAccessor = () => ({ enabled: graph.getWorkflow().scheduler.enabled, mode: graph.getWorkflow().scheduler.mode });
+    let batchRunStateGetter = () => null;
+    const runtimeStore = (0, runtime_store_1.createRuntimeStore)({
+        graph,
+        defaultItemKeys: options.defaultItemKeys,
+        runStateFile: options.runStateFile,
+        initialRun,
+        getSchedulerState: () => schedulerStateAccessor(),
+        getBatchRunState: () => batchRunStateGetter(),
+    });
+    let getBatchRunId = () => null;
+    const executionService = (0, execution_1.createExecutionService)({
+        client: options.client,
+        runtimeStore,
+        graph,
+        artifactDir: options.artifactDir,
+        pipelineId: options.pipelineId,
+        pipelineNodeExecutionTimeoutMs: (0, execution_timeout_1.getPipelineNodeExecutionTimeoutMs)(),
+        defaultItemKeys: options.defaultItemKeys,
+        getBatchRunId: () => getBatchRunId(),
+    });
+    const schedulerService = (0, scheduler_service_1.createSchedulerService)({
+        pipelineId: options.pipelineId,
+        runtimeStore,
+        graph,
+        defaultItemKeys: options.defaultItemKeys,
+        executionService,
+        onRunCompleted: options.onRunCompleted,
+    });
+    getBatchRunId = () => schedulerService.getBatchRunState().batchRunId;
+    schedulerStateAccessor = schedulerService.getSchedulerState;
+    batchRunStateGetter = () => schedulerService.getBatchRunState();
+    const sendJson = (res, code, data) => (0, http_utils_1.sendJson)(res, code, data, options.webOrigin);
+    const setRun = (nextRun) => {
+        runtimeStore.setRun(nextRun);
+        graph.syncRunGroupsFromWorkflow(nextRun);
+        if (!nextRun.itemRuns || nextRun.itemRuns.length === 0) {
+            runtimeStore.setRun((0, runtime_model_1.seedRunWithItems)(graph.getTemplateNodes(), options.defaultItemKeys));
+            graph.syncRunGroupsFromWorkflow(runtimeStore.getRun());
+        }
+    };
+    const setTemplateNodes = (nextNodes) => {
+        graph.setTemplateNodes(nextNodes);
+    };
+    const setWorkflow = (nextWorkflow) => {
+        graph.setWorkflow(nextWorkflow);
+        schedulerService.syncSchedulerStateFromWorkflow();
+        graph.syncRunGroupsFromWorkflow(runtimeStore.getRun());
+    };
+    const onGatewayStatus = (status) => {
+        runtimeStore.setLatestStatus(status);
+        runtimeStore.pushTimeline(`网关状态: ${status.status}`, status.status.includes("failed") ? "error" : "info");
+        runtimeStore.broadcast({
+            type: "gateway.status",
+            payload: status,
+        });
+    };
+    const onGatewayFrame = (frame) => {
+        const isHealthEvent = frame.type === "event" && frame.event === "health";
+        const isTickEvent = frame.type === "event" && frame.event === "tick";
+        const isSilentEvent = isHealthEvent || isTickEvent;
+        runtimeStore.setLastFrame(frame);
+        if (frame.type === "event" && !isSilentEvent) {
+            runtimeStore.pushTimeline(`事件: ${frame.event}`, "info", {
+                type: "event",
+                event: frame.event,
+                seq: frame.seq ?? null,
+                stateVersion: frame.stateVersion ?? null,
+                payload: frame.payload ?? null,
+            });
+        }
+        // health / tick 都是高频事件，只保留为 lastFrame，不推送到 timeline / ws，
+        // 避免前端与日志被刷屏，同时不影响依赖最后一帧做诊断的调试能力。
+        if (!isSilentEvent) {
+            runtimeStore.broadcast({
+                type: "gateway.frame",
+                payload: frame,
+            });
+        }
+    };
+    const onGatewayRawFrame = (rawFrame) => {
+        executionService.onGatewayFrame(rawFrame);
+    };
+    const onGatewayError = (error) => {
+        runtimeStore.pushTimeline(`网关错误: ${String(error)}`, "error");
+        runtimeStore.broadcast({
+            type: "gateway.error",
+            payload: { message: String(error) },
+        });
+    };
+    const onGatewayReady = (hello) => {
+        runtimeStore.setLatestHello(hello);
+        runtimeStore.pushTimeline("网关握手完成");
+        runtimeStore.emitPipeline();
+        runtimeStore.broadcast({
+            type: "gateway.ready",
+            payload: hello,
+        });
+    };
+    const getBootstrapPayload = () => {
+        const run = runtimeStore.getRun();
+        const nodesWithWorkflowMeta = graph.getNodesWithWorkflowMeta(run.nodes);
+        return {
+            status: runtimeStore.getLatestStatus() ?? options.client.getStatus(),
+            timeline: runtimeStore.getTimeline(),
+            run: { ...run, nodes: nodesWithWorkflowMeta },
+            pipeline: nodesWithWorkflowMeta,
+            runId: run.id,
+            hello: runtimeStore.getLatestHello(),
+            scheduler: schedulerService.getSchedulerState(),
+            batchRunState: schedulerService.getBatchRunState(),
+        };
+    };
+    const hasActiveSession = (sessionKey) => {
+        return executionService.hasActiveSession?.(sessionKey) ?? false;
+    };
+    const initialize = async () => {
+        await runtimeStore.restorePersistedRunState();
+    };
+    return {
+        initialize,
+        dispose: () => executionService.dispose(),
+        sendJson,
+        getBootstrapPayload,
+        onGatewayStatus,
+        onGatewayFrame,
+        onGatewayRawFrame,
+        hasActiveSession,
+        onGatewayError,
+        onGatewayReady,
+        runtime: {
+            setBroadcast: runtimeStore.setBroadcast,
+            pushTimeline: runtimeStore.pushTimeline,
+            emitPipeline: runtimeStore.emitPipeline,
+            getRun: runtimeStore.getRun,
+            setRun,
+            seedRun: runtimeStore.seedRun,
+            getTimeline: runtimeStore.getTimeline,
+            touchRun: runtime_model_1.touchRun,
+        },
+        gateway: {
+            client: options.client,
+            getLatestStatus: runtimeStore.getLatestStatus,
+            getLatestHello: runtimeStore.getLatestHello,
+            getLastFrame: runtimeStore.getLastFrame,
+            refreshSessionsFromGateway: executionService.refreshSessionsFromGateway,
+            getSessionCache: executionService.getSessionCache,
+            getExecutorSessionByAgentId: executionService.getExecutorSessionByAgentId,
+            pickArray: array_1.pickArray,
+        },
+        workflow: {
+            getTemplateNodes: graph.getTemplateNodes,
+            setTemplateNodes,
+            getWorkflow: graph.getWorkflow,
+            setWorkflow,
+            mergeTemplateNodesIntoWorkflow: template_1.mergeTemplateNodesIntoWorkflow,
+            getWorkflowNodeById: graph.getWorkflowNodeById,
+            getIncomingEdges: graph.getIncomingEdges,
+            isCrossBranchEdge: graph.isCrossBranchEdge,
+            isGroupId: graph.isGroupId,
+            isWorkflowNodeEnabled: graph.isWorkflowNodeEnabled,
+            pipelineId: options.pipelineId,
+        },
+        pipeline: {
+            getItemRuns: () => runtimeStore.getRun().itemRuns ?? [],
+            executeNode: executionService.executeNode,
+            retryNodeExecution: schedulerService.retryNodeExecution,
+            drainPipeline: schedulerService.drainPipeline,
+            getSchedulerState: schedulerService.getSchedulerState,
+            setSchedulerEnabled: schedulerService.setSchedulerEnabled,
+            setSchedulerMode: schedulerService.setSchedulerMode,
+            getBatchRunState: schedulerService.getBatchRunState,
+            startBatchRun: schedulerService.startBatchRun,
+            stopBatchRun: schedulerService.stopBatchRun,
+            cancelBatchRun: schedulerService.cancelBatchRun,
+            abortRunControllers: executionService.abortRunControllers,
+            getOrCreateDrainSignal: executionService.getOrCreateDrainSignal,
+        },
+        output: {
+            list: options.outputStore.list.bind(options.outputStore),
+            getByRunId: options.outputStore.getByRunId.bind(options.outputStore),
+            getById: options.outputStore.getById.bind(options.outputStore),
+            append: options.outputStore.append.bind(options.outputStore),
+        },
+    };
+};
+exports.createPipelineRuntime = createPipelineRuntime;

package/dist/src/app/runtime-store.js

@@ -0,0 +1,151 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRuntimeStore = void 0;
+const promises_1 = require("node:fs/promises");
+const frame_sanitizer_1 = require("../gateway/frame-sanitizer");
+const runtime_model_1 = require("../pipeline/runtime-model");
+const timeline_log_store_1 = require("../pipeline/timeline-log-store");
+const data_dir_1 = require("./data-dir");
+const createRuntimeStore = (options) => {
+    const timeline = [];
+    let run = options.initialRun;
+    let latestStatus = null;
+    let latestHello = null;
+    let lastFrame = null;
+    let broadcast = () => { };
+    let persistRunStateInFlight = null;
+    const timelineLogStore = (0, timeline_log_store_1.createTimelineLogStore)({
+        rootDir: (0, data_dir_1.resolveTaskMeldDataPath)("logs", "runs"),
+    });
+    const persistRunState = async () => {
+        if (persistRunStateInFlight)
+            return persistRunStateInFlight;
+        persistRunStateInFlight = (async () => {
+            try {
+                await (0, promises_1.mkdir)((0, data_dir_1.resolveTaskMeldDataPath)(), { recursive: true });
+                await (0, promises_1.writeFile)(options.runStateFile, JSON.stringify({
+                    savedAt: new Date().toISOString(),
+                    workflowVersion: options.graph.getWorkflow().version,
+                    run,
+                }, null, 2), "utf8");
+            }
+            catch (error) {
+                // Persistence failures should not break pipeline execution.
+                pushTimeline(`持久化运行状态失败: ${error instanceof Error ? error.message : String(error)}`, "warn");
+            }
+        })().finally(() => {
+            persistRunStateInFlight = null;
+        });
+        return persistRunStateInFlight;
+    };
+    const tryLoadPersistedRunState = async () => {
+        try {
+            const raw = await (0, promises_1.readFile)(options.runStateFile, "utf8");
+            const parsed = JSON.parse(raw);
+            if (!parsed || typeof parsed !== "object")
+                return null;
+            const payload = parsed;
+            const savedRun = payload.run;
+            if (!savedRun || !Array.isArray(savedRun.nodes))
+                return null;
+            if (!Array.isArray(savedRun.itemRuns))
+                return null;
+            if (!Array.isArray(savedRun.groups))
+                savedRun.groups = [];
+            if (!Array.isArray(savedRun.groupItemRuns))
+                savedRun.groupItemRuns = [];
+            if (!savedRun.input)
+                savedRun.input = { trigger: "manual" };
+            if (savedRun.output === undefined)
+                savedRun.output = null;
+            const nodeIds = new Set(savedRun.nodes.map((node) => node.id));
+            const templateNodes = options.graph.getTemplateNodes();
+            if (nodeIds.size !== templateNodes.length)
+                return null;
+            for (const node of templateNodes) {
+                if (!nodeIds.has(node.id))
+                    return null;
+            }
+            return savedRun;
+        }
+        catch (error) {
+            pushTimeline(`加载持久化运行状态失败: ${error instanceof Error ? error.message : String(error)}`, "warn");
+            return null;
+        }
+    };
+    const pushTimeline = (text, level = "info", detail) => {
+        const safeDetail = detail !== undefined ? (0, frame_sanitizer_1.sanitizeDiagnosticPayload)(detail) : undefined;
+        const item = (0, runtime_model_1.addTimeline)(timeline, text, level, safeDetail);
+        void timelineLogStore.appendTimeline(run.id, item);
+        broadcast({
+            type: "timeline.updated",
+            payload: { item },
+        });
+    };
+    const emitPipeline = () => {
+        options.graph.syncRunGroupsFromWorkflow(run);
+        (0, runtime_model_1.syncRunNodeStatusFromItemRuns)(run);
+        (0, runtime_model_1.touchRun)(run);
+        const nodesWithWorkflowMeta = options.graph.getNodesWithWorkflowMeta(run.nodes);
+        broadcast({
+            type: "pipeline.updated",
+            payload: {
+                run: { ...run, nodes: nodesWithWorkflowMeta },
+                runId: run.id,
+                nodes: nodesWithWorkflowMeta,
+                scheduler: { ...options.getSchedulerState() },
+                ...(options.getBatchRunState ? { batchRunState: options.getBatchRunState() } : {}),
+            },
+        });
+        void persistRunState();
+    };
+    const restorePersistedRunState = async () => {
+        const persisted = await tryLoadPersistedRunState();
+        if (!persisted)
+            return;
+        run = persisted;
+        options.graph.syncRunGroupsFromWorkflow(run);
+        (0, runtime_model_1.syncRunNodeStatusFromItemRuns)(run);
+        (0, runtime_model_1.touchRun)(run);
+        pushTimeline(`已恢复上次运行状态: ${run.id}`);
+        emitPipeline();
+    };
+    const bootstrapRun = () => {
+        if (run.itemRuns && run.itemRuns.length > 0)
+            return;
+        run = (0, runtime_model_1.seedRunWithItems)(options.graph.getTemplateNodes(), options.defaultItemKeys);
+        options.graph.syncRunGroupsFromWorkflow(run);
+    };
+    return {
+        getRun: () => run,
+        setRun: (nextRun) => {
+            run = nextRun;
+        },
+        bootstrapRun,
+        seedRun: (nodes = options.graph.getTemplateNodes(), itemKeys = options.defaultItemKeys) => (0, runtime_model_1.seedRunWithItems)(nodes, itemKeys),
+        getTimeline: () => timeline,
+        pushTimeline,
+        emitPipeline,
+        restorePersistedRunState,
+        persistRunState,
+        setBroadcast: (nextBroadcast) => {
+            broadcast = nextBroadcast;
+        },
+        broadcast: (payload) => {
+            broadcast(payload);
+        },
+        getLatestStatus: () => latestStatus,
+        setLatestStatus: (status) => {
+            latestStatus = status;
+        },
+        getLatestHello: () => latestHello,
+        setLatestHello: (hello) => {
+            latestHello = hello;
+        },
+        getLastFrame: () => lastFrame,
+        setLastFrame: (frame) => {
+            lastFrame = frame;
+        },
+    };
+};
+exports.createRuntimeStore = createRuntimeStore;

package/dist/src/app/user-config.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveGatewayConfig = exports.writeUserConfig = exports.readUserConfig = void 0;
+const node_os_1 = require("node:os");
+const node_path_1 = require("node:path");
+const promises_1 = require("node:fs/promises");
+const userConfigDir = (0, node_path_1.join)((0, node_os_1.homedir)(), ".taskmeld");
+const userConfigPath = (0, node_path_1.join)(userConfigDir, "config.json");
+const readUserConfig = async () => {
+    try {
+        const raw = await (0, promises_1.readFile)(userConfigPath, "utf8");
+        const parsed = JSON.parse(raw);
+        return {
+            gatewayUrl: typeof parsed.gatewayUrl === "string" ? parsed.gatewayUrl.trim() : undefined,
+            gatewayToken: typeof parsed.gatewayToken === "string" ? parsed.gatewayToken.trim() : undefined,
+        };
+    }
+    catch {
+        return {};
+    }
+};
+exports.readUserConfig = readUserConfig;
+const writeUserConfig = async (config) => {
+    await (0, promises_1.mkdir)(userConfigDir, { recursive: true });
+    const existing = await (0, exports.readUserConfig)();
+    const merged = { ...existing, ...config };
+    await (0, promises_1.writeFile)(userConfigPath, JSON.stringify(merged, null, 2) + "\n", "utf8");
+};
+exports.writeUserConfig = writeUserConfig;
+const resolveGatewayConfig = async () => {
+    const userConfig = await (0, exports.readUserConfig)();
+    return {
+        url: process.env.OPENCLAW_GATEWAY_URL?.trim() || userConfig.gatewayUrl || null,
+        token: process.env.OPENCLAW_GATEWAY_TOKEN?.trim() || userConfig.gatewayToken || null,
+    };
+};
+exports.resolveGatewayConfig = resolveGatewayConfig;

package/dist/src/artifacts/artifact-cleanup.js

@@ -0,0 +1,192 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cleanupTempFiles = exports.cleanupEmptyDirs = exports.executeCleanup = exports.planCleanup = void 0;
+const promises_1 = require("node:fs/promises");
+const node_path_1 = require("node:path");
+const storage_service_1 = require("./storage-service");
+const artifact_index_1 = require("./artifact-index");
+const DEFAULT_RETENTION_DAYS = {
+    success: 30,
+    failed: 90,
+    rejected: 90,
+};
+const ONE_DAY_MS = 24 * 60 * 60 * 1000;
+/**
+ * 生成清理计划，不删除任何文件。
+ * 默认只清理 success 状态，可通过 options 指定其他状态。
+ */
+const planCleanup = async (definition, options = {}) => {
+    const statuses = options.statuses?.length ? options.statuses : ["success"];
+    const safeStatuses = statuses.filter((s) => s !== "unknown");
+    const statusFilter = new Set(safeStatuses);
+    const kindFilter = options.kinds?.length ? new Set(options.kinds) : null;
+    const olderThanDays = options.olderThanDays ?? Math.max(...safeStatuses.map((s) => DEFAULT_RETENTION_DAYS[s] ?? 90));
+    const cutoffMs = Date.now() - olderThanDays * ONE_DAY_MS;
+    // 优先从索引获取文件列表，索引缺失时回退扫描
+    let items = await (0, artifact_index_1.readIndexRecords)(definition.artifactDir);
+    if (items.length === 0) {
+        const scanned = await (0, storage_service_1.scanStoredArtifacts)([definition]);
+        items = scanned.map((item) => ({
+            schemaVersion: 1,
+            artifactId: "",
+            pipelineId: item.pipelineId,
+            status: item.status,
+            kind: "artifact",
+            dateBucket: item.dateBucket,
+            runId: item.runId,
+            batchRunId: null,
+            nodeId: item.nodeId,
+            groupId: null,
+            itemKey: null,
+            requestId: null,
+            type: "unknown",
+            artifactSchemaVersion: 1,
+            name: "",
+            relativePath: item.relativePath,
+            sizeBytes: item.sizeBytes,
+            hash: "",
+            createdAt: item.updatedAt,
+            updatedAt: item.updatedAt,
+        }));
+    }
+    const files = [];
+    let totalSizeBytes = 0;
+    let oldestDate = null;
+    let newestDate = null;
+    for (const item of items) {
+        if (!statusFilter.has(item.status))
+            continue;
+        if (kindFilter && !kindFilter.has(item.kind))
+            continue;
+        const itemMs = Date.parse(item.updatedAt);
+        if (!Number.isFinite(itemMs) || itemMs > cutoffMs)
+            continue;
+        if (options.maxSizeBytes != null && totalSizeBytes + item.sizeBytes > options.maxSizeBytes)
+            break;
+        files.push({
+            relativePath: item.relativePath,
+            sizeBytes: item.sizeBytes,
+            hash: item.hash,
+        });
+        totalSizeBytes += item.sizeBytes;
+        const dateBucket = item.dateBucket;
+        if (dateBucket && (oldestDate === null || dateBucket < oldestDate))
+            oldestDate = dateBucket;
+        if (dateBucket && (newestDate === null || dateBucket > newestDate))
+            newestDate = dateBucket;
+    }
+    return {
+        pipelineId: definition.id,
+        files,
+        totalSizeBytes,
+        oldestDate,
+        newestDate,
+    };
+};
+exports.planCleanup = planCleanup;
+/**
+ * 执行清理：删除文件 + 清理空目录 + 清理临时文件 + 重建索引。
+ */
+const executeCleanup = async (definition, plan) => {
+    const warnings = [];
+    let deleted = 0;
+    let failed = 0;
+    for (const file of plan.files) {
+        const rootAbs = (0, node_path_1.resolve)(definition.artifactDir);
+        const absPath = (0, node_path_1.resolve)(rootAbs, file.relativePath);
+        // 路径穿越保护：目标必须位于当前 pipeline 的 artifactDir 内
+        if (absPath !== rootAbs && !absPath.startsWith(`${rootAbs}${node_path_1.sep}`)) {
+            failed += 1;
+            warnings.push(`拒绝删除越界文件 (${definition.id}:${file.relativePath})`);
+            continue;
+        }
+        try {
+            await (0, promises_1.rm)(absPath);
+            deleted += 1;
+        }
+        catch (error) {
+            failed += 1;
+            warnings.push(`删除失败 (${definition.id}:${file.relativePath}): ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    // 清理空目录
+    await (0, exports.cleanupEmptyDirs)(definition.artifactDir);
+    // 清理临时文件
+    const tmpResult = await (0, exports.cleanupTempFiles)(definition.artifactDir);
+    warnings.push(...tmpResult.warnings);
+    // 重建索引以移除已删文件
+    try {
+        const { rebuildArtifactIndex } = await import("./artifact-index.js");
+        await rebuildArtifactIndex(definition, (d) => (0, storage_service_1.scanStoredArtifacts)([d]));
+    }
+    catch {
+        warnings.push(`删除后自动重建索引失败 (${definition.id})，请手动执行 rebuild-index`);
+    }
+    return { deleted, failed, warnings };
+};
+exports.executeCleanup = executeCleanup;
+/**
+ * 递归清理空目录。保留 artifactDir 根目录本身。
+ */
+const cleanupEmptyDirs = async (artifactDir) => {
+    const warnings = [];
+    let removed = 0;
+    const walkAndRemove = async (dirPath) => {
+        try {
+            const entries = await (0, promises_1.readdir)(dirPath, { withFileTypes: true });
+            for (const entry of entries) {
+                if (entry.isDirectory()) {
+                    await walkAndRemove(`${dirPath}${node_path_1.sep}${entry.name}`);
+                }
+            }
+            // 不删除 artifacts 根目录本身
+            const isRoot = dirPath === artifactDir || dirPath.endsWith(`${node_path_1.sep}artifacts`) && dirPath.replace(/\\/g, "/").endsWith("/artifacts");
+            if (isRoot)
+                return;
+            const after = await (0, promises_1.readdir)(dirPath);
+            if (after.length === 0) {
+                await (0, promises_1.rmdir)(dirPath);
+                removed += 1;
+            }
+        }
+        catch {
+            // 目录不存在或无权访问
+        }
+    };
+    await walkAndRemove(artifactDir);
+    return { removed, warnings };
+};
+exports.cleanupEmptyDirs = cleanupEmptyDirs;
+/**
+ * 清理 persistArtifactFile 遗留的 .tmp-*.json 临时文件（原子写入失败残留）。
+ */
+const cleanupTempFiles = async (artifactDir) => {
+    const warnings = [];
+    let cleaned = 0;
+    const walkAndClean = async (dirPath) => {
+        try {
+            const entries = await (0, promises_1.readdir)(dirPath, { withFileTypes: true });
+            for (const entry of entries) {
+                const subPath = `${dirPath}${node_path_1.sep}${entry.name}`;
+                if (entry.isDirectory()) {
+                    await walkAndClean(subPath);
+                }
+                else if (entry.isFile() && entry.name.startsWith(".tmp-") && entry.name.endsWith(".json")) {
+                    try {
+                        await (0, promises_1.rm)(subPath);
+                        cleaned += 1;
+                    }
+                    catch (error) {
+                        warnings.push(`清理临时文件失败: ${error instanceof Error ? error.message : String(error)}`);
+                    }
+                }
+            }
+        }
+        catch {
+            // 目录不存在
+        }
+    };
+    await walkAndClean(artifactDir);
+    return { cleaned, warnings };
+};
+exports.cleanupTempFiles = cleanupTempFiles;