taskmeld 0.1.1

package/dist/src/cli/commands/agent.js

@@ -0,0 +1,126 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.agentRoutes = exports.agentSendCommand = exports.agentSessionCommand = exports.agentListCommand = void 0;
+const errors_1 = require("../errors");
+const readFlagAsPositiveInteger = (value, fallback) => {
+    if (typeof value !== "string")
+        return fallback;
+    const parsed = Number.parseInt(value.trim(), 10);
+    return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+};
+const agentListCommand = async (_input, ctx) => {
+    return ctx.app.agentService.listAgents();
+};
+exports.agentListCommand = agentListCommand;
+const parseSessionId = (id) => {
+    const parts = id.split(":");
+    if (parts.length >= 3 && parts[0] === "agent") {
+        return { agentId: parts[1], sessionId: parts.slice(2).join(":") };
+    }
+    return { agentId: null, sessionId: id };
+};
+const agentSessionCommand = async (input, ctx) => {
+    const agentId = input.args[0];
+    const sessions = agentId
+        ? await ctx.app.agentService.filterSessionsByAgent(agentId)
+        : await ctx.app.agentService.listSessions();
+    const items = Array.isArray(sessions) ? sessions : [];
+    return items.map((s) => {
+        const rawId = typeof s.id === "string" ? s.id : "";
+        const parsed = parseSessionId(rawId);
+        return {
+            agentId: parsed.agentId,
+            sessionId: parsed.sessionId,
+            raw: s,
+        };
+    });
+};
+exports.agentSessionCommand = agentSessionCommand;
+const readPipedStdin = async (stdin) => {
+    if (!stdin || stdin.isTTY)
+        return "";
+    return new Promise((resolve, reject) => {
+        let content = "";
+        stdin.setEncoding?.("utf8");
+        stdin.on("data", (chunk) => {
+            content += typeof chunk === "string" ? chunk : chunk.toString("utf8");
+        });
+        stdin.on("end", () => resolve(content.trim()));
+        stdin.on("error", reject);
+    });
+};
+const agentSendCommand = async (input, ctx) => {
+    const agentId = (0, errors_1.assertRequiredArg)(input.args[0], "agentId");
+    const messageFromArgs = (input.args[1] ?? "").trim().replace(/\\n/g, "\n");
+    const messageFromStdin = !messageFromArgs ? await readPipedStdin(input.stdin) : "";
+    const message = messageFromArgs || messageFromStdin;
+    if (!message) {
+        throw new errors_1.CliError("Missing message: provide a positional argument or pipe via stdin", {
+            code: "INVALID_ARGUMENT",
+            exitCode: 2,
+        });
+    }
+    const sessionId = typeof input.flags.session === "string" && input.flags.session.trim()
+        ? input.flags.session.trim()
+        : "main";
+    const fullSessionId = `agent:${sessionId}:${agentId}`;
+    const timeoutMs = readFlagAsPositiveInteger(input.flags.timeout, 120_000);
+    const streamVal = input.flags.stream;
+    const isStreaming = streamVal === true || (typeof streamVal === "string" && streamVal === "true");
+    if (isStreaming && ctx.global.format !== "json") {
+        const result = await ctx.app.agentService.sendMessageAndWaitForReply({ sessionId: fullSessionId, message }, {
+            timeoutMs,
+            onChunk: (text) => {
+                process.stdout.write(text);
+            },
+        });
+        process.stdout.write("\n");
+        return { ...result, streamed: true };
+    }
+    return ctx.app.agentService.sendMessageAndWaitForReply({ sessionId: fullSessionId, message }, { timeoutMs });
+};
+exports.agentSendCommand = agentSendCommand;
+exports.agentRoutes = [
+    {
+        key: "agent.list",
+        path: ["agent", "list"],
+        description: "输出智能体列表",
+        handler: exports.agentListCommand,
+        bootstrap: { gateway: "required" },
+        help: {
+            usage: "taskmeld agent list [--format <json|md>]",
+            summary: "输出智能体列表",
+        },
+    },
+    {
+        key: "agent.session",
+        path: ["agent", "session"],
+        description: "输出会话列表（全部或按 agent 过滤）",
+        handler: exports.agentSessionCommand,
+        bootstrap: { gateway: "required" },
+        help: {
+            usage: "taskmeld agent session [agentId] [--format <json|md>]",
+            summary: "输出会话列表（全部或按 agent 过滤）",
+            args: [{ name: "agentId", required: false, description: "按 Agent ID 过滤会话" }],
+        },
+    },
+    {
+        key: "agent.send",
+        path: ["agent", "send"],
+        description: "向指定 agent 会话发送消息",
+        handler: exports.agentSendCommand,
+        bootstrap: { gateway: "required" },
+        help: {
+            usage: "taskmeld agent send <agentId> <message> [--session <id>] [--format <json|md>]",
+            summary: "向指定 agent 会话发送消息并等待回复",
+            args: [
+                { name: "agentId", required: true, description: "Agent ID" },
+                { name: "message", required: true, description: "消息内容" },
+            ],
+            options: [
+                { flags: ["--session"], valueName: "id", description: "会话 ID（默认 main）" },
+                { flags: ["--stream"], description: "流式输出回复内容" },
+            ],
+        },
+    },
+];

package/dist/src/cli/commands/artifact.js

@@ -0,0 +1,175 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.artifactRoutes = exports.artifactIndexCommand = exports.artifactCleanupCommand = exports.artifactExportCommand = exports.artifactShowCommand = exports.artifactListCommand = void 0;
+const errors_1 = require("../errors");
+const pickOptionalString = (value) => {
+    if (typeof value !== "string")
+        return undefined;
+    const trimmed = value.trim();
+    return trimmed ? trimmed : undefined;
+};
+const pickCsvStrings = (value) => {
+    if (typeof value !== "string")
+        return undefined;
+    const values = value.split(",").map((item) => item.trim()).filter(Boolean);
+    return values.length ? values : undefined;
+};
+const pickPositiveInteger = (value, flagName) => {
+    if (value === undefined)
+        return undefined;
+    if (value === true) {
+        throw new errors_1.CliError(`Invalid flag: --${flagName} requires a positive integer`, {
+            code: "INVALID_ARGUMENT",
+            exitCode: 2,
+        });
+    }
+    const parsed = Number(value);
+    if (!Number.isInteger(parsed) || parsed <= 0) {
+        throw new errors_1.CliError(`Invalid flag: --${flagName} must be a positive integer`, {
+            code: "INVALID_ARGUMENT",
+            exitCode: 2,
+        });
+    }
+    return parsed;
+};
+const artifactListCommand = async (input, ctx) => {
+    return ctx.app.artifactService.listArtifacts({
+        pipelineId: pickOptionalString(input.flags.pipeline),
+        nodeId: pickOptionalString(input.flags.node),
+        status: pickOptionalString(input.flags.status),
+        kind: pickOptionalString(input.flags.kind),
+        batchRunId: pickOptionalString(input.flags.batch),
+        runId: pickOptionalString(input.flags.run),
+        cursor: pickOptionalString(input.flags.cursor),
+    });
+};
+exports.artifactListCommand = artifactListCommand;
+const artifactShowCommand = async (input, ctx) => {
+    const pipelineId = (0, errors_1.assertRequiredArg)(input.args[0], "pipelineId");
+    const relativePath = (0, errors_1.assertRequiredArg)(input.args[1], "relativePath");
+    return ctx.app.artifactService.getArtifactContent({ pipelineId, relativePath });
+};
+exports.artifactShowCommand = artifactShowCommand;
+const artifactExportCommand = async (input, ctx) => {
+    return ctx.app.artifactService.exportArtifacts({
+        pipelineId: pickOptionalString(input.flags.pipeline),
+        nodeId: pickOptionalString(input.flags.node),
+        status: pickOptionalString(input.flags.status),
+        kind: pickOptionalString(input.flags.kind),
+        batchRunId: pickOptionalString(input.flags.batch),
+        dateFrom: pickOptionalString(input.flags.from),
+        dateTo: pickOptionalString(input.flags.to),
+        limit: pickPositiveInteger(input.flags.limit, "limit"),
+    });
+};
+exports.artifactExportCommand = artifactExportCommand;
+const artifactCleanupCommand = async (input, ctx) => {
+    const pipelineId = (0, errors_1.assertRequiredArg)(input.args[0], "pipelineId");
+    const plan = await ctx.app.artifactService.planCleanup(pipelineId, {
+        olderThanDays: pickPositiveInteger(input.flags["older-than"], "older-than"),
+        statuses: pickCsvStrings(input.flags.status),
+    });
+    const planObj = plan;
+    if (input.flags.confirm !== true) {
+        return { ...planObj, dryRun: true, message: "dry-run 模式，候选文件不会删除。传入 --confirm 执行真实删除。" };
+    }
+    const result = await ctx.app.artifactService.executeCleanup(pipelineId, plan);
+    return { ...planObj, dryRun: false, ...result };
+};
+exports.artifactCleanupCommand = artifactCleanupCommand;
+const artifactIndexCommand = async (input, ctx) => {
+    const action = (0, errors_1.assertRequiredArg)(input.args[0], "action");
+    if (action !== "rebuild") {
+        throw new errors_1.CliError(`Unknown artifact index action: ${action}`, {
+            code: "UNKNOWN_COMMAND",
+            exitCode: 2,
+            details: { action },
+        });
+    }
+    return ctx.app.artifactService.rebuildIndex(pickOptionalString(input.flags.pipeline));
+};
+exports.artifactIndexCommand = artifactIndexCommand;
+exports.artifactRoutes = [
+    {
+        key: "artifact.index",
+        path: ["artifact", "index"],
+        description: "重建产物索引",
+        handler: exports.artifactIndexCommand,
+        help: {
+            usage: "taskmeld artifact index rebuild [--pipeline <id>] [--format <json|md>]",
+            args: [{ name: "rebuild", required: true, description: "重建 index.jsonl" }],
+            options: [{ flags: ["--pipeline"], valueName: "id", description: "只重建指定流水线" }],
+            summary: "扫描产物目录并重建 index.jsonl，用于升级后纳入历史文件或修复索引不一致",
+        },
+    },
+    {
+        key: "artifact.list",
+        path: ["artifact", "list"],
+        description: "输出产物列表",
+        handler: exports.artifactListCommand,
+        help: {
+            usage: "taskmeld artifact list [--pipeline <id>] [--node <id>] [--status <status>] [--kind <kind>] [--batch <id>] [--run <id>] [--cursor <cursor>] [--format <json|md>]",
+            options: [
+                { flags: ["--pipeline"], valueName: "id", description: "按流水线过滤" },
+                { flags: ["--node"], valueName: "id", description: "按节点过滤" },
+                { flags: ["--status"], valueName: "status", description: "success,failed,rejected" },
+                { flags: ["--kind"], valueName: "kind", description: "artifact,envelope,adapter,group" },
+                { flags: ["--batch"], valueName: "id", description: "按批跑ID过滤" },
+                { flags: ["--run"], valueName: "id", description: "按运行RunId过滤" },
+                { flags: ["--cursor"], valueName: "cursor", description: "分页游标" },
+            ],
+            summary: "输出产物列表，支持状态/类型/批跑/游标分页",
+        },
+    },
+    {
+        key: "artifact.show",
+        path: ["artifact", "show"],
+        description: "输出产物内容",
+        handler: exports.artifactShowCommand,
+        help: {
+            usage: "taskmeld artifact show <pipelineId> <relativePath> [--format <json|md>]",
+            args: [
+                { name: "pipelineId", required: true, description: "流水线 ID" },
+                { name: "relativePath", required: true, description: "产物相对路径" },
+            ],
+            summary: "输出指定产物的文件内容",
+        },
+    },
+    {
+        key: "artifact.export",
+        path: ["artifact", "export"],
+        description: "导出产物内容",
+        handler: exports.artifactExportCommand,
+        help: {
+            usage: "taskmeld artifact export [--pipeline <id>] [--from <date>] [--to <date>] [--format <json>]",
+            options: [
+                { flags: ["--pipeline"], valueName: "id", description: "按流水线过滤" },
+                { flags: ["--node"], valueName: "id", description: "按节点过滤" },
+                { flags: ["--status"], valueName: "status", description: "success,failed,rejected" },
+                { flags: ["--kind"], valueName: "kind", description: "artifact,envelope,adapter,group" },
+                { flags: ["--batch"], valueName: "id", description: "按批跑ID过滤" },
+                { flags: ["--from"], valueName: "date", description: "开始日期 YYYY-MM-DD" },
+                { flags: ["--to"], valueName: "date", description: "结束日期 YYYY-MM-DD" },
+                { flags: ["--limit"], valueName: "n", description: "最大导出条数，默认20000" },
+            ],
+            summary: "导出产物内容为 日期->流水线->节点 三层JSON",
+        },
+    },
+    {
+        key: "artifact.cleanup",
+        path: ["artifact", "cleanup"],
+        description: "清理旧产物",
+        handler: exports.artifactCleanupCommand,
+        help: {
+            usage: "taskmeld artifact cleanup <pipelineId> [--older-than <days>] [--status <status>] [--confirm]",
+            args: [{ name: "pipelineId", required: true, description: "流水线 ID" }],
+            options: [
+                { flags: ["--pipeline"], valueName: "id", description: "按流水线过滤" },
+                { flags: ["--older-than"], valueName: "days", description: "保留天数，默认 success=30/failed=90/rejected=90" },
+                { flags: ["--status"], valueName: "status", description: "success,failed,rejected" },
+                { flags: ["--confirm"], description: "必须显式传入才执行真实删除，否则 dry-run" },
+            ],
+            summary: "清理旧产物文件，默认 dry-run 只展示候选不删除，传 --confirm 执行真实删除并重建索引",
+        },
+    },
+];

package/dist/src/cli/commands/init.js

@@ -0,0 +1,150 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initRoutes = exports.initCommand = void 0;
+const node_readline_1 = require("node:readline");
+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 c = {
+    reset: "\x1b[0m",
+    bold: "\x1b[1m",
+    dim: "\x1b[2m",
+    cyan: "\x1b[36m",
+    green: "\x1b[32m",
+    white: "\x1b[37m",
+    black: "\x1b[30m",
+    bgCyan: "\x1b[46m",
+    bgGreen: "\x1b[42m",
+};
+const hr = () => {
+    process.stdout.write(`\n  ${c.dim}${"─".repeat(50)}${c.reset}\n\n`);
+};
+const fieldPrompt = (rl, label, hint, prefill) => {
+    return new Promise((resolve) => {
+        process.stdout.write(`  ${c.bold}${c.white}${label}${c.reset}\n`);
+        process.stdout.write(`  ${c.dim}${hint}${c.reset}\n\n`);
+        rl.question(`  ${c.green}${c.bold}>${c.reset} `, (answer) => {
+            resolve(answer.trim());
+        });
+        if (prefill) {
+            rl.write(prefill);
+        }
+    });
+};
+const readConfig = async () => {
+    try {
+        const raw = await (0, promises_1.readFile)(userConfigPath, "utf8");
+        return JSON.parse(raw);
+    }
+    catch {
+        return {};
+    }
+};
+const writeConfig = async (config) => {
+    await (0, promises_1.mkdir)(userConfigDir, { recursive: true });
+    const existing = await readConfig();
+    const merged = { ...existing, ...config };
+    await (0, promises_1.writeFile)(userConfigPath, JSON.stringify(merged, null, 2) + "\n", "utf8");
+};
+const initCommand = async (input) => {
+    let url = typeof input.flags.url === "string" ? input.flags.url.trim() : "";
+    let token = typeof input.flags.token === "string" ? input.flags.token.trim() : "";
+    const interactive = !url || !token;
+    if (interactive) {
+        console.log("");
+        console.log(`  ${c.bold}${c.cyan}TaskMeld${c.reset}  ${c.dim}·  First-time Setup${c.reset}`);
+        console.log("");
+        console.log(`  ${c.dim}Configure your OpenClaw Gateway connection to get started.${c.reset}`);
+        console.log(`  ${c.dim}Config  ${userConfigPath}${c.reset}`);
+        const rl = (0, node_readline_1.createInterface)({
+            input: process.stdin,
+            output: process.stdout,
+        });
+        if (!url) {
+            hr();
+            url = await fieldPrompt(rl, "Gateway URL", "ws:// or wss:// address of your OpenClaw Gateway", "ws://127.0.0.1:18789") || "ws://127.0.0.1:18789";
+        }
+        if (url && !token) {
+            hr();
+            token = await fieldPrompt(rl, "Gateway Token", "Authentication token for the Gateway");
+        }
+        rl.close();
+        if (!url || !token) {
+            throw new Error("Both Gateway URL and Token are required to complete setup.");
+        }
+    }
+    if (!url.startsWith("ws://") && !url.startsWith("wss://")) {
+        throw new Error(`Invalid Gateway URL: ${url}. Must start with ws:// or wss://`);
+    }
+    await writeConfig({
+        gatewayUrl: url,
+        gatewayToken: token,
+    });
+    if (interactive) {
+        console.log("");
+        console.log(`  ${c.bgGreen}${c.black}${c.bold} > Gateway configured successfully ${c.reset}`);
+        console.log("");
+        console.log(`  ${c.dim}URL${c.reset}     ${url}`);
+        console.log(`  ${c.dim}Config${c.reset}  ${userConfigPath}`);
+        console.log("");
+        console.log(`  ${c.dim}Run ${c.white}\"taskmeld server start\"${c.reset}${c.dim} to begin.${c.reset}`);
+        console.log("");
+    }
+    return {
+        ok: true,
+        gatewayUrl: url,
+        configPath: userConfigPath,
+        interactive,
+    };
+};
+exports.initCommand = initCommand;
+exports.initRoutes = [
+    {
+        key: "init",
+        path: ["init"],
+        description: "Guided setup for OpenClaw Gateway connection",
+        handler: exports.initCommand,
+        renderHelp: () => {
+            const lines = [
+                "Usage:",
+                "  taskmeld init [--url <url>] [--token <token>]",
+                "",
+                "Description:",
+                "  Guided first-time setup — configure the OpenClaw Gateway connection.",
+                `  Config is saved to ${userConfigPath}`,
+                "",
+                "Options:",
+                "  --url <url>      Gateway WebSocket URL (ws:// or wss://)",
+                "  --token <token>  Gateway authentication token",
+                "",
+                "Examples:",
+                "  taskmeld init",
+                "  taskmeld init --url ws://127.0.0.1:18789 --token your-token",
+                "",
+                "Notes:",
+                "  Running without flags starts an interactive guided setup.",
+                "  Environment variables (OPENCLAW_GATEWAY_URL/TOKEN) take precedence over this config.",
+            ];
+            return lines.join("\n");
+        },
+        help: {
+            usage: "taskmeld init [--url <url>] [--token <token>]",
+            summary: "Guided first-time setup — configure the OpenClaw Gateway connection.",
+            options: [
+                { flags: ["--url"], valueName: "url", description: "Gateway WebSocket URL (ws:// or wss://)" },
+                { flags: ["--token"], valueName: "token", description: "Gateway authentication token" },
+            ],
+            examples: [
+                "taskmeld init",
+                "taskmeld init --url ws://127.0.0.1:18789 --token your-token",
+            ],
+            notes: [
+                "Running without flags starts an interactive guided setup.",
+                "Config is saved to ~/.taskmeld/config.json.",
+                "Environment variables (OPENCLAW_GATEWAY_URL/TOKEN) take precedence over this config.",
+            ],
+        },
+    },
+];

package/dist/src/cli/commands/pipeline/errors.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.throwSelectorScopedError = void 0;
+const errors_1 = require("../../errors");
+const selector_1 = require("./selector");
+const throwSelectorScopedError = (result, selector) => {
+    if (result.error === "pipeline_not_found" && selector.pipelineId) {
+        throw new errors_1.CliError(`Pipeline not found: ${selector.pipelineId}`, {
+            code: "PIPELINE_NOT_FOUND",
+            exitCode: 3,
+            details: selector,
+        });
+    }
+    if (result.error === "run_not_found" && selector.runId) {
+        throw new errors_1.CliError(`Run not found: ${selector.runId}`, {
+            code: "RUN_NOT_FOUND",
+            exitCode: 3,
+            details: selector,
+        });
+    }
+    if (result.error === "batch_run_not_found" && selector.batchRunId) {
+        throw new errors_1.CliError(`Batch run not found: ${selector.batchRunId}`, {
+            code: "BATCH_RUN_NOT_FOUND",
+            exitCode: 3,
+            details: selector,
+        });
+    }
+    throw new errors_1.CliError(`Pipeline selector not found: ${(0, selector_1.describePipelineSelector)(selector)}`, {
+        code: "PIPELINE_TARGET_NOT_FOUND",
+        exitCode: 3,
+        details: {
+            ...selector,
+            error: result.error ?? "unknown_error",
+        },
+    });
+};
+exports.throwSelectorScopedError = throwSelectorScopedError;

package/dist/src/cli/commands/pipeline/result.js

@@ -0,0 +1,179 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pipelineResultRoutes = exports.pipelineResultCommand = void 0;
+const errors_1 = require("../../errors");
+const groupItemRunsByBaseKey = (itemRuns) => {
+    const batchMap = new Map();
+    for (const item of itemRuns) {
+        const rawKey = String(item.itemKey ?? "");
+        const baseKey = rawKey.split("::")[0];
+        if (!batchMap.has(baseKey)) {
+            batchMap.set(baseKey, {
+                nodeIds: new Set(),
+                itemKeys: new Set(),
+                nodeStatusMap: new Map(),
+            });
+        }
+        const batch = batchMap.get(baseKey);
+        const nodeId = String(item.nodeId ?? "");
+        batch.nodeIds.add(nodeId);
+        if (rawKey)
+            batch.itemKeys.add(rawKey);
+        batch.nodeStatusMap.set(nodeId, {
+            status: String(item.status ?? "unknown"),
+            lastError: typeof item.lastError === "string" ? item.lastError : null,
+        });
+    }
+    return [...batchMap.entries()].map(([baseKey, batch]) => ({
+        baseKey,
+        nodeIds: batch.nodeIds,
+        itemKeys: batch.itemKeys,
+        nodeStatusMap: batch.nodeStatusMap,
+    }));
+};
+const extractEnvelopeContents = (content) => {
+    const obj = content;
+    if (!obj)
+        return { contents: [], logs: null };
+    const contents = Array.isArray(obj.contents) ? obj.contents : [];
+    const logs = Array.isArray(obj.logs) ? obj.logs : null;
+    return { contents, logs };
+};
+const pipelineResultCommand = async (input, ctx) => {
+    const pipelineId = (0, errors_1.assertRequiredArg)(input.args[0], "pipelineId");
+    const targetNodeId = typeof input.flags.node === "string" ? input.flags.node.trim() : undefined;
+    const includeLogs = input.flags.logs === true;
+    const detail = await ctx.app.pipelineService.getPipelineById(pipelineId);
+    if (!detail) {
+        throw new errors_1.CliError(`Pipeline not found: ${pipelineId}`, {
+            code: "PIPELINE_NOT_FOUND",
+            exitCode: 3,
+            details: { pipelineId },
+        });
+    }
+    const d = detail;
+    const run = d.run;
+    const runId = String(run.id ?? "");
+    const runStatus = String(run.status ?? "unknown");
+    const workflow = d.workflow;
+    const workflowNodes = Array.isArray(workflow.nodes) ? workflow.nodes : [];
+    const nodeTitleMap = new Map();
+    for (const wn of workflowNodes) {
+        const id = String(wn.id ?? "");
+        const title = String(wn.name ?? wn.title ?? id);
+        if (id)
+            nodeTitleMap.set(id, title);
+    }
+    const workflowPlugins = workflow.plugins;
+    const remoteBatchPlugin = workflowPlugins?.remoteBatch;
+    const isBatch = remoteBatchPlugin?.enabled === true;
+    const itemRuns = Array.isArray(run.itemRuns) ? run.itemRuns : [];
+    const batchRun = d.batchRun;
+    const batchRunId = typeof batchRun?.batchRunId === "string" ? batchRun.batchRunId : null;
+    const result = {
+        command: "pipeline.result",
+        pipelineId,
+        title: String(d.title ?? pipelineId),
+        runId,
+        runStatus,
+        batchRunId,
+        isBatch,
+        batches: [],
+        nodes: [],
+    };
+    // 通过 artifact service 查询 envelope 文件（复用统一读取语义）
+    const envelopeList = await ctx.app.artifactService.listArtifacts({
+        pipelineId,
+        runId,
+        kind: "envelope",
+    });
+    const envelopeItems = Array.isArray(envelopeList?.items) ? envelopeList.items : [];
+    // 按 nodeId 索引 envelope 的 relativePath
+    const envelopePathByNode = new Map();
+    for (const item of envelopeItems) {
+        const nid = item.nodeId?.trim();
+        const rp = item.relativePath?.trim();
+        if (nid && rp)
+            envelopePathByNode.set(nid, rp);
+    }
+    const fetchNodeContent = async (nodeId) => {
+        const relativePath = envelopePathByNode.get(nodeId);
+        if (!relativePath)
+            return { content: [], logs: null };
+        try {
+            const raw = await ctx.app.artifactService.getArtifactContent({ pipelineId, relativePath });
+            if (!raw?.content)
+                return { content: [], logs: null };
+            const { contents, logs } = extractEnvelopeContents(raw.content);
+            const content = contents.map((c) => (typeof c === "string" ? c : JSON.stringify(c)));
+            return { content, logs: includeLogs ? logs : null };
+        }
+        catch {
+            return { content: [], logs: null };
+        }
+    };
+    if (isBatch) {
+        const groups = groupItemRunsByBaseKey(itemRuns);
+        for (const group of groups) {
+            const batchNodes = [];
+            for (const nodeId of group.nodeIds) {
+                if (targetNodeId && nodeId !== targetNodeId)
+                    continue;
+                const { content, logs } = await fetchNodeContent(nodeId);
+                const nodeStatus = group.nodeStatusMap.get(nodeId);
+                batchNodes.push({
+                    nodeId,
+                    title: nodeTitleMap.get(nodeId) ?? nodeId,
+                    status: nodeStatus?.status ?? "unknown",
+                    lastError: nodeStatus?.lastError ?? null,
+                    content,
+                    logs,
+                });
+            }
+            if (batchNodes.length > 0) {
+                result.batches.push({
+                    itemKey: group.baseKey,
+                    items: [...group.itemKeys],
+                    nodes: batchNodes,
+                });
+            }
+        }
+    }
+    else {
+        const nodes = Array.isArray(run.nodes) ? run.nodes : [];
+        for (const node of nodes) {
+            const nodeId = String(node.id ?? "");
+            if (targetNodeId && nodeId !== targetNodeId)
+                continue;
+            const { content, logs } = await fetchNodeContent(nodeId);
+            result.nodes.push({
+                nodeId,
+                title: nodeTitleMap.get(nodeId) ?? String(node.title ?? nodeId),
+                status: String(node.status ?? "unknown"),
+                lastError: typeof node.lastError === "string" ? node.lastError : null,
+                content,
+                logs,
+            });
+        }
+    }
+    return result;
+};
+exports.pipelineResultCommand = pipelineResultCommand;
+exports.pipelineResultRoutes = [
+    {
+        key: "pipeline.result",
+        path: ["pipeline", "result"],
+        description: "输出流水线运行结果",
+        handler: exports.pipelineResultCommand,
+        help: {
+            usage: "taskmeld pipeline result <pipelineId> [--node <nodeId>] [--logs] [--format <json|md>]",
+            args: [{ name: "pipelineId", required: true, description: "流水线 ID" }],
+            options: [
+                { flags: ["--node"], valueName: "nodeId", description: "过滤到指定节点" },
+                { flags: ["--logs"], description: "同时展示处理日志" },
+                { flags: ["--format"], valueName: "json|md", description: "输出格式，默认 md" },
+            ],
+            summary: "输出流水线运行后各节点的产物内容",
+        },
+    },
+];