taskmeld 0.1.1

package/dist/src/services/pipeline-service.js

@@ -0,0 +1,529 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPipelineService = exports.matchPipelineIdentityTarget = exports.readPipelineIdentitySnapshot = exports.readNestedValueByPath = exports.extractKeywordPoolFromUnknown = exports.normalizePipelineRunIdentityTarget = void 0;
+const pipeline_config_1 = require("../app/pipeline-config");
+const execution_status_1 = require("../pipeline/execution-status");
+const item_batch_controller_1 = require("../pipeline/item-batch-controller");
+const pipeline_status_1 = require("./pipeline-status");
+const getRuntimeByPipelineId = (app, pipelineId) => app.getPipelineRuntime(pipelineId);
+const normalizeIdentityValue = (value) => typeof value === "string" && value.trim() ? value.trim() : null;
+const normalizePipelineRunIdentityTarget = (target) => ({
+    runId: normalizeIdentityValue(target?.runId),
+    batchRunId: normalizeIdentityValue(target?.batchRunId),
+});
+exports.normalizePipelineRunIdentityTarget = normalizePipelineRunIdentityTarget;
+const extractKeywordPoolFromUnknown = (value, depth = 0) => {
+    if (depth > 5)
+        return [];
+    const normalizedDirect = (0, item_batch_controller_1.normalizePoolItems)(value);
+    if (normalizedDirect.length > 0)
+        return normalizedDirect;
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return [];
+    const record = value;
+    // 远端关键词池优先按约定字段提取，兼容现有 list30/list/items 等结构。
+    const priorityKeys = ["list30", "list", "keywords", "items", "pool"];
+    for (const key of priorityKeys) {
+        const candidates = (0, exports.extractKeywordPoolFromUnknown)(record[key], depth + 1);
+        if (candidates.length > 0)
+            return candidates;
+    }
+    const mapValue = record.map;
+    if (mapValue && typeof mapValue === "object" && !Array.isArray(mapValue)) {
+        const mapCandidates = (0, item_batch_controller_1.normalizePoolItems)(Object.values(mapValue));
+        if (mapCandidates.length > 0)
+            return mapCandidates;
+    }
+    for (const nested of Object.values(record)) {
+        const candidates = (0, exports.extractKeywordPoolFromUnknown)(nested, depth + 1);
+        if (candidates.length > 0)
+            return candidates;
+    }
+    return [];
+};
+exports.extractKeywordPoolFromUnknown = extractKeywordPoolFromUnknown;
+const readNestedValueByPath = (value, sourceField) => {
+    const normalizedPath = sourceField.trim();
+    if (!normalizedPath)
+        return null;
+    const segments = normalizedPath
+        .split(".")
+        .map((segment) => segment.trim())
+        .filter(Boolean);
+    if (segments.length === 0)
+        return null;
+    let current = value;
+    for (const segment of segments) {
+        if (!current || typeof current !== "object" || Array.isArray(current))
+            return null;
+        current = current[segment];
+    }
+    return current;
+};
+exports.readNestedValueByPath = readNestedValueByPath;
+const normalizeBatchSize = (value) => {
+    if (typeof value !== "number" || !Number.isFinite(value))
+        return undefined;
+    return Math.max(1, Math.trunc(value));
+};
+const normalizeStartIndex = (startIndex, startBatch, batchSize) => {
+    if (typeof startIndex === "number" && Number.isFinite(startIndex)) {
+        return Math.max(0, Math.trunc(startIndex));
+    }
+    if (typeof startBatch === "number" && Number.isFinite(startBatch) && typeof batchSize === "number") {
+        return Math.max(0, (Math.trunc(startBatch) - 1) * batchSize);
+    }
+    return undefined;
+};
+const buildBatchRunId = (pipelineId, snapshot) => {
+    if (typeof snapshot.batchRunId === "string" && snapshot.batchRunId.trim()) {
+        return snapshot.batchRunId.trim();
+    }
+    const startedAt = typeof snapshot.startedAt === "string" && snapshot.startedAt.trim() ? snapshot.startedAt.trim() : String(Date.now());
+    return `batch:${pipelineId}:${startedAt}`;
+};
+const markRunningRunStopped = (run) => {
+    const now = new Date().toISOString();
+    // 停止是用户主动中止，不应继续让 queued/blocked 节点保持可调度状态。
+    for (const node of run.nodes) {
+        if (node.status === "success" || node.status === "failed" || node.status === "rejected" || node.status === "skipped")
+            continue;
+        node.status = "stopped";
+        node.finishedAt = node.finishedAt ?? now;
+        node.lastError = node.lastError ?? "用户手动停止流水线";
+    }
+    for (const item of run.itemRuns ?? []) {
+        if (item.status === "success" || item.status === "failed" || item.status === "rejected" || item.status === "skipped")
+            continue;
+        item.status = "stopped";
+        item.finishedAt = item.finishedAt ?? now;
+        item.lastError = item.lastError ?? "用户手动停止流水线";
+    }
+    for (const group of run.groups ?? []) {
+        if (group.status === "success" || group.status === "failed" || group.status === "rejected" || group.status === "skipped")
+            continue;
+        group.status = "stopped";
+        group.finishedAt = group.finishedAt ?? now;
+        group.lastError = group.lastError ?? "用户手动停止流水线";
+    }
+    for (const groupItem of run.groupItemRuns ?? []) {
+        if (groupItem.status === "success" || groupItem.status === "failed" || groupItem.status === "rejected" || groupItem.status === "skipped")
+            continue;
+        groupItem.status = "stopped";
+        groupItem.finishedAt = groupItem.finishedAt ?? now;
+        groupItem.lastError = groupItem.lastError ?? "用户手动停止流水线";
+    }
+    run.status = "stopped";
+    run.updatedAt = now;
+};
+const readPipelineIdentitySnapshot = (pipelineId, run, batchRun) => {
+    if (typeof batchRun?.batchRunId === "string" && batchRun.batchRunId.trim()) {
+        return {
+            pipelineId,
+            runId: normalizeIdentityValue(run?.id),
+            batchRunId: batchRun.batchRunId.trim(),
+        };
+    }
+    const startedAt = normalizeIdentityValue(batchRun?.startedAt);
+    return {
+        pipelineId,
+        runId: normalizeIdentityValue(run?.id),
+        batchRunId: startedAt ? `batch:${pipelineId}:${startedAt}` : null,
+    };
+};
+exports.readPipelineIdentitySnapshot = readPipelineIdentitySnapshot;
+const matchPipelineIdentityTarget = (identity, target) => {
+    const normalizedTarget = (0, exports.normalizePipelineRunIdentityTarget)(target);
+    const metadata = {
+        ...identity,
+        requestedRunId: normalizedTarget.runId,
+        requestedBatchRunId: normalizedTarget.batchRunId,
+        matchedBy: null,
+    };
+    if (normalizedTarget.batchRunId) {
+        if (identity.batchRunId !== normalizedTarget.batchRunId) {
+            return { ok: false, metadata };
+        }
+        metadata.matchedBy = "batchRunId";
+    }
+    if (normalizedTarget.runId) {
+        if (identity.runId !== normalizedTarget.runId) {
+            return { ok: false, metadata };
+        }
+        metadata.matchedBy = metadata.matchedBy ?? "runId";
+    }
+    if (!normalizedTarget.batchRunId && !normalizedTarget.runId) {
+        metadata.matchedBy = "pipelineId";
+    }
+    return { ok: true, metadata };
+};
+exports.matchPipelineIdentityTarget = matchPipelineIdentityTarget;
+const attachIdentityToPipelineStatusResult = (result, metadata) => {
+    return {
+        ...result,
+        ...metadata,
+    };
+};
+const createPipelineService = (app) => {
+    const listPipelines = () => app.listPipelines().map((definition) => ({
+        id: definition.id,
+        title: definition.title,
+    }));
+    const getPipeline = (pipelineId) => {
+        const definition = app.getPipelineDefinition(pipelineId);
+        const runtime = app.getPipelineRuntime(pipelineId);
+        if (!definition || !runtime)
+            return null;
+        // 只读 service 直接透出运行态快照，不承担任何写入行为。
+        return {
+            pipelineId: definition.id,
+            title: definition.title,
+            run: runtime.runtime.getRun(),
+            scheduler: runtime.pipeline.getSchedulerState(),
+            batchRun: runtime.pipeline.getBatchRunState(),
+            templateNodes: runtime.workflow.getTemplateNodes(),
+            workflow: runtime.workflow.getWorkflow(),
+        };
+    };
+    const getTimeline = () => app.runtime.getCombinedTimeline();
+    const startPipeline = async (pipelineId) => {
+        const runtime = getRuntimeByPipelineId(app, pipelineId);
+        if (!runtime)
+            return { ok: false, pipelineId, error: "pipeline_not_found" };
+        const batchState = runtime.pipeline.getBatchRunState();
+        if (batchState.status === "running") {
+            return { ok: false, pipelineId, error: "batch_run_in_progress", state: batchState };
+        }
+        const workflow = runtime.workflow.getWorkflow();
+        const remoteBatchPlugin = workflow.plugins.remoteBatch;
+        if (remoteBatchPlugin.enabled) {
+            const remoteUrl = remoteBatchPlugin.url.trim() || pipeline_config_1.DEFAULT_REMOTE_BATCH_URL;
+            if (!remoteUrl) {
+                return { ok: false, pipelineId, error: "remote_pool_url_empty" };
+            }
+            let remotePayload = null;
+            try {
+                const response = await fetch(remoteUrl, { method: "GET" });
+                if (!response.ok) {
+                    return {
+                        ok: false,
+                        pipelineId,
+                        error: "remote_pool_fetch_failed",
+                        remoteUrl,
+                        status: response.status,
+                    };
+                }
+                const text = await response.text();
+                try {
+                    remotePayload = JSON.parse(text);
+                }
+                catch {
+                    // 非 JSON 返回也允许继续尝试解析，兼容逗号/换行文本池。
+                    remotePayload = text;
+                }
+            }
+            catch (error) {
+                return {
+                    ok: false,
+                    pipelineId,
+                    error: "remote_pool_fetch_error",
+                    remoteUrl,
+                    detail: error instanceof Error ? error.message : "unknown_error",
+                };
+            }
+            const preferredPayload = remoteBatchPlugin.sourceField
+                ? (0, exports.readNestedValueByPath)(remotePayload, remoteBatchPlugin.sourceField)
+                : null;
+            const items = (0, exports.extractKeywordPoolFromUnknown)(preferredPayload ?? remotePayload);
+            if (items.length === 0) {
+                return { ok: false, pipelineId, error: "remote_batch_items_empty", remoteUrl };
+            }
+            const batchSize = Math.max(1, remoteBatchPlugin.batchSize || 1);
+            const startIndex = Math.max(0, (Math.max(1, remoteBatchPlugin.startBatch || 1) - 1) * batchSize);
+            const started = runtime.pipeline.startBatchRun(items, batchSize, { startIndex });
+            if (!started.ok) {
+                const normalizedError = started.error === "batch_run_in_progress" ? "batch_run_in_progress" : "batch_items_empty";
+                return { ok: false, pipelineId, error: normalizedError, state: started.snapshot, remoteUrl };
+            }
+            runtime.runtime.pushTimeline(`[${pipelineId}] 远程关键词池批跑已启动: ${items.length} 个关键词, 每批 ${started.snapshot.batchSize} 个`, "info", { remoteUrl });
+            return {
+                ok: true,
+                mode: "remote_batch",
+                pipelineId,
+                accepted: true,
+                batchRunId: buildBatchRunId(pipelineId, started.snapshot),
+                runId: runtime.runtime.getRun()?.id ?? null,
+                remoteUrl,
+                totalFetched: items.length,
+                batchRun: started.snapshot,
+                templateNodes: runtime.workflow.getTemplateNodes(),
+                edges: runtime.workflow.getWorkflow().edges,
+                workflowNodes: runtime.workflow.getWorkflow().nodes,
+            };
+        }
+        const run = runtime.runtime.seedRun(runtime.workflow.getTemplateNodes());
+        runtime.runtime.setRun(run);
+        runtime.runtime.pushTimeline(`[${pipelineId}] 已启动新运行: ${run.id}`);
+        runtime.runtime.emitPipeline();
+        // start 只负责发起运行，不承诺在返回时已执行完成。
+        void runtime.pipeline.drainPipeline(`run:start:${run.id}`).then(() => {
+            runtime.runtime.touchRun(runtime.runtime.getRun());
+        });
+        return { ok: true, mode: "single", pipelineId, accepted: true, runId: run.id, run: runtime.runtime.getRun(), workflowNodes: runtime.workflow.getWorkflow().nodes };
+    };
+    const getPipelineExecutionStatus = (pipelineId, target) => {
+        const detail = getPipeline(pipelineId);
+        if (!detail) {
+            const missingIdentity = (0, exports.readPipelineIdentitySnapshot)(pipelineId, null, null);
+            return {
+                ...(0, exports.matchPipelineIdentityTarget)(missingIdentity, target).metadata,
+                ok: false,
+                error: "pipeline_not_found",
+            };
+        }
+        const identity = (0, exports.readPipelineIdentitySnapshot)(pipelineId, detail.run, detail.batchRun);
+        const matchedIdentity = (0, exports.matchPipelineIdentityTarget)(identity, target);
+        if (!matchedIdentity.ok) {
+            return {
+                ...matchedIdentity.metadata,
+                ok: false,
+                error: "run_not_found",
+            };
+        }
+        // status 命令只表达“当前是否仍在运行”，非运行态改为返回精简联合结构。
+        return attachIdentityToPipelineStatusResult((0, pipeline_status_1.buildPipelineStatusResult)({
+            pipelineId,
+            run: detail.run,
+            scheduler: detail.scheduler,
+            batchRun: detail.batchRun,
+        }), matchedIdentity.metadata);
+    };
+    const stopPipeline = (pipelineId, target) => {
+        const runtime = getRuntimeByPipelineId(app, pipelineId);
+        const missingIdentity = (0, exports.readPipelineIdentitySnapshot)(pipelineId, runtime?.runtime.getRun(), runtime?.pipeline.getBatchRunState());
+        if (!runtime) {
+            return {
+                ...(0, exports.matchPipelineIdentityTarget)(missingIdentity, target).metadata,
+                ok: false,
+                error: "pipeline_not_found",
+            };
+        }
+        const runState = runtime.runtime.getRun();
+        const batchRunState = runtime.pipeline.getBatchRunState();
+        const identity = (0, exports.readPipelineIdentitySnapshot)(pipelineId, runState, batchRunState);
+        const matchedIdentity = (0, exports.matchPipelineIdentityTarget)(identity, target);
+        if (!matchedIdentity.ok) {
+            return {
+                ...matchedIdentity.metadata,
+                ok: false,
+                error: "run_not_found",
+            };
+        }
+        if (batchRunState.status !== "running") {
+            const currentStatus = getPipelineExecutionStatus(pipelineId, target);
+            if (currentStatus.ok && "status" in currentStatus && currentStatus.status.runStatus === "running") {
+                if (runState.id) {
+                    runtime.pipeline.abortRunControllers(runState.id);
+                }
+                markRunningRunStopped(runState);
+                runtime.runtime.pushTimeline(`[${pipelineId}] 已请求停止单次运行: ${runState.id}`, "warn");
+                runtime.runtime.emitPipeline();
+                const stoppedStatus = (0, execution_status_1.buildPipelineExecutionStatus)({
+                    pipelineId,
+                    run: runState,
+                    scheduler: runtime.pipeline.getSchedulerState(),
+                    batchRun: runtime.pipeline.getBatchRunState(),
+                });
+                return {
+                    ...matchedIdentity.metadata,
+                    ok: true,
+                    mode: "single",
+                    status: stoppedStatus,
+                };
+            }
+            return {
+                ...matchedIdentity.metadata,
+                ok: false,
+                error: "batch_run_not_running",
+                status: currentStatus.ok && "status" in currentStatus ? currentStatus.status : undefined,
+            };
+        }
+        const stopped = runtime.pipeline.stopBatchRun();
+        if (!stopped.ok) {
+            return {
+                ...matchedIdentity.metadata,
+                ok: false,
+                error: "batch_run_not_running",
+            };
+        }
+        // 中止当前正在执行的节点，同时向远端 agent 发送 /stop 命令
+        if (runState.id) {
+            runtime.pipeline.abortRunControllers(runState.id);
+        }
+        const currentStatus = getPipelineExecutionStatus(pipelineId, target);
+        return {
+            ...matchedIdentity.metadata,
+            ok: true,
+            mode: "remote_batch",
+            stopped,
+            status: currentStatus.ok && "status" in currentStatus
+                ? currentStatus.status
+                : {
+                    pipelineId,
+                    mode: "remote_batch",
+                    running: true,
+                    runId: null,
+                    runStatus: "running",
+                    activeNodeIds: [],
+                    pendingNodeIds: [],
+                    scheduler: runtime.pipeline.getSchedulerState(),
+                    batchRun: runtime.pipeline.getBatchRunState(),
+                    currentBatch: null,
+                    lastError: null,
+                    updatedAt: new Date().toISOString(),
+                },
+        };
+    };
+    const runPipeline = async (pipelineId) => {
+        // run 仅作为兼容入口，语义等价到 start。
+        return startPipeline(pipelineId);
+    };
+    const startBatchRun = (input) => {
+        const runtime = getRuntimeByPipelineId(app, input.pipelineId);
+        if (!runtime)
+            return { ok: false, pipelineId: input.pipelineId, error: "pipeline_not_found" };
+        if (input.items.length === 0)
+            return { ok: false, pipelineId: input.pipelineId, error: "batch_items_empty" };
+        const batchSize = normalizeBatchSize(input.batchSize);
+        const startIndex = normalizeStartIndex(input.startIndex, input.startBatch, batchSize);
+        const started = runtime.pipeline.startBatchRun(input.items, batchSize, startIndex !== undefined ? { startIndex } : undefined);
+        if (!started.ok) {
+            return {
+                ok: false,
+                pipelineId: input.pipelineId,
+                error: started.error === "batch_run_in_progress" ? "batch_run_in_progress" : "batch_items_empty",
+                state: started.snapshot,
+            };
+        }
+        return { ok: true, pipelineId: input.pipelineId, state: started.snapshot };
+    };
+    const startRemoteBatchRun = async (input) => {
+        const runtime = getRuntimeByPipelineId(app, input.pipelineId);
+        if (!runtime)
+            return { ok: false, pipelineId: input.pipelineId, error: "pipeline_not_found" };
+        const remoteBatchPlugin = runtime.workflow.getWorkflow().plugins.remoteBatch;
+        if (!remoteBatchPlugin.enabled) {
+            return { ok: false, pipelineId: input.pipelineId, error: "pipeline_plugin_disabled", plugin: "remoteBatch" };
+        }
+        const remoteUrl = typeof input.url === "string" && input.url.trim()
+            ? input.url.trim()
+            : remoteBatchPlugin.url.trim() || pipeline_config_1.DEFAULT_REMOTE_BATCH_URL;
+        if (!remoteUrl) {
+            return { ok: false, pipelineId: input.pipelineId, error: "remote_pool_url_empty" };
+        }
+        let remotePayload = null;
+        try {
+            const response = await fetch(remoteUrl, { method: "GET" });
+            if (!response.ok) {
+                return { ok: false, pipelineId: input.pipelineId, error: "remote_pool_fetch_failed", remoteUrl, status: response.status };
+            }
+            const text = await response.text();
+            try {
+                remotePayload = JSON.parse(text);
+            }
+            catch {
+                // 非 JSON 文本也允许继续解析，避免上游切到纯文本池时整条批跑入口不可用。
+                remotePayload = text;
+            }
+        }
+        catch (error) {
+            return {
+                ok: false,
+                pipelineId: input.pipelineId,
+                error: "remote_pool_fetch_error",
+                remoteUrl,
+                detail: error instanceof Error ? error.message : "unknown_error",
+            };
+        }
+        // sourceField 视为“优先路径”而非严格依赖：路径缺失时退回全量解析以保持兼容。
+        const preferredPayload = remoteBatchPlugin.sourceField
+            ? (0, exports.readNestedValueByPath)(remotePayload, remoteBatchPlugin.sourceField)
+            : null;
+        const items = (0, exports.extractKeywordPoolFromUnknown)(preferredPayload ?? remotePayload);
+        if (items.length === 0) {
+            return { ok: false, pipelineId: input.pipelineId, error: "remote_batch_items_empty", remoteUrl };
+        }
+        const batchSize = normalizeBatchSize(input.batchSize) ?? remoteBatchPlugin.batchSize ?? 5;
+        const startIndex = normalizeStartIndex(input.startIndex, input.startBatch, batchSize);
+        const started = runtime.pipeline.startBatchRun(items, batchSize, startIndex !== undefined ? { startIndex } : undefined);
+        if (!started.ok) {
+            return {
+                ok: false,
+                pipelineId: input.pipelineId,
+                error: started.error === "batch_run_in_progress" ? "batch_run_in_progress" : "batch_items_empty",
+                state: started.snapshot,
+                remoteUrl,
+            };
+        }
+        runtime.runtime.pushTimeline(`[${input.pipelineId}] 远程关键词池批跑已启动: ${items.length} 个关键词, 每批 ${started.snapshot.batchSize} 个`, "info", { remoteUrl });
+        return {
+            ok: true,
+            pipelineId: input.pipelineId,
+            state: started.snapshot,
+            remoteUrl,
+            totalFetched: items.length,
+        };
+    };
+    const retryNode = async (input) => {
+        const runtime = getRuntimeByPipelineId(app, input.pipelineId);
+        if (!runtime)
+            return { ok: false, pipelineId: input.pipelineId, error: "pipeline_not_found" };
+        // 中止当前正在执行的节点，避免旧节点与新重试冲突（同时向远端 agent 发送 /stop 命令）
+        const runState = runtime.runtime.getRun();
+        if (runState.id) {
+            runtime.pipeline.abortRunControllers(runState.id);
+        }
+        const retry = await runtime.pipeline.retryNodeExecution(input.nodeId, input.itemKey);
+        const run = runtime.runtime.getRun();
+        runtime.runtime.touchRun(run);
+        return { ok: true, pipelineId: input.pipelineId, run, retry };
+    };
+    const listOutputs = async (pipelineId) => {
+        const runtime = app.getPipelineRuntime(pipelineId);
+        if (!runtime)
+            return [];
+        return runtime.output.list();
+    };
+    const getOutput = async (pipelineId, runId) => {
+        const runtime = app.getPipelineRuntime(pipelineId);
+        if (!runtime)
+            return null;
+        if (runId)
+            return runtime.output.getByRunId(runId);
+        const outputs = await runtime.output.list();
+        return outputs.length > 0 ? outputs[outputs.length - 1] : null;
+    };
+    const listLinks = async () => app.dispatch.listLinks();
+    const getQueue = (pipelineId) => app.dispatch.getQueue(pipelineId);
+    const cancelJob = async (pipelineId, jobId, reason) => app.dispatch.cancelJob(jobId, reason ?? "canceled_by_user");
+    const retryJob = async (pipelineId, jobId) => app.dispatch.retryJob(jobId);
+    return {
+        listPipelines,
+        getPipeline,
+        getTimeline,
+        startPipeline,
+        getPipelineExecutionStatus,
+        stopPipeline,
+        runPipeline,
+        startBatchRun,
+        startRemoteBatchRun,
+        retryNode,
+        listOutputs,
+        getOutput,
+        listLinks,
+        getQueue,
+        cancelJob,
+        retryJob,
+    };
+};
+exports.createPipelineService = createPipelineService;

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

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildPipelineStatusResult = exports.readPipelineLastCompletedAt = void 0;
+const execution_status_1 = require("../pipeline/execution-status");
+const isNonEmptyString = (value) => {
+    return typeof value === "string" && value.trim().length > 0;
+};
+const parseTimestamp = (value) => {
+    if (!isNonEmptyString(value))
+        return null;
+    const parsed = Date.parse(value.trim());
+    return Number.isFinite(parsed) ? parsed : null;
+};
+const pickLatestTimestamp = (candidates) => {
+    let best = null;
+    for (const candidate of candidates) {
+        if (!isNonEmptyString(candidate))
+            continue;
+        const normalized = candidate.trim();
+        const ms = parseTimestamp(normalized);
+        if (ms === null)
+            continue;
+        if (!best || ms > best.ms) {
+            best = { iso: normalized, ms };
+        }
+    }
+    return best?.iso ?? null;
+};
+const collectFinishedAtValues = (items) => {
+    if (!Array.isArray(items))
+        return [];
+    return items
+        .map((item) => item.finishedAt)
+        .filter((value) => isNonEmptyString(value))
+        .map((value) => value.trim());
+};
+const isRunTerminal = (run) => {
+    return run.status === "success" || run.status === "failed" || run.status === "stopped";
+};
+const isBatchTerminal = (batchRun) => {
+    if (!batchRun || typeof batchRun !== "object")
+        return false;
+    const status = batchRun.status;
+    return status === "completed" || status === "failed" || status === "stopped";
+};
+const readPipelineLastCompletedAt = (run, batchRun) => {
+    const candidates = [];
+    // 只有确认 run 已进入终态后，才允许把 updatedAt 视作完成时间候选。
+    if (isRunTerminal(run) && isNonEmptyString(run.updatedAt)) {
+        candidates.push(run.updatedAt.trim());
+    }
+    candidates.push(...collectFinishedAtValues(run.nodes));
+    candidates.push(...collectFinishedAtValues(run.itemRuns));
+    candidates.push(...collectFinishedAtValues(run.groups));
+    candidates.push(...collectFinishedAtValues(run.groupItemRuns));
+    // 批跑完成时间应来自控制器真实终态，而不是运行中的快照更新时间。
+    if (isBatchTerminal(batchRun) && isNonEmptyString(batchRun.finishedAt)) {
+        candidates.push(batchRun.finishedAt.trim());
+    }
+    return pickLatestTimestamp(candidates);
+};
+exports.readPipelineLastCompletedAt = readPipelineLastCompletedAt;
+const buildPipelineStatusResult = (input) => {
+    const status = (0, execution_status_1.buildPipelineExecutionStatus)({
+        pipelineId: input.pipelineId,
+        // 这里直接复用 execution-status 作为运行态快照构造器，保证 status 字段来源仍然唯一。
+        run: input.run,
+        scheduler: input.scheduler,
+        batchRun: input.batchRun,
+    });
+    if (status.running) {
+        // status.running=true 时，mode 只能是 single 或 remote_batch；这里显式收窄给 CLI/API 统一消费。
+        return {
+            ok: true,
+            status: {
+                ...status,
+                mode: status.mode === "remote_batch" ? "remote_batch" : "single",
+                running: true,
+            },
+        };
+    }
+    const batchRunRecord = input.batchRun && typeof input.batchRun === "object" ? input.batchRun : null;
+    return {
+        ok: true,
+        pipelineId: input.pipelineId,
+        running: false,
+        message: "no active pipeline run",
+        lastCompletedAt: (0, exports.readPipelineLastCompletedAt)(input.run, input.batchRun),
+        lastRunId: isNonEmptyString(input.run.id) ? input.run.id.trim() : null,
+        lastBatchRunId: isNonEmptyString(batchRunRecord?.batchRunId) ? String(batchRunRecord.batchRunId).trim() : null,
+    };
+};
+exports.buildPipelineStatusResult = buildPipelineStatusResult;

package/dist/src/services/read-services.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAppServices = exports.createReadonlyServices = void 0;
+const agent_service_1 = require("./agent-service");
+const artifact_service_1 = require("./artifact-service");
+const pipeline_service_1 = require("./pipeline-service");
+const scheduler_service_1 = require("./scheduler-service");
+const session_service_1 = require("./session-service");
+const system_service_1 = require("./system-service");
+const createAllServices = (app) => ({
+    system: (0, system_service_1.createSystemService)(app),
+    pipeline: (0, pipeline_service_1.createPipelineService)(app),
+    agent: (0, agent_service_1.createAgentService)(app),
+    session: (0, session_service_1.createSessionService)(app),
+    artifact: (0, artifact_service_1.createArtifactService)(app),
+    scheduler: (0, scheduler_service_1.createSchedulerService)(app),
+});
+const createReadonlyServices = (app) => {
+    const services = createAllServices(app);
+    return {
+        // 统一工厂用于主线集成，CLI 入口只需传入 registry 即可拿到全部只读 service。
+        system: services.system,
+        pipeline: services.pipeline,
+        agent: services.agent,
+        session: services.session,
+        artifact: services.artifact,
+    };
+};
+exports.createReadonlyServices = createReadonlyServices;
+const createAppServices = (app) => {
+    const services = createAllServices(app);
+    return {
+        readonly: {
+            system: services.system,
+            pipeline: services.pipeline,
+            agent: services.agent,
+            session: services.session,
+            artifact: services.artifact,
+        },
+        writable: {
+            pipeline: {
+                startPipeline: services.pipeline.startPipeline,
+                getPipelineExecutionStatus: services.pipeline.getPipelineExecutionStatus,
+                stopPipeline: services.pipeline.stopPipeline,
+                runPipeline: services.pipeline.runPipeline,
+                retryNode: services.pipeline.retryNode,
+                getOutput: services.pipeline.getOutput,
+                listOutputs: services.pipeline.listOutputs,
+                listLinks: services.pipeline.listLinks,
+                getQueue: services.pipeline.getQueue,
+            },
+            session: {
+                sendMessage: services.session.sendMessage,
+                sendMessageAndWaitForReply: services.session.sendMessageAndWaitForReply,
+            },
+            scheduler: services.scheduler,
+        },
+    };
+};
+exports.createAppServices = createAppServices;