@fieldwangai/agentflow 0.1.156 → 0.1.159

package/bin/lib/flow-dsl/codegen.mjs

@@ -53,7 +53,7 @@ function interpolatedLiteral(text, folds) {
 }
 
 function displayFileExt(kind) {
-  return { html: "html", chart: "json", table: "json", mermaid: "mmd", ascii: "txt", react: "json" }[kind] || "md";
+  return { html: "html", code: "txt", chart: "json", table: "json", mermaid: "mmd", ascii: "txt", react: "json" }[kind] || "md";
 }
 
 /**
@@ -70,6 +70,25 @@ export function generateFlowSource(ir, opts = {}) {
     return rel;
   };
 
+  // 节点 id 就是顶层变量名，可能刚好叫 display / flow / file。节点 id 不能为了代码生成
+  // 偷偷改掉（那会变成另一张图），所以冲突时给 DSL API import 起别名：
+  // `import { display as displayApi } ...; const display = displayApi.markdown(...)`。
+  // 所有顶层标识符共用 taken；先给内置 API 占位，后面的输出解构和包 import 也会避开它们。
+  const taken = new Set(Object.keys(N));
+  const uniqueName = (base, fallback) => {
+    let name = isIdentifier(base) ? base : fallback;
+    if (taken.has(name)) name = fallback;
+    while (taken.has(name)) name += "_";
+    taken.add(name);
+    return name;
+  };
+  const flowApiRoots = ["agent", "control", "display", "file", "flow", "provide", "tool", "workspace"];
+  const flowApiBinding = new Map(flowApiRoots.map((root) => [root, uniqueName(root, `${root}Api`)]));
+  const apiCall = (name) => {
+    const [root, ...tail] = String(name || "").split(".");
+    return [flowApiBinding.get(root) || root, ...tail].join(".");
+  };
+
   // 同一个节点的 body 和某个引脚值可能都超阈值，文件名必须带槽名区分：都叫
   // `prompts/<id>.md` 的话两段不同的文本会写进同一个文件，往返时后写的覆盖先写的。
   const externalize = (id, slot, text) => {
@@ -83,7 +102,7 @@ export function generateFlowSource(ir, opts = {}) {
   };
   const textArg = (id, slot, text) => {
     const rel = externalize(id, slot, text);
-    return rel ? `file(${JSON.stringify(rel)})` : literal(text);
+    return rel ? `${apiCall("file")}(${JSON.stringify(rel)})` : literal(text);
   };
 
   const controlNext = new Map();
@@ -114,18 +133,6 @@ export function generateFlowSource(ir, opts = {}) {
     }),
   );
 
-  // 文件里所有顶层标识符共用一个命名空间：节点 id、解构出来的输出变量、import 绑定名。
-  // 分开发号就会撞——两个节点各有一个叫 ok 的自定义输出槽，是完全正常的图，但会生成两条
-  // `const { ok } = ...`，文件根本解析不回来。
-  const taken = new Set(Object.keys(N));
-  const uniqueName = (base, fallback) => {
-    let name = isIdentifier(base) ? base : fallback;
-    if (taken.has(name)) name = fallback;
-    while (taken.has(name)) name += "_";
-    taken.add(name);
-    return name;
-  };
-
   // 自定义输出槽通过解构暴露成变量：`const { storyId } = node;`
   const outVar = new Map();
   for (const [id, slots] of destructured) {
@@ -143,7 +150,7 @@ export function generateFlowSource(ir, opts = {}) {
     const shared = [...bindingOf.values()].find((v) => v.spec === pkg.specifier);
     bindingOf.set(id, shared || { name: uniqueName(base, `${base}Node`), spec: pkg.specifier });
   }
-  const callee = (id) => bindingOf.get(id)?.name || apiName(N[id].definitionId);
+  const callee = (id) => bindingOf.get(id)?.name || apiCall(apiName(N[id].definitionId));
 
   const bodyTextOf = (id) => String(
     (N[id].definitionId === "tool_nodejs" && N[id].script) ? N[id].script : (N[id].body || ""),
@@ -256,7 +263,7 @@ export function generateFlowSource(ir, opts = {}) {
   };
   const printItem = (item) => (
     Array.isArray(item)
-      ? `flow.fork(${item.map((s) => `flow(${s.map(printItem).join(", ")})`).join(", ")})`
+      ? `${apiCall("flow.fork")}(${item.map((s) => `${apiCall("flow")}(${s.map(printItem).join(", ")})`).join(", ")})`
       : item
   );
 
@@ -286,8 +293,8 @@ export function generateFlowSource(ir, opts = {}) {
     if (isIf(id)) {
       const thenIds = (controlNext.get(id) || []).filter((x) => x.slot === "next1").map((x) => x.to);
       const elseIds = (controlNext.get(id) || []).filter((x) => x.slot === "next2").map((x) => x.to);
-      args.push(`flow(${chainFrom(thenIds).map(printItem).join(", ")})`);
-      args.push(`flow(${chainFrom(elseIds).map(printItem).join(", ")})`);
+      args.push(`${apiCall("flow")}(${chainFrom(thenIds).map(printItem).join(", ")})`);
+      args.push(`${apiCall("flow")}(${chainFrom(elseIds).map(printItem).join(", ")})`);
     } else {
       const usesScript = node.definitionId === "tool_nodejs" && node.script;
       const body = usesScript ? node.script : node.body;
@@ -323,14 +330,14 @@ export function generateFlowSource(ir, opts = {}) {
     if (N[runId].label) head.push(literal(N[runId].label));
     // 排程配置存在 run 节点的 body 里，是 JSON 字符串
     if (definitionId === "workspace_scheduled_run") head.push(N[runId].body ? literal(N[runId].body) : "null");
-    const fn = definitionId === "workspace_scheduled_run" ? "flow.schedule" : "flow";
+    const fn = apiCall(definitionId === "workspace_scheduled_run" ? "flow.schedule" : "flow");
     out.push(`export const ${runId} = ${fn}(${[...head, ...seq].join(", ")});\n`);
   }
 
   // 一个 run 直接连到另一个 run：接力，不是子图
   for (const [src, list] of [...controlNext].sort()) {
     for (const x of list) {
-      if (RUN_DEFINITIONS.has(N[x.to].definitionId)) out.push(`flow.resume(${src}, ${x.to});\n`);
+      if (RUN_DEFINITIONS.has(N[x.to].definitionId)) out.push(`${apiCall("flow.resume")}(${src}, ${x.to});\n`);
     }
   }
 
@@ -339,13 +346,17 @@ export function generateFlowSource(ir, opts = {}) {
   for (const id of ids) {
     if (declared.has(id) || RUN_DEFINITIONS.has(N[id].definitionId) || controlTargets.has(id)) continue;
     if (!(controlNext.get(id) || []).length) continue;
-    out.push(`flow.detached(${chainFrom([id]).map(printItem).join(", ")});\n`);
+    out.push(`${apiCall("flow.detached")}(${chainFrom([id]).map(printItem).join(", ")});\n`);
   }
   for (const id of ids) {
     if (!declared.has(id) && !RUN_DEFINITIONS.has(N[id].definitionId)) declare(id, true);
   }
 
-  const imports = [`import { agent, control, display, file, flow, provide, tool, workspace } from "agentflow/flow";`];
+  const flowImports = flowApiRoots.map((root) => {
+    const local = flowApiBinding.get(root);
+    return local === root ? root : `${root} as ${local}`;
+  });
+  const imports = [`import { ${flowImports.join(", ")} } from "agentflow/flow";`];
   const seenBinding = new Set();
   for (const id of ids) {
     const binding = bindingOf.get(id);

package/bin/lib/flow-dsl/parser.mjs

@@ -59,6 +59,26 @@ export function parseFlowSource(source, opts = {}) {
     unresolved.push({ line: node?.loc?.start?.line || 0, message });
   };
 
+  // codegen 在节点 id 与 DSL API 名冲突时会生成
+  // `import { display as displayApi } from "agentflow/flow"`。静态解析时先把 local 名还原成
+  // canonical API 名，后面的节点类型、flow 控制语句和 file() 才仍走同一套规则。
+  const flowApiOf = new Map();
+  for (const stmt of ast.body) {
+    if (stmt.type !== "ImportDeclaration" || String(stmt.source.value) !== "agentflow/flow") continue;
+    for (const specifier of stmt.specifiers || []) {
+      if (specifier.type !== "ImportSpecifier") continue;
+      const imported = specifier.imported?.name ?? specifier.imported?.value;
+      const local = specifier.local?.name;
+      if (imported && local) flowApiOf.set(local, String(imported));
+    }
+  }
+  const apiCalleePath = (node) => {
+    const raw = calleePath(node);
+    if (!raw) return raw;
+    const [root, ...tail] = raw.split(".");
+    return [flowApiOf.get(root) || root, ...tail].join(".");
+  };
+
   function stringOf(node) {
     if (!node) return null;
     if (node.type === "Literal" && typeof node.value === "string") return node.value;
@@ -72,7 +92,7 @@ export function parseFlowSource(source, opts = {}) {
       return String(node.operator === "-" ? -node.argument.value : node.argument.value);
     }
     if (node.type === "TemplateLiteral" && node.expressions.length === 0) return node.quasis[0].value.cooked;
-    if (node.type === "CallExpression" && calleePath(node.callee) === "file") {
+    if (node.type === "CallExpression" && apiCalleePath(node.callee) === "file") {
       const rel = stringOf(node.arguments[0]);
       if (rel == null) return null;
       if (!(rel in files)) throw new Error(`file(${JSON.stringify(rel)}) 找不到对应文件`);
@@ -229,7 +249,7 @@ export function parseFlowSource(source, opts = {}) {
     const out = [];
     for (const arg of call.arguments) {
       if (arg.type === "Identifier") out.push(arg.name);
-      else if (arg.type === "CallExpression" && calleePath(arg.callee) === "flow.fork") {
+      else if (arg.type === "CallExpression" && apiCalleePath(arg.callee) === "flow.fork") {
         out.push({ fork: arg.arguments.map(itemsOf) });
       } else {
         unresolvedAt(arg, "控制流参数只能是节点变量名或 flow.fork(...)");
@@ -277,7 +297,7 @@ export function parseFlowSource(source, opts = {}) {
         unresolvedAt(d, `${id}: 节点声明右边必须是一次节点调用`);
         continue;
       }
-      const path = calleePath(init.callee);
+      const path = apiCalleePath(init.callee);
       const args = [...init.arguments];
 
       const first = args[0];
@@ -384,7 +404,7 @@ export function parseFlowSource(source, opts = {}) {
     }
 
     if (decl?.type === "ExpressionStatement" && decl.expression.type === "CallExpression") {
-      const path = calleePath(decl.expression.callee);
+      const path = apiCalleePath(decl.expression.callee);
       if (path === "flow.resume") {
         const [a, b] = decl.expression.arguments.map((x) => x.name);
         if (a && b) edges.push(`${a}|next|${b}|prev`);

package/bin/lib/jenkins.mjs

@@ -0,0 +1,368 @@
+import crypto from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+
+const PACKAGE_RE = /(?:\.apk|\.aab|\.ipa)(?:[?#]|$)|apk-dir|apk-file/i;
+const QR_RE = /(?:^|[^a-z])(?:qr|qrcode)(?:[^a-z]|$)|二维码/i;
+const URL_RE = /https?:\/\/[^\s<>"']+/gi;
+
+export const JENKINS_BUILD_STATE_VERSION = 1;
+export const DEFAULT_JENKINS_POLL_INTERVAL_MS = 30_000;
+export const DEFAULT_JENKINS_TIMEOUT_MS = 2 * 60 * 60 * 1000;
+
+function safeText(value, max = 800) {
+  return String(value ?? "").replace(/[\r\n]+/g, " ").trim().slice(0, max);
+}
+
+function safeCredentialKey(ref) {
+  return String(ref || "")
+    .trim()
+    .toUpperCase()
+    .replace(/[^A-Z0-9]+/g, "_")
+    .replace(/^_+|_+$/g, "");
+}
+
+function parseDurationMs(raw, fallback) {
+  const text = String(raw ?? "").trim().toLowerCase();
+  if (!text) return fallback;
+  const match = text.match(/^(\d+(?:\.\d+)?)\s*(ms|s|m|h|d)?$/);
+  if (!match) throw new Error(`invalid duration: ${raw}`);
+  const value = Number(match[1]);
+  const unit = match[2] || "s";
+  const factor = unit === "ms" ? 1 : unit === "s" ? 1000 : unit === "m" ? 60_000 : unit === "h" ? 3_600_000 : 86_400_000;
+  return Math.round(value * factor);
+}
+
+export function normalizeJenkinsBuildConfig(inputs = {}) {
+  const job = String(inputs.job || inputs.jobName || "").trim();
+  if (!job) throw new Error("Jenkins job is required");
+  let parameters = {};
+  const rawParameters = inputs.parameters ?? inputs.parametersJson ?? "{}";
+  if (rawParameters && typeof rawParameters === "object" && !Array.isArray(rawParameters)) {
+    parameters = { ...rawParameters };
+  } else if (String(rawParameters || "").trim()) {
+    const parsed = JSON.parse(String(rawParameters));
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+      throw new Error("Jenkins parameters must be a JSON object");
+    }
+    parameters = parsed;
+  }
+  const pollIntervalMs = Math.max(5_000, parseDurationMs(inputs.pollInterval || inputs.pollIntervalSec, DEFAULT_JENKINS_POLL_INTERVAL_MS));
+  const timeoutMs = Math.max(pollIntervalMs, parseDurationMs(inputs.timeout || inputs.timeoutSec, DEFAULT_JENKINS_TIMEOUT_MS));
+  return {
+    job,
+    parameters,
+    credentialRef: String(inputs.credentialRef || "").trim(),
+    pollIntervalMs,
+    timeoutMs,
+  };
+}
+
+export function jenkinsCredentialEnv(env = process.env, credentialRef = "") {
+  const key = safeCredentialKey(credentialRef);
+  const prefix = key ? `JENKINS_${key}_` : "";
+  const pick = (name) => (prefix && env[`${prefix}${name}`]) || env[`JENKINS_${name}`] || "";
+  return {
+    baseUrl: String(pick("BASE_URL") || "").trim().replace(/\/+$/, ""),
+    username: String(pick("USERNAME") || "").trim(),
+    token: String(pick("TOKEN") || "").trim(),
+  };
+}
+
+function trimUrl(url) {
+  return String(url || "").trim().replace(/[.,;:!?\])}]+$/, "");
+}
+
+function jobPath(job) {
+  const parts = String(job || "").split("/").map((part) => part.trim()).filter(Boolean);
+  if (!parts.length) throw new Error("Jenkins job is required");
+  return parts.map((part) => `job/${encodeURIComponent(part)}`).join("/");
+}
+
+function absoluteUrl(baseUrl, candidate) {
+  const value = String(candidate || "").trim();
+  if (!value) return "";
+  return new URL(value, `${baseUrl}/`).toString();
+}
+
+async function responseBody(response) {
+  const text = await response.text();
+  if (!text.trim()) return {};
+  try {
+    return JSON.parse(text);
+  } catch {
+    return { raw: text };
+  }
+}
+
+/** Native Jenkins Remote API client. Credentials never leave the request headers. */
+export function createJenkinsHttpInvoker({ credentialRef = "", env = process.env, fetchImpl = globalThis.fetch, signal = null, requestTimeoutMs = 30_000 } = {}) {
+  if (typeof fetchImpl !== "function") throw new Error("global fetch is not available in this Node.js runtime");
+  const credentials = jenkinsCredentialEnv(env, credentialRef);
+  if (!credentials.baseUrl) {
+    const suffix = credentialRef ? ` for credentialRef ${credentialRef}` : "";
+    throw new Error(`JENKINS_BASE_URL is required${suffix}`);
+  }
+  const headers = { Accept: "application/json" };
+  if (credentials.username || credentials.token) {
+    headers.Authorization = `Basic ${Buffer.from(`${credentials.username}:${credentials.token}`).toString("base64")}`;
+  }
+
+  const request = async (url, options = {}) => {
+    const controller = new AbortController();
+    const onAbort = () => controller.abort(signal?.reason);
+    if (signal) signal.addEventListener("abort", onAbort, { once: true });
+    const timer = setTimeout(() => controller.abort(new Error("Jenkins request timed out")), Math.max(1_000, Number(requestTimeoutMs) || 30_000));
+    try {
+      const response = await fetchImpl(url, {
+        ...options,
+        headers: { ...headers, ...(options.headers || {}) },
+        signal: controller.signal,
+      });
+      const body = await responseBody(response);
+      if (!response.ok) {
+        return { ok: false, status: response.status, safe_summary: `Jenkins HTTP ${response.status}: ${safeText(body?.message || body?.raw || response.statusText)}` };
+      }
+      return { ok: true, response, body };
+    } finally {
+      clearTimeout(timer);
+      if (signal) signal.removeEventListener("abort", onAbort);
+    }
+  };
+
+  return async (operation, args = {}) => {
+    if (operation === "trigger") {
+      const configuredParameters = args.parameters || {};
+      let parameterized = Object.keys(configuredParameters).length > 0;
+      if (!parameterized) {
+        const metadataUrl = `${credentials.baseUrl}/${jobPath(args.job)}/api/json?tree=actions[parameterDefinitions[name]]`;
+        const metadata = await request(metadataUrl);
+        if (!metadata.ok) return metadata;
+        parameterized = (Array.isArray(metadata.body?.actions) ? metadata.body.actions : [])
+          .some((action) => Array.isArray(action?.parameterDefinitions) && action.parameterDefinitions.length > 0);
+      }
+      const endpoint = `${credentials.baseUrl}/${jobPath(args.job)}/${parameterized ? "buildWithParameters" : "build"}`;
+      const form = new URLSearchParams();
+      for (const [key, value] of Object.entries(configuredParameters)) {
+        form.set(key, value == null ? "" : typeof value === "object" ? JSON.stringify(value) : String(value));
+      }
+      const result = await request(endpoint, {
+        method: "POST",
+        headers: { "Content-Type": "application/x-www-form-urlencoded" },
+        body: form.toString(),
+        redirect: "manual",
+      });
+      if (!result.ok) return result;
+      const location = result.response.headers.get("location") || "";
+      const queueUrl = absoluteUrl(credentials.baseUrl, location);
+      const queueId = queueUrl.match(/\/queue\/item\/([^/?#]+)/)?.[1] || "";
+      return queueId
+        ? { ok: true, resource: { queue_id: decodeURIComponent(queueId), queue_url: queueUrl } }
+        : { ok: false, safe_summary: "Jenkins trigger did not return a queue Location header" };
+    }
+    if (operation === "queue") {
+      const url = `${credentials.baseUrl}/queue/item/${encodeURIComponent(String(args.queueId))}/api/json`;
+      const result = await request(url);
+      return result.ok ? { ok: true, resource: { item: result.body } } : result;
+    }
+    if (operation === "build") {
+      const url = `${credentials.baseUrl}/${jobPath(args.job)}/${encodeURIComponent(String(args.buildNumber))}/api/json`;
+      const result = await request(url);
+      return result.ok ? { ok: true, resource: { build: result.body } } : result;
+    }
+    throw new Error(`unsupported Jenkins operation: ${operation}`);
+  };
+}
+
+function hashParameters(parameters) {
+  return crypto.createHash("sha256").update(JSON.stringify(parameters || {})).digest("hex").slice(0, 16);
+}
+
+function artifactUrl(buildUrl, artifact) {
+  const direct = trimUrl(artifact?.url);
+  if (direct) return direct;
+  const relative = String(artifact?.relativePath || "").trim();
+  if (!relative || !buildUrl) return "";
+  return `${String(buildUrl).replace(/\/+$/, "")}/artifact/${relative.split("/").map(encodeURIComponent).join("/")}`;
+}
+
+function collectBuildLinks(build = {}) {
+  const buildUrl = trimUrl(build.url);
+  const packageUrls = [];
+  const qrUrls = [];
+  const add = (context, rawUrl) => {
+    const url = trimUrl(rawUrl);
+    if (!/^https?:\/\//i.test(url)) return;
+    const haystack = `${context || ""} ${url}`;
+    if (QR_RE.test(haystack)) {
+      if (!qrUrls.includes(url)) qrUrls.push(url);
+    } else if (PACKAGE_RE.test(haystack)) {
+      if (!packageUrls.includes(url)) packageUrls.push(url);
+    }
+  };
+  for (const artifact of Array.isArray(build.artifacts) ? build.artifacts : []) {
+    add(artifact?.relativePath || artifact?.fileName || "", artifactUrl(buildUrl, artifact));
+  }
+  const scan = (value, context = "", depth = 0) => {
+    if (depth > 5 || value == null) return;
+    if (typeof value === "string") {
+      for (const url of value.match(URL_RE) || []) add(context, url);
+    } else if (Array.isArray(value)) {
+      for (const item of value) scan(item, context, depth + 1);
+    } else if (typeof value === "object") {
+      for (const [key, item] of Object.entries(value)) scan(item, `${context} ${key}`, depth + 1);
+    }
+  };
+  scan(build.description || "", "description");
+  scan(build.actions || [], "actions");
+  return { buildUrl, url: packageUrls[0] || buildUrl, qrUrl: qrUrls[0] || "" };
+}
+
+function waitResult(state, nowMs, pollIntervalMs, message) {
+  const wakeAt = new Date(nowMs + pollIntervalMs).toISOString();
+  return { kind: "waiting", message, wakeAt, state: { ...state, wakeAt, message, updatedAt: new Date(nowMs).toISOString() } };
+}
+
+function completeResult(state, nowMs, status, message, links = {}) {
+  const completedAt = new Date(nowMs).toISOString();
+  const next = {
+    ...state,
+    phase: "complete",
+    status,
+    message,
+    url: links.url || state.url || state.buildUrl || "",
+    qrUrl: links.qrUrl || state.qrUrl || "",
+    buildUrl: links.buildUrl || state.buildUrl || "",
+    wakeAt: "",
+    completedAt,
+    updatedAt: completedAt,
+  };
+  return { kind: "complete", message, state: next, outputs: { status, url: next.url, qrUrl: next.qrUrl } };
+}
+
+function failedResult(state, nowMs, message) {
+  return { ...completeResult(state, nowMs, "ERROR", message), kind: "failed" };
+}
+
+function blockedTriggerResult(state, nowMs, message) {
+  const updatedAt = new Date(nowMs).toISOString();
+  return {
+    kind: "failed",
+    message,
+    state: { ...state, phase: "triggering", status: "ERROR", message, wakeAt: "", updatedAt },
+    outputs: { status: "ERROR", url: state.url || state.buildUrl || "", qrUrl: state.qrUrl || "" },
+  };
+}
+
+function invokeFailure(state, nowMs, config, response, fallback) {
+  const errors = Number(state.consecutiveErrors || 0) + 1;
+  const message = safeText(response?.safe_summary || response?.blocked_reason || fallback || "Jenkins request failed");
+  const next = { ...state, consecutiveErrors: errors, lastError: message };
+  if ([401, 403].includes(Number(response?.status)) || errors >= 3) return failedResult(next, nowMs, message);
+  return waitResult(next, nowMs, config.pollIntervalMs, `Jenkins 暂时不可用，稍后重试 (${errors}/3)`);
+}
+
+/** Advances exactly one remote operation and returns a durable checkpoint. */
+export async function advanceJenkinsBuild({ state, config, invoke, persistState = () => {}, nowMs = Date.now(), cancelled = false, runId = "" }) {
+  const nowIso = new Date(nowMs).toISOString();
+  let current = state && typeof state === "object" ? { ...state } : null;
+  if (cancelled) return completeResult(current || { version: 1, job: config.job, createdAt: nowIso }, nowMs, "CANCELLED", "Jenkins 构建监控已取消");
+  if (current?.phase === "complete") return completeResult(current, nowMs, current.status || "ERROR", current.message || "Jenkins 构建已结束", current);
+
+  if (!current) {
+    current = {
+      version: JENKINS_BUILD_STATE_VERSION,
+      runId: String(runId || ""),
+      job: config.job,
+      parametersHash: hashParameters(config.parameters),
+      phase: "triggering",
+      status: "QUEUED",
+      createdAt: nowIso,
+      startedAt: nowIso,
+      deadlineAt: new Date(nowMs + config.timeoutMs).toISOString(),
+      pollCount: 0,
+      consecutiveErrors: 0,
+      updatedAt: nowIso,
+    };
+    // Persist before the non-idempotent trigger. A crash must never trigger a duplicate build.
+    persistState(current);
+    let response;
+    try {
+      response = await invoke("trigger", { job: config.job, parameters: config.parameters });
+    } catch (error) {
+      return blockedTriggerResult(current, nowMs, `Jenkins 触发结果未知，为避免重复构建未自动重试：${safeText(error?.message || error)}`);
+    }
+    if (!response?.ok) return failedResult(current, nowMs, safeText(response?.safe_summary || response?.blocked_reason || "Jenkins trigger failed"));
+    const queueId = String(response?.resource?.queue_id || response?.resource?.queueId || "").trim();
+    if (!queueId) return failedResult(current, nowMs, "Jenkins trigger did not return queueId");
+    current = { ...current, phase: "queued", status: "QUEUED", queueId, queueUrl: response?.resource?.queue_url || "", message: `已进入 Jenkins 队列 ${queueId}`, updatedAt: nowIso };
+    return waitResult(current, nowMs, config.pollIntervalMs, current.message);
+  }
+
+  if (current.job !== config.job || current.parametersHash !== hashParameters(config.parameters)) {
+    return failedResult(current, nowMs, "Jenkins checkpoint does not match the current job or parameters");
+  }
+  if (current.phase === "triggering") return blockedTriggerResult(current, nowMs, "Jenkins 触发结果未知，为避免重复构建未自动重试");
+  if (current.deadlineAt && Date.parse(current.deadlineAt) <= nowMs) return completeResult(current, nowMs, "TIMEOUT", "等待 Jenkins 构建超时");
+
+  if (current.phase === "queued") {
+    let response;
+    try {
+      response = await invoke("queue", { queueId: current.queueId });
+    } catch (error) {
+      response = { ok: false, safe_summary: error?.message || String(error) };
+    }
+    if (!response?.ok) return invokeFailure(current, nowMs, config, response, "Jenkins queue lookup failed");
+    const item = response?.resource?.item || {};
+    const executable = item.executable || {};
+    if (item.cancelled) return completeResult(current, nowMs, "ABORTED", "Jenkins 队列任务已取消");
+    if (executable.number != null) {
+      const buildNumber = String(executable.number);
+      const next = { ...current, phase: "running", status: "RUNNING", buildNumber, buildUrl: trimUrl(executable.url), pollCount: Number(current.pollCount || 0) + 1, consecutiveErrors: 0 };
+      return waitResult(next, nowMs, config.pollIntervalMs, `Jenkins 构建中 · #${buildNumber}`);
+    }
+    const next = { ...current, pollCount: Number(current.pollCount || 0) + 1, consecutiveErrors: 0, queueReason: safeText(item.why || "") };
+    return waitResult(next, nowMs, config.pollIntervalMs, next.queueReason || `Jenkins 排队中 · ${current.queueId}`);
+  }
+
+  if (current.phase === "running") {
+    let response;
+    try {
+      response = await invoke("build", { job: config.job, buildNumber: current.buildNumber });
+    } catch (error) {
+      response = { ok: false, safe_summary: error?.message || String(error) };
+    }
+    if (!response?.ok) return invokeFailure(current, nowMs, config, response, "Jenkins build lookup failed");
+    const build = response?.resource?.build || {};
+    const links = collectBuildLinks(build);
+    if (build.building || !build.result) {
+      const next = { ...current, status: "RUNNING", buildUrl: links.buildUrl || current.buildUrl || "", pollCount: Number(current.pollCount || 0) + 1, consecutiveErrors: 0 };
+      return waitResult(next, nowMs, config.pollIntervalMs, `Jenkins 构建中 · #${current.buildNumber}`);
+    }
+    const status = String(build.result || "ERROR").trim().toUpperCase();
+    return completeResult({ ...current, buildNumber: String(build.number ?? current.buildNumber ?? "") }, nowMs, status, `Jenkins ${status}${current.buildNumber ? ` · #${current.buildNumber}` : ""}`, links);
+  }
+
+  return failedResult(current, nowMs, `Unknown Jenkins phase: ${safeText(current.phase)}`);
+}
+
+export function readJenkinsBuildState(filePath) {
+  try {
+    const parsed = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+
+export function writeJenkinsBuildState(filePath, state) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  const temp = `${filePath}.tmp-${process.pid}-${crypto.randomBytes(4).toString("hex")}`;
+  fs.writeFileSync(temp, JSON.stringify(state, null, 2) + "\n", { encoding: "utf-8", mode: 0o600 });
+  fs.renameSync(temp, filePath);
+}
+
+export function jenkinsBuildStatePath(workspaceRoot, nodeId) {
+  const safeNodeId = String(nodeId || "jenkins").replace(/[^A-Za-z0-9._-]+/g, "_").slice(0, 120) || "jenkins";
+  return path.join(path.resolve(workspaceRoot), ".workspace", "agentflow", "jenkins", `${safeNodeId}.json`);
+}

package/bin/lib/legacy-flow-execution.mjs

@@ -33,7 +33,6 @@ export const WORKSPACE_UNSUPPORTED_NODE_IDS = new Set([
   "tool_get_env",
   // 其它
   "tool_print",
-  "tool_jenkins_build",
 ]);
 
 /** 节点面板与目录需要隐藏的全部 definitionId */

package/bin/lib/locales/en.json

@@ -351,6 +351,10 @@
       "displayName": "Markdown Display",
       "description": "Render Markdown content on the Workspace canvas and pass the text downstream"
     },
+    "display_code": {
+      "displayName": "Code Display",
+      "description": "Render highlighted source code with line numbers, copy, wrap, and download controls, then pass the code downstream"
+    },
     "display_mermaid": {
       "displayName": "Mermaid Display",
       "description": "Render Mermaid diagram source on the Workspace canvas and pass the source downstream"

package/bin/lib/locales/zh.json

@@ -351,6 +351,10 @@
       "displayName": "Markdown 展示",
       "description": "在 Workspace 画布中渲染 Markdown 内容，并将文本继续传给下游"
     },
+    "display_code": {
+      "displayName": "代码展示",
+      "description": "在 Workspace 画布中高亮展示代码，支持行号、复制、换行和下载，并将代码继续传给下游"
+    },
     "display_mermaid": {
       "displayName": "Mermaid 展示",
       "description": "在 Workspace 画布中渲染 Mermaid 图，并将源码继续传给下游"

package/bin/lib/mcp-server.mjs

@@ -70,6 +70,7 @@ function query(params = {}) {
 function displayKind(definitionId) {
   const id = String(definitionId || "");
   if (id === "display_markdown") return "markdown";
+  if (id === "display_code") return "code";
   if (id === "display_mermaid") return "mermaid";
   if (id === "display_ascii") return "ascii";
   if (id === "display_html") return "html";