taskmeld 0.1.1

package/dist/src/artifacts/storage-service.js

@@ -0,0 +1,371 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.exportStoredArtifactContents = exports.readStoredArtifactContent = exports.listStoredArtifacts = exports.scanStoredArtifacts = void 0;
+const promises_1 = require("node:fs/promises");
+const node_path_1 = require("node:path");
+const artifact_index_1 = require("./artifact-index");
+const DATE_BUCKET_RE = /^\d{4}-\d{2}-\d{2}$/;
+const NUMERIC_TOKEN_RE = /^\d+$/;
+const toUnixPath = (value) => value.replaceAll("\\", "/");
+const formatDateBucketFromIso = (iso) => {
+    const ms = Date.parse(iso);
+    if (!Number.isFinite(ms))
+        return "unknown";
+    const d = new Date(ms);
+    const yyyy = d.getFullYear();
+    const mm = String(d.getMonth() + 1).padStart(2, "0");
+    const dd = String(d.getDate()).padStart(2, "0");
+    return `${yyyy}-${mm}-${dd}`;
+};
+const normalizeDateBucketParam = (value) => {
+    if (!value)
+        return null;
+    const normalized = value.trim();
+    return DATE_BUCKET_RE.test(normalized) ? normalized : null;
+};
+const toRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value) ? value : null;
+const parseNodeIdFromFileName = (fileName, runId, relativePath) => {
+    if (!runId?.trim())
+        return null;
+    const normalizedName = fileName.trim();
+    if (!normalizedName.toLowerCase().endsWith(".json"))
+        return null;
+    const nameWithoutExt = normalizedName.slice(0, -".json".length);
+    const runPrefix = `${runId}-`;
+    if (!nameWithoutExt.startsWith(runPrefix))
+        return null;
+    const tail = nameWithoutExt.slice(runPrefix.length);
+    if (!tail)
+        return null;
+    const normalizedPath = toUnixPath(relativePath).toLowerCase();
+    if (normalizedPath.includes("/envelopes/")) {
+        // envelope 文件名格式: <runId>-<nodeId>-node-<nodeId>-<uuid>-envelope.json
+        const marker = "-node-";
+        const markerIndex = tail.indexOf(marker);
+        if (markerIndex > 0) {
+            const nodeId = tail.slice(0, markerIndex).trim();
+            return nodeId || null;
+        }
+        return null;
+    }
+    // group/adpater 聚合文件格式不稳定（含 itemKey），这里不参与节点筛选，避免误判。
+    if (tail.endsWith("-adapter-output") || tail.endsWith("-group-output"))
+        return null;
+    const tokens = tail.split("-").filter(Boolean);
+    if (tokens.length < 3)
+        return null;
+    // 结构化节点产物命名格式: <runId>-<nodeId>-<artifactIndex>-<safeType>.json
+    let artifactIndexPos = -1;
+    for (let i = tokens.length - 1; i >= 0; i -= 1) {
+        if (NUMERIC_TOKEN_RE.test(tokens[i])) {
+            artifactIndexPos = i;
+            break;
+        }
+    }
+    if (artifactIndexPos <= 0 || artifactIndexPos >= tokens.length - 1)
+        return null;
+    const nodeId = tokens.slice(0, artifactIndexPos).join("-").trim();
+    return nodeId || null;
+};
+const walkFiles = async (rootDir) => {
+    const out = [];
+    const queue = [rootDir];
+    while (queue.length > 0) {
+        const current = queue.shift();
+        if (!current)
+            continue;
+        let entries;
+        try {
+            entries = await (0, promises_1.readdir)(current, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            const nextPath = `${current}${node_path_1.sep}${entry.name}`;
+            if (entry.isDirectory()) {
+                queue.push(nextPath);
+                continue;
+            }
+            if (entry.isFile())
+                out.push(nextPath);
+        }
+    }
+    return out;
+};
+const parseArtifactPathMeta = (artifactRootAbs, filePathAbs, updatedAtIso) => {
+    const rawRelative = toUnixPath(filePathAbs.slice(artifactRootAbs.length).replace(/^[/\\]+/, ""));
+    const segments = rawRelative.split("/").filter(Boolean);
+    const statusRaw = segments[0] ?? "unknown";
+    const status = statusRaw === "success" || statusRaw === "failed" || statusRaw === "rejected" ? statusRaw : "unknown";
+    const dateRaw = segments[1] ?? "";
+    const dateBucket = DATE_BUCKET_RE.test(dateRaw) ? dateRaw : formatDateBucketFromIso(updatedAtIso);
+    let runId = null;
+    if (segments[2]?.startsWith("batch-")) {
+        // 批跑产物路径: status/date/batchRunId/runId/...
+        runId = segments[3]?.startsWith("run-") ? segments[3] : null;
+    }
+    else {
+        runId = segments[2]?.startsWith("run-") ? segments[2] : null;
+    }
+    return { status, dateBucket, runId, relativePath: rawRelative };
+};
+const shouldIncludeArtifactFile = (relativePath) => {
+    const normalized = toUnixPath(relativePath).toLowerCase();
+    if (!normalized.endsWith(".json"))
+        return false;
+    return true;
+};
+/** 文件系统扫描（降级路径 / 索引重建用）。 */
+const scanStoredArtifacts = async (definitions, options) => {
+    const pipelineIdFilter = options?.pipelineIds?.length ? new Set(options.pipelineIds) : null;
+    const nodeIdFilter = options?.nodeIds?.length ? new Set(options.nodeIds) : null;
+    const statusFilter = options?.statuses?.length ? new Set(options.statuses) : null;
+    const kindFilter = options?.kinds?.length ? new Set(options.kinds) : null;
+    const batchRunIdFilter = options?.batchRunId ?? null;
+    const runIdFilter = options?.runId ?? null;
+    const dateFrom = normalizeDateBucketParam(options?.dateFrom ?? null);
+    const dateTo = normalizeDateBucketParam(options?.dateTo ?? null);
+    const out = [];
+    for (const definition of definitions) {
+        if (pipelineIdFilter && !pipelineIdFilter.has(definition.id))
+            continue;
+        const artifactRootAbs = (0, node_path_1.resolve)(definition.artifactDir);
+        const files = await walkFiles(artifactRootAbs);
+        for (const filePath of files) {
+            const fileStat = await (0, promises_1.stat)(filePath).catch(() => null);
+            if (!fileStat || !fileStat.isFile())
+                continue;
+            const updatedAt = fileStat.mtime.toISOString();
+            const meta = parseArtifactPathMeta(artifactRootAbs, (0, node_path_1.resolve)(filePath), updatedAt);
+            if (!shouldIncludeArtifactFile(meta.relativePath))
+                continue;
+            const fileName = (0, node_path_1.basename)(filePath);
+            const effectiveRunId = meta.runId ?? (meta.status === "rejected"
+                ? (() => { const m = fileName.match(/^(run-.+?)(?:-n\d|-rejected-by)/); return m ? m[1] : null; })()
+                : null);
+            if (!effectiveRunId && meta.status !== "rejected")
+                continue;
+            if (statusFilter && !statusFilter.has(meta.status))
+                continue;
+            if (runIdFilter && effectiveRunId !== runIdFilter)
+                continue;
+            // batchRunId 扫描过滤：路径含 batch-xxx 段
+            if (batchRunIdFilter && !meta.relativePath.includes(`/${batchRunIdFilter}/`))
+                continue;
+            const nodeId = parseNodeIdFromFileName(fileName, effectiveRunId, meta.relativePath);
+            // kind 扫描过滤：通过文件名后缀和路径判断
+            if (kindFilter) {
+                const scanKind = meta.relativePath.includes("/envelopes/") ? "envelope"
+                    : fileName.includes("-adapter-output") ? "adapter"
+                        : fileName.includes("-group-output") ? "group"
+                            : "artifact";
+                if (!kindFilter.has(scanKind))
+                    continue;
+            }
+            if (nodeIdFilter && (!nodeId || !nodeIdFilter.has(nodeId)))
+                continue;
+            if (dateFrom !== null || dateTo !== null) {
+                const rowDateBucket = DATE_BUCKET_RE.test(meta.dateBucket) ? meta.dateBucket : formatDateBucketFromIso(updatedAt);
+                if (dateFrom !== null && rowDateBucket < dateFrom)
+                    continue;
+                if (dateTo !== null && rowDateBucket > dateTo)
+                    continue;
+            }
+            out.push({
+                pipelineId: definition.id,
+                pipelineTitle: definition.title,
+                status: meta.status,
+                dateBucket: meta.dateBucket,
+                runId: effectiveRunId,
+                nodeId,
+                relativePath: meta.relativePath,
+                fileName,
+                sizeBytes: fileStat.size,
+                updatedAt,
+            });
+        }
+    }
+    return out.sort((a, b) => Date.parse(b.updatedAt) - Date.parse(a.updatedAt));
+};
+exports.scanStoredArtifacts = scanStoredArtifacts;
+const encodeListCursor = (updatedAt, runId, fileName) => Buffer.from(`${updatedAt}|${runId ?? "unknown"}|${fileName}`).toString("base64url");
+const decodeListCursor = (cursor) => {
+    try {
+        const raw = Buffer.from(cursor, "base64url").toString("utf8");
+        const idx1 = raw.indexOf("|");
+        const idx2 = raw.lastIndexOf("|");
+        if (idx1 < 0 || idx2 <= idx1)
+            return null;
+        return { updatedAt: raw.slice(0, idx1), runId: raw.slice(idx1 + 1, idx2), fileName: raw.slice(idx2 + 1) };
+    }
+    catch {
+        return null;
+    }
+};
+/** 优先读索引，索引缺失时降级为文件系统扫描。支持 cursor 分页。 */
+const listStoredArtifacts = async (definitions, options) => {
+    const pipelineIdFilter = options?.pipelineIds?.length ? new Set(options.pipelineIds) : null;
+    const limit = Number.isFinite(options?.limit) ? Math.max(1, Math.min(5000, Math.trunc(options?.limit))) : 100;
+    // 尝试从索引读取（不传 cursor，由外层统一分页）
+    const indexItems = [];
+    let indexAvailable = false;
+    for (const definition of definitions) {
+        if (pipelineIdFilter && !pipelineIdFilter.has(definition.id))
+            continue;
+        const filter = {
+            pipelineId: definition.id,
+            statuses: options?.statuses,
+            kinds: options?.kinds,
+            nodeIds: options?.nodeIds,
+            dateFrom: options?.dateFrom,
+            dateTo: options?.dateTo,
+            batchRunId: options?.batchRunId,
+            runId: options?.runId,
+            limit: 0, // 0 = 无限制，全量读出后统一排序分页
+        };
+        const result = await (0, artifact_index_1.listIndexRecords)(definition.artifactDir, filter);
+        if (result.total > 0 || result.items.length > 0) {
+            indexAvailable = true;
+            for (const record of result.items) {
+                indexItems.push((0, artifact_index_1.toStoredArtifactItem)(record, definition.id, definition.title));
+            }
+        }
+    }
+    // 统一的排序与 cursor 分页（index 和 scan 使用相同编码）
+    const sortItems = (items) => items.sort((a, b) => Date.parse(b.updatedAt) - Date.parse(a.updatedAt));
+    const paginateWithCursor = (items, source) => {
+        let startIndex = 0;
+        if (options?.cursor) {
+            const decoded = decodeListCursor(options.cursor);
+            if (decoded) {
+                const pos = items.findIndex((item) => item.updatedAt === decoded.updatedAt &&
+                    (item.runId ?? "unknown") === decoded.runId &&
+                    item.fileName === decoded.fileName);
+                if (pos >= 0)
+                    startIndex = pos + 1;
+            }
+        }
+        const page = items.slice(startIndex, startIndex + limit);
+        const nextCursor = page.length === limit && startIndex + limit < items.length
+            ? encodeListCursor(page[page.length - 1].updatedAt, page[page.length - 1].runId, page[page.length - 1].fileName)
+            : null;
+        return { items: page, nextCursor, source };
+    };
+    if (indexAvailable) {
+        return paginateWithCursor(sortItems(indexItems), "index");
+    }
+    // 降级：文件系统扫描
+    const scanItems = await (0, exports.scanStoredArtifacts)(definitions, {
+        pipelineIds: options?.pipelineIds,
+        nodeIds: options?.nodeIds,
+        dateFrom: options?.dateFrom,
+        dateTo: options?.dateTo,
+        statuses: options?.statuses,
+        kinds: options?.kinds,
+        batchRunId: options?.batchRunId,
+        runId: options?.runId,
+    });
+    return paginateWithCursor(sortItems(scanItems), "scan");
+};
+exports.listStoredArtifacts = listStoredArtifacts;
+const resolveArtifactFilePath = (definition, relativePath) => {
+    const rootAbs = (0, node_path_1.resolve)(definition.artifactDir);
+    const targetAbs = (0, node_path_1.resolve)(rootAbs, relativePath);
+    // 防止路径穿越，只允许读取当前流水线产物目录下文件。
+    if (targetAbs !== rootAbs && !targetAbs.startsWith(`${rootAbs}${node_path_1.sep}`))
+        return null;
+    return targetAbs;
+};
+const readStoredArtifactContent = async (definition, relativePath) => {
+    const targetAbs = resolveArtifactFilePath(definition, relativePath);
+    if (!targetAbs)
+        return null;
+    const fileStat = await (0, promises_1.stat)(targetAbs).catch(() => null);
+    if (!fileStat || !fileStat.isFile())
+        return null;
+    const rawText = await (0, promises_1.readFile)(targetAbs, "utf8");
+    let parsed = null;
+    try {
+        parsed = JSON.parse(rawText);
+    }
+    catch {
+        parsed = null;
+    }
+    const parsedObj = toRecord(parsed);
+    // 优先按 kind 字段分发，无 kind 时回退到旧启发式判断（向后兼容）
+    const kind = typeof parsedObj?.kind === "string" ? parsedObj.kind : null;
+    const isEnvelope = kind === "envelope" || (!kind && parsedObj && "envelope" in parsedObj);
+    const envelopeObj = isEnvelope ? toRecord(parsedObj?.envelope) : null;
+    const artifactObj = !isEnvelope && parsedObj && "artifact" in parsedObj ? toRecord(parsedObj.artifact) : null;
+    const content = (() => {
+        if (artifactObj)
+            return artifactObj.content ?? parsed ?? rawText;
+        if (envelopeObj) {
+            const artifacts = Array.isArray(envelopeObj.artifacts) ? envelopeObj.artifacts : [];
+            const contents = artifacts
+                .map((item) => toRecord(item)?.content)
+                .filter((item) => item !== undefined);
+            const logs = Array.isArray(envelopeObj.logs) ? envelopeObj.logs : [];
+            // envelope 预览返回 contents + logs，便于排错。
+            return {
+                contents,
+                logs,
+            };
+        }
+        return parsed ?? rawText;
+    })();
+    const meta = artifactObj ? toRecord(artifactObj.meta) : null;
+    return {
+        rawText,
+        parsed,
+        content,
+        meta,
+    };
+};
+exports.readStoredArtifactContent = readStoredArtifactContent;
+const exportStoredArtifactContents = async (definitions, options) => {
+    // 优先从索引选候选文件，减少全量 scan；索引缺失时 listStoredArtifacts 自动降级 scan
+    const limit = Number.isFinite(options?.limit) ? Math.max(1, Math.trunc(options?.limit)) : 20000;
+    const listResult = await (0, exports.listStoredArtifacts)(definitions, {
+        pipelineIds: options?.pipelineIds,
+        nodeIds: options?.nodeIds,
+        dateFrom: options?.dateFrom,
+        dateTo: options?.dateTo,
+        statuses: options?.statuses,
+        kinds: options?.kinds,
+        batchRunId: options?.batchRunId,
+        runId: options?.runId,
+        limit,
+    });
+    const items = listResult.items;
+    const definitionById = new Map(definitions.map((definition) => [definition.id, definition]));
+    const out = {};
+    for (const item of items.slice(0, limit)) {
+        const definition = definitionById.get(item.pipelineId);
+        if (!definition)
+            continue;
+        const content = await (0, exports.readStoredArtifactContent)(definition, item.relativePath);
+        if (!content)
+            continue;
+        const dateKey = item.dateBucket || "unknown";
+        const pipelineKey = item.pipelineId || "unknown";
+        const nodeKey = item.nodeId?.trim() || "unknown";
+        if (!out[dateKey])
+            out[dateKey] = {};
+        if (!out[dateKey][pipelineKey])
+            out[dateKey][pipelineKey] = {};
+        if (!out[dateKey][pipelineKey][nodeKey])
+            out[dateKey][pipelineKey][nodeKey] = [];
+        // 导出只保留产物内容，不包含 runId、文件名等元信息。
+        // 若 content 本身是数组，则展开写入，避免导出结果出现“数组套数组”。
+        if (Array.isArray(content.content)) {
+            out[dateKey][pipelineKey][nodeKey].push(...content.content);
+        }
+        else {
+            out[dateKey][pipelineKey][nodeKey].push(content.content);
+        }
+    }
+    return out;
+};
+exports.exportStoredArtifactContents = exportStoredArtifactContents;

package/dist/src/cli/bootstrap.js

@@ -0,0 +1,226 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMainCliBootstrap = void 0;
+const create_app_context_1 = require("../app/create-app-context");
+const user_config_1 = require("../app/user-config");
+const server_runtime_client_1 = require("./server-runtime-client");
+const errors_1 = require("./errors");
+const normalizePipelineSelector = (selector) => {
+    if (typeof selector === "string") {
+        return { pipelineId: selector.trim() || undefined };
+    }
+    return {
+        pipelineId: typeof selector.pipelineId === "string" && selector.pipelineId.trim() ? selector.pipelineId.trim() : undefined,
+        runId: typeof selector.runId === "string" && selector.runId.trim() ? selector.runId.trim() : undefined,
+        batchRunId: typeof selector.batchRunId === "string" && selector.batchRunId.trim() ? selector.batchRunId.trim() : undefined,
+    };
+};
+const requirePipelineId = (selector) => {
+    if (selector.pipelineId)
+        return selector.pipelineId;
+    // 内嵌 runtime service 只能通过 pipelineId 定位 pipeline 实例；runId/batchRunId 在此层仅用于二次匹配。
+    throw new errors_1.CliError("Missing pipelineId for local runtime selector", {
+        code: "INVALID_ARGUMENT",
+        exitCode: 2,
+        details: {
+            runId: selector.runId ?? null,
+            batchRunId: selector.batchRunId ?? null,
+        },
+    });
+};
+const buildCliAppContext = (appContext) => {
+    const { readonly: readonlyServices, writable: writableServices } = appContext.services;
+    const serverLifecycleClient = (0, server_runtime_client_1.createServerLifecycleClient)();
+    return {
+        systemService: {
+            getSnapshot: async () => readonlyServices.system.getSnapshot(),
+        },
+        serverService: {
+            ensureServerReady: async () => serverLifecycleClient.ensureServerReady(),
+            startServer: async () => serverLifecycleClient.startServer(),
+            getServerStatus: async () => serverLifecycleClient.getServerStatus(),
+            stopServer: async () => serverLifecycleClient.stopServer(),
+        },
+        pipelineService: {
+            listPipelines: async () => readonlyServices.pipeline.listPipelines(),
+            getPipelineById: async (pipelineId) => readonlyServices.pipeline.getPipeline(pipelineId),
+            startPipeline: async (pipelineId) => writableServices.pipeline.startPipeline(pipelineId),
+            getPipelineStatus: async (selector) => {
+                const normalized = normalizePipelineSelector(selector);
+                const pipelineId = requirePipelineId(normalized);
+                return writableServices.pipeline.getPipelineExecutionStatus(pipelineId, {
+                    runId: normalized.runId,
+                    batchRunId: normalized.batchRunId,
+                });
+            },
+            stopPipeline: async (selector) => {
+                const normalized = normalizePipelineSelector(selector);
+                const pipelineId = requirePipelineId(normalized);
+                return writableServices.pipeline.stopPipeline(pipelineId, {
+                    runId: normalized.runId,
+                    batchRunId: normalized.batchRunId,
+                });
+            },
+            runPipeline: async (pipelineId) => writableServices.pipeline.runPipeline(pipelineId),
+            retryNode: async (input) => writableServices.pipeline.retryNode(input),
+            diagnoseNode: async (input) => {
+                const runtimeApiClient = (0, server_runtime_client_1.createPipelineRuntimeApiClient)();
+                return runtimeApiClient.diagnoseNode(input.pipelineId, input.nodeId, input.itemKey);
+            },
+            getOutput: async (pipelineId, runId) => writableServices.pipeline.getOutput(pipelineId, runId),
+            listOutputs: async (pipelineId) => writableServices.pipeline.listOutputs(pipelineId),
+            listLinks: async () => writableServices.pipeline.listLinks(),
+            getQueue: (pipelineId) => writableServices.pipeline.getQueue(pipelineId),
+        },
+        agentService: {
+            listAgents: async () => readonlyServices.agent.listAgents(),
+            listSessions: async () => readonlyServices.session.listSessions(),
+            filterSessionsByAgent: async (agentId) => {
+                const raw = await readonlyServices.session.listSessions();
+                const sessions = Array.isArray(raw) ? raw : [];
+                return sessions.filter((s) => {
+                    const id = typeof s?.id === "string" ? s.id : "";
+                    const parts = id.split(":");
+                    return parts.length >= 3 && parts[0] === "agent" && parts[1] === agentId;
+                });
+            },
+            sendMessage: async (input) => writableServices.session.sendMessage(input),
+            getSessionHistory: async (sessionId) => readonlyServices.session.getSessionHistory(sessionId),
+            sendMessageAndWaitForReply: async (input, options) => writableServices.session.sendMessageAndWaitForReply(input, options),
+        },
+        sessionService: {
+            listSessions: async () => readonlyServices.session.listSessions(),
+            sendMessage: async (input) => writableServices.session.sendMessage(input),
+        },
+        artifactService: {
+            planCleanup: async (pipelineId, options) => readonlyServices.artifact.planCleanup(pipelineId, (options ?? {})),
+            executeCleanup: async (pipelineId, plan) => readonlyServices.artifact.executeCleanup(pipelineId, plan),
+            rebuildIndex: async (pipelineId) => readonlyServices.artifact.rebuildIndex(pipelineId),
+            listArtifacts: async (filter) => readonlyServices.artifact.listArtifacts({
+                pipelineIds: filter.pipelineId ? [filter.pipelineId] : undefined,
+                nodeIds: filter.nodeId ? [filter.nodeId] : undefined,
+                statuses: filter.status ? filter.status.split(",").map((s) => s.trim()).filter(Boolean) : undefined,
+                kinds: filter.kind ? filter.kind.split(",").map((k) => k.trim()).filter(Boolean) : undefined,
+                batchRunId: filter.batchRunId,
+                runId: filter.runId,
+                cursor: filter.cursor,
+            }),
+            getArtifactContent: async (filter) => readonlyServices.artifact.getArtifactContent({
+                pipelineId: filter.pipelineId,
+                relativePath: filter.relativePath,
+            }),
+            exportArtifacts: async (filter) => readonlyServices.artifact.exportArtifactContents({
+                pipelineIds: filter.pipelineId ? [filter.pipelineId] : undefined,
+                nodeIds: filter.nodeId ? [filter.nodeId] : undefined,
+                statuses: filter.status ? filter.status.split(",").map((s) => s.trim()).filter(Boolean) : undefined,
+                kinds: filter.kind ? filter.kind.split(",").map((k) => k.trim()).filter(Boolean) : undefined,
+                batchRunId: filter.batchRunId,
+                dateFrom: filter.dateFrom,
+                dateTo: filter.dateTo,
+                limit: filter.limit,
+            }),
+        },
+        schedulerService: {
+            toggleScheduler: async (pipelineId, enabled) => writableServices.scheduler.toggleScheduler(pipelineId, enabled),
+            setSchedulerMode: async (pipelineId, mode) => writableServices.scheduler.setSchedulerMode(pipelineId, mode),
+        },
+    };
+};
+const buildRuntimeApiOnlyContext = () => {
+    const runtimeApiClient = (0, server_runtime_client_1.createPipelineRuntimeApiClient)();
+    const serverLifecycleClient = (0, server_runtime_client_1.createServerLifecycleClient)();
+    const unsupported = async () => {
+        throw new Error("unsupported_cli_runtime_api_context");
+    };
+    return {
+        systemService: {
+            getSnapshot: unsupported,
+        },
+        serverService: {
+            ensureServerReady: async () => serverLifecycleClient.ensureServerReady(),
+            startServer: async () => serverLifecycleClient.startServer(),
+            getServerStatus: async () => serverLifecycleClient.getServerStatus(),
+            stopServer: async () => serverLifecycleClient.stopServer(),
+        },
+        pipelineService: {
+            listPipelines: unsupported,
+            getPipelineById: unsupported,
+            startPipeline: async (pipelineId) => runtimeApiClient.startPipeline(pipelineId),
+            getPipelineStatus: async (selector) => runtimeApiClient.getPipelineStatus(selector),
+            stopPipeline: async (selector) => runtimeApiClient.stopPipeline(selector),
+            waitForPipelineWatchSignal: async (selector, timeoutMs) => runtimeApiClient.waitForPipelineWatchSignal(selector, timeoutMs),
+            runPipeline: async (pipelineId) => runtimeApiClient.startPipeline(pipelineId),
+            retryNode: unsupported,
+            diagnoseNode: async (input) => runtimeApiClient.diagnoseNode(input.pipelineId, input.nodeId, input.itemKey),
+            getOutput: async (pipelineId, runId) => runtimeApiClient.getOutput(pipelineId, runId),
+            listOutputs: async (pipelineId) => runtimeApiClient.listOutputs(pipelineId),
+            listLinks: async () => runtimeApiClient.listLinks(),
+            getQueue: async (pipelineId) => runtimeApiClient.getQueue(pipelineId),
+        },
+        agentService: {
+            listAgents: unsupported,
+            listSessions: unsupported,
+            filterSessionsByAgent: unsupported,
+            sendMessage: unsupported,
+            getSessionHistory: unsupported,
+            sendMessageAndWaitForReply: unsupported,
+        },
+        sessionService: {
+            listSessions: unsupported,
+            sendMessage: unsupported,
+        },
+        artifactService: {
+            listArtifacts: unsupported,
+            getArtifactContent: unsupported,
+            exportArtifacts: unsupported,
+            planCleanup: unsupported,
+            executeCleanup: unsupported,
+            rebuildIndex: unsupported,
+        },
+        schedulerService: {
+            toggleScheduler: unsupported,
+            setSchedulerMode: unsupported,
+        },
+    };
+};
+const createMainCliBootstrap = () => {
+    return async ({ route }) => {
+        const bootstrap = route.bootstrap;
+        if (bootstrap?.runtimeApiOnly) {
+            // runtime-api only 路由必须复用 daemon 提供的 API 语义，避免误落到内嵌 service 路径。
+            if (bootstrap.ensureServerReady) {
+                const serverLifecycleClient = (0, server_runtime_client_1.createServerLifecycleClient)();
+                // 运行类命令必须先绑定到持久执行宿主，避免 CLI 临时进程误充当后台宿主。
+                await serverLifecycleClient.ensureServerReady();
+            }
+            return {
+                app: buildRuntimeApiOnlyContext(),
+            };
+        }
+        const gatewayConfig = await (0, user_config_1.resolveGatewayConfig)();
+        const appContext = (0, create_app_context_1.createAppContext)({
+            gatewayUrl: gatewayConfig.url ?? undefined,
+            gatewayToken: gatewayConfig.token ?? undefined,
+        });
+        await appContext.initialize();
+        if (bootstrap?.gateway === "required") {
+            await appContext.gateway.connect();
+        }
+        else if (bootstrap?.gateway === "warmup") {
+            // 系统快照尽量尝试建链，失败时退回当前缓存状态，避免只读命令被完全阻断。
+            try {
+                await appContext.gateway.connect();
+            }
+            catch {
+                // 保持只读命令可退化执行。
+            }
+        }
+        return {
+            app: buildCliAppContext(appContext),
+            dispose: () => {
+                appContext.dispose();
+            },
+        };
+    };
+};
+exports.createMainCliBootstrap = createMainCliBootstrap;