@fieldwangai/agentflow 0.1.137 → 0.1.141

package/bin/lib/prd-workflow-collaboration.mjs

@@ -4,7 +4,7 @@ import path from "path";
 import { getAgentflowDataRoot } from "./paths.mjs";
 import { getTeamForUser } from "./teams.mjs";
 
-const REGISTRY_VERSION = 2;
+const REGISTRY_VERSION = 4;
 
 function registryPath() {
   return path.join(getAgentflowDataRoot(), "collaboration", "prd-workflows.json");
@@ -63,6 +63,48 @@ function normalizedMemberMap(value) {
     .filter(([userId, role]) => userId && role));
 }
 
+function normalizeKnowledgeBindings(value) {
+  if (!Array.isArray(value)) return [];
+  const seen = new Set();
+  return value.flatMap((entry) => {
+    if (!entry || typeof entry !== "object" || Array.isArray(entry)) return [];
+    const workspaceId = String(entry.workspaceId || entry.id || "").trim();
+    if (!workspaceId || seen.has(workspaceId)) return [];
+    seen.add(workspaceId);
+    return [{
+      workspaceId,
+      label: String(entry.label || workspaceId).trim() || workspaceId,
+      kind: String(entry.kind || "git").trim().toLowerCase(),
+      type: String(entry.type || "knowledge").trim().toLowerCase(),
+      branch: String(entry.branch || "").trim(),
+      boundBy: normalizeUserId(entry.boundBy),
+      boundAt: String(entry.boundAt || "").trim(),
+    }];
+  });
+}
+
+function normalizeProjectBindings(value) {
+  if (!Array.isArray(value)) return [];
+  const seen = new Set();
+  return value.flatMap((entry) => {
+    if (!entry || typeof entry !== "object" || Array.isArray(entry)) return [];
+    const workspaceId = String(entry.workspaceId || "").trim();
+    const flowId = String(entry.flowId || "").trim();
+    const flowSource = String(entry.flowSource || "user").trim() || "user";
+    if (!workspaceId || !flowId || seen.has(workspaceId)) return [];
+    seen.add(workspaceId);
+    return [{
+      workspaceId,
+      flowId,
+      flowSource,
+      archived: entry.archived === true,
+      ownerId: normalizeUserId(entry.ownerId),
+      boundBy: normalizeUserId(entry.boundBy),
+      boundAt: String(entry.boundAt || "").trim(),
+    }];
+  });
+}
+
 function collaborationMembers(record) {
   const ownerId = normalizeUserId(record?.ownerId);
   const explicit = normalizedMemberMap(record?.members);
@@ -107,6 +149,8 @@ function publicWorkflow(record, userId = "") {
         ? record.authority.unresolvedParticipants.map((value) => String(value || "")).filter(Boolean)
         : [],
     } : null,
+    knowledgeBindings: normalizeKnowledgeBindings(record.knowledgeBindings),
+    projectBindingCount: normalizeProjectBindings(record.projectBindings).length,
     shareActive: Boolean(record.shareToken),
     shareCreatedAt: record.shareCreatedAt || "",
     createdAt: record.createdAt || "",
@@ -232,6 +276,100 @@ export function prdWorkflowCollaborationSummary(record, userId) {
   return publicWorkflow(record, userId);
 }
 
+export function setPrdWorkflowKnowledgeBindings({ tapdId, userId, bindings = [] }) {
+  const record = getPrdWorkflowCollaborationForUser(tapdId, userId);
+  if (!record) return { error: "PRD Workflow collaboration not found", status: 404 };
+  const actorId = normalizeUserId(userId);
+  if (prdWorkflowCollaborationAccess(record, actorId).role !== "owner") {
+    return { error: "Only the Workflow owner can manage knowledge bindings", status: 403 };
+  }
+  const registry = readRegistry();
+  const stored = registry.workflows[record.id];
+  if (!stored) return { error: "PRD Workflow collaboration not found", status: 404 };
+  const now = new Date().toISOString();
+  stored.knowledgeBindings = normalizeKnowledgeBindings(bindings).map((binding) => ({
+    ...binding,
+    boundBy: actorId,
+    boundAt: binding.boundAt || now,
+  }));
+  stored.updatedAt = now;
+  writeRegistry(registry);
+  return {
+    record: stored,
+    workflow: publicWorkflow(stored, actorId),
+    knowledgeBindings: normalizeKnowledgeBindings(stored.knowledgeBindings),
+  };
+}
+
+export function listPrdWorkflowProjectBindings({ tapdId, userId }) {
+  const record = getPrdWorkflowCollaborationForUser(tapdId, userId);
+  if (!record) return { error: "PRD Workflow collaboration not found", status: 404 };
+  return {
+    record,
+    workflow: publicWorkflow(record, userId),
+    projectBindings: normalizeProjectBindings(record.projectBindings),
+  };
+}
+
+export function bindPrdWorkflowProject({ tapdId, userId, project }) {
+  const record = getPrdWorkflowCollaborationForUser(tapdId, userId);
+  if (!record) return { error: "PRD Workflow collaboration not found", status: 404 };
+  const normalized = normalizeProjectBindings([project])[0];
+  if (!normalized) return { error: "Project binding requires workspaceId and flowId", status: 400 };
+  const registry = readRegistry();
+  const stored = registry.workflows[record.id];
+  if (!stored) return { error: "PRD Workflow collaboration not found", status: 404 };
+  const actorId = normalizeUserId(userId);
+  const now = new Date().toISOString();
+  const current = normalizeProjectBindings(stored.projectBindings);
+  const existing = current.find((binding) => binding.workspaceId === normalized.workspaceId);
+  stored.projectBindings = [
+    ...current.filter((binding) => binding.workspaceId !== normalized.workspaceId),
+    {
+      ...normalized,
+      boundBy: existing?.boundBy || actorId,
+      boundAt: existing?.boundAt || now,
+    },
+  ];
+  stored.updatedAt = now;
+  writeRegistry(registry);
+  return {
+    record: stored,
+    workflow: publicWorkflow(stored, actorId),
+    projectBindings: normalizeProjectBindings(stored.projectBindings),
+    created: !existing,
+  };
+}
+
+export function unbindPrdWorkflowProject({ tapdId, userId, workspaceId }) {
+  const record = getPrdWorkflowCollaborationForUser(tapdId, userId);
+  if (!record) return { error: "PRD Workflow collaboration not found", status: 404 };
+  const id = String(workspaceId || "").trim();
+  if (!id) return { error: "Missing workspaceId", status: 400 };
+  const registry = readRegistry();
+  const stored = registry.workflows[record.id];
+  if (!stored) return { error: "PRD Workflow collaboration not found", status: 404 };
+  const current = normalizeProjectBindings(stored.projectBindings);
+  const next = current.filter((binding) => binding.workspaceId !== id);
+  if (next.length === current.length) {
+    return {
+      record: stored,
+      workflow: publicWorkflow(stored, userId),
+      projectBindings: current,
+      unchanged: true,
+    };
+  }
+  stored.projectBindings = next;
+  stored.updatedAt = new Date().toISOString();
+  writeRegistry(registry);
+  return {
+    record: stored,
+    workflow: publicWorkflow(stored, userId),
+    projectBindings: next,
+    removedWorkspaceId: id,
+  };
+}
+
 export function ensurePrdWorkflowShareLink({ tapdId, userId }) {
   const ensured = ensurePrdWorkflowCollaboration({ tapdId, userId });
   if (ensured.error) return ensured;

package/bin/lib/recent-runs.mjs

@@ -9,6 +9,21 @@ import { isApplyProcessAlive } from "./run-apply-active-lock.mjs";
 /** Web UI 调用 /api/flow/run/stop 时写入，用于与「未跑完但未标记」区分 */
 export const RUN_INTERRUPTED_FILENAME = "run-interrupted.json";
 
+function hasActiveDurableWait(runDir) {
+  const paths = [path.join(runDir, "wait-states.json"), path.join(runDir, "wait-state.json")];
+  for (const filePath of paths) {
+    if (!fs.existsSync(filePath)) continue;
+    try {
+      const parsed = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+      const waits = Array.isArray(parsed?.waits) ? parsed.waits : parsed && typeof parsed === "object" ? [parsed] : [];
+      if (waits.some((wait) => wait && (wait.status === "waiting" || wait.status === "resuming"))) return true;
+    } catch {
+      /* ignore corrupt wait files */
+    }
+  }
+  return false;
+}
+
 /** @param {string} filePath */
 function parseResultStatusFromFile(filePath) {
   try {
@@ -112,6 +127,7 @@ function inferRunStatusFromRunDir(runDir) {
 
   if (anyResult || fs.existsSync(flowJsonPath)) {
     if (isApplyProcessAlive(runDir)) return "running";
+    if (hasActiveDurableWait(runDir)) return "running";
     return "interrupted";
   }
   return "unknown";

package/bin/lib/run-node-statuses-from-disk.mjs

@@ -17,6 +17,28 @@ function parseResultStatus(filePath) {
   }
 }
 
+function readJenkinsState(runDir, instanceId) {
+  const statePath = path.join(runDir, "state", `${instanceId}.jenkins.json`);
+  if (!fs.existsSync(statePath)) return null;
+  try {
+    const parsed = JSON.parse(fs.readFileSync(statePath, "utf-8"));
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+
+function jenkinsUiStatus(executionStatus, state) {
+  if (!state) return executionStatus;
+  if (executionStatus === "pending" || state.phase === "queued" || state.phase === "running" || state.phase === "triggering") {
+    return "waiting";
+  }
+  if (executionStatus === "success" && state.phase === "complete") {
+    return String(state.status || "").toUpperCase() === "SUCCESS" ? "success" : "outcome_failed";
+  }
+  return executionStatus;
+}
+
 /** @param {string} filePath @returns {number | null} */
 function parseElapsedMsLine(filePath) {
   try {
@@ -34,7 +56,7 @@ function parseElapsedMsLine(filePath) {
  * @param {string} workspaceRoot
  * @param {string} flowName
  * @param {string} uuid
- * @returns {Record<string, { status: string, elapsed?: string }>}
+ * @returns {Record<string, { status: string, elapsed?: string, executionStatus?: string, phase?: string, jenkinsStatus?: string, message?: string, buildNumber?: string, url?: string, qrUrl?: string, startedAt?: string, wakeAt?: string }>}
  */
 export function getRunNodeStatusesFromDisk(workspaceRoot, flowName, uuid, opts = {}) {
   const runDir = getRunDir(workspaceRoot, flowName, uuid, opts);
@@ -70,9 +92,25 @@ export function getRunNodeStatusesFromDisk(workspaceRoot, flowName, uuid, opts =
     const low = String(status).toLowerCase();
     if (low === "completed" || low === "done") uiStatus = "success";
 
-    /** @type {{ status: string, elapsed?: string }} */
+    const jenkinsState = defId === "tool_jenkins_build" ? readJenkinsState(runDir, instanceId) : null;
+    if (jenkinsState) uiStatus = jenkinsUiStatus(uiStatus, jenkinsState);
+
+    /** @type {{ status: string, elapsed?: string, executionStatus?: string, phase?: string, jenkinsStatus?: string, message?: string, buildNumber?: string, url?: string, qrUrl?: string, startedAt?: string, wakeAt?: string }} */
     const row = { status: uiStatus };
-    if (uiStatus === "success" && fs.existsSync(resultPath)) {
+    if (jenkinsState) {
+      row.executionStatus = status;
+      row.phase = String(jenkinsState.phase || "");
+      row.jenkinsStatus = String(jenkinsState.status || "");
+      row.message = String(jenkinsState.message || "");
+      row.buildNumber = String(jenkinsState.buildNumber || "");
+      row.url = String(jenkinsState.url || jenkinsState.buildUrl || "");
+      row.qrUrl = String(jenkinsState.qrUrl || "");
+      row.startedAt = String(jenkinsState.startedAt || "");
+      row.wakeAt = String(jenkinsState.wakeAt || "");
+      const started = Date.parse(jenkinsState.startedAt || "");
+      const ended = Date.parse(jenkinsState.completedAt || "");
+      if (Number.isFinite(started) && Number.isFinite(ended) && ended >= started) row.elapsed = formatDuration(ended - started);
+    } else if (uiStatus === "success" && fs.existsSync(resultPath)) {
       const ms = parseElapsedMsLine(resultPath);
       if (ms != null && ms > 0) {
         row.elapsed = formatDuration(ms);

package/bin/lib/scheduler.mjs

@@ -9,7 +9,7 @@ import {
   readScheduleState,
   writeScheduleState,
 } from "./schedule-config.mjs";
-import { getAgentflowUserContexts, getRunDir, PACKAGE_ROOT } from "./paths.mjs";
+import { getAgentflowUserContexts, getFlowRuntimeRoot, getRunDir, PACKAGE_ROOT } from "./paths.mjs";
 import { isApplyProcessAlive } from "./run-apply-active-lock.mjs";
 import { log } from "./log.mjs";
 import { readMergedEnvObject } from "./user-env.mjs";
@@ -112,17 +112,28 @@ function getLatestRunUuidForFlow(workspaceRoot, flowId, opts = {}) {
   }
 }
 
-function listRunDirsForFlow(flow) {
-  const flowDir = flow.path || "";
-  const runRoot = flowDir ? path.join(flowDir, "runBuild") : "";
-  if (!runRoot || !fs.existsSync(runRoot)) return [];
-  try {
-    return fs.readdirSync(runRoot, { withFileTypes: true })
-      .filter((e) => e.isDirectory() && /^\d{14}$/.test(e.name))
-      .map((e) => ({ uuid: e.name, runDir: path.join(runRoot, e.name) }));
-  } catch {
-    return [];
+function listRunDirsForFlow(workspaceRoot, flow, opts = {}) {
+  const roots = [
+    flow.path ? path.join(flow.path, "runBuild") : "",
+    path.join(getFlowRuntimeRoot(workspaceRoot, flow.id, opts), "runBuild"),
+  ].filter(Boolean);
+  const seen = new Set();
+  const runs = [];
+  for (const runRoot of roots) {
+    const resolved = path.resolve(runRoot);
+    if (seen.has(resolved) || !fs.existsSync(resolved)) continue;
+    seen.add(resolved);
+    try {
+      for (const entry of fs.readdirSync(resolved, { withFileTypes: true })) {
+        if (entry.isDirectory() && /^\d{14}$/.test(entry.name)) {
+          runs.push({ uuid: entry.name, runDir: path.join(resolved, entry.name) });
+        }
+      }
+    } catch {
+      /* ignore unreadable run roots */
+    }
   }
+  return runs.sort((a, b) => b.uuid.localeCompare(a.uuid));
 }
 
 function readJsonObject(filePath) {
@@ -317,12 +328,23 @@ function startWaitingRunResume(workspaceRoot, flow, waitState, opts = {}) {
   const agentflowBin = path.join(PACKAGE_ROOT, "bin", "agentflow.mjs");
   const uuid = String(waitState.uuid || "");
   const instanceId = String(waitState.instanceId || "");
+  const rerunCurrentNode = waitState.resumeMode === "rerun";
+  if (rerunCurrentNode) {
+    writeResult(
+      workspaceRoot,
+      flow.id,
+      uuid,
+      instanceId,
+      { status: "cache_not_met", message: "后台任务到期，重新检查外部状态" },
+      { execId: Number(waitState.execId) || undefined, preserveBody: true, runDir: waitState.runDir },
+    );
+  }
   const args = [
     agentflowBin,
-    "resume",
+    rerunCurrentNode ? "apply" : "resume",
     flow.id,
     uuid,
-    instanceId,
+    ...(rerunCurrentNode ? [] : [instanceId]),
     "--machine-readable",
     "--workspace-root",
     path.resolve(workspaceRoot),
@@ -356,9 +378,9 @@ function startWaitingRunResume(workspaceRoot, flow, waitState, opts = {}) {
   return child;
 }
 
-function countActiveWaitsForFlow(flow) {
+function countActiveWaitsForFlow(workspaceRoot, flow, opts = {}) {
   let count = 0;
-  for (const run of listRunDirsForFlow(flow)) {
+  for (const run of listRunDirsForFlow(workspaceRoot, flow, opts)) {
     for (const waitState of readWaitStates(run.runDir)) {
       if (waitState && (waitState.status === "waiting" || waitState.status === "resuming")) count += 1;
     }
@@ -378,10 +400,10 @@ function hasNodeBranchEdge(runDir, instanceId, branchName) {
   return flow.edges.some((e) => e && e.source === instanceId && (e.sourceHandle || "output-0") === sourceHandle);
 }
 
-export function cancelScheduledRun(workspaceRoot, flowId, uuid) {
-  const flow = listFlowsJson(workspaceRoot).find((f) => f.id === flowId && !f.archived && f.source !== "builtin");
+export function cancelScheduledRun(workspaceRoot, flowId, uuid, opts = {}) {
+  const flow = listFlowsJson(workspaceRoot, opts).find((f) => f.id === flowId && !f.archived);
   if (!flow) return { ok: false, error: `flow not found: ${flowId}` };
-  const runDir = getRunDir(workspaceRoot, flow.id, uuid);
+  const runDir = getRunDir(workspaceRoot, flow.id, uuid, opts);
   if (!fs.existsSync(runDir)) return { ok: false, error: `run not found: ${flowId}/${uuid}` };
   const cancelledAt = new Date().toISOString();
   fs.writeFileSync(path.join(runDir, "cancelled.json"), JSON.stringify({ cancelled: true, cancelledAt }, null, 2) + "\n", "utf-8");
@@ -396,16 +418,22 @@ export function cancelScheduledRun(workspaceRoot, flowId, uuid) {
       instanceId &&
       hasNodeBranchEdge(runDir, instanceId, "cancelled") &&
       !resumePid;
-    if (canPropagate) {
+    const canRerunForCancellation = waitState.resumeMode === "rerun" && instanceId && !resumePid;
+    if (canRerunForCancellation) {
+      const child = startWaitingRunResume(workspaceRoot, flow, { ...waitState, uuid, runDir, branch: "cancelled" }, opts);
+      resumePid = child.pid || null;
+      writeWaitState(waitState, { status: "resuming", branch: "cancelled", cancelledAt, resumePid, resumeStartedAt: cancelledAt });
+      propagated += 1;
+    } else if (canPropagate) {
       writeResult(
         workspaceRoot,
         flow.id,
         uuid,
         instanceId,
         { status: "success", message: "已取消", branch: "cancelled" },
-        { execId: Number(waitState.execId) || undefined, preserveBody: false },
+        { execId: Number(waitState.execId) || undefined, preserveBody: false, runDir },
       );
-      const child = startWaitingRunResume(workspaceRoot, flow, { ...waitState, uuid, runDir, branch: "cancelled" });
+      const child = startWaitingRunResume(workspaceRoot, flow, { ...waitState, uuid, runDir, branch: "cancelled" }, opts);
       resumePid = child.pid || null;
       writeWaitState(waitState, { status: "resuming", branch: "cancelled", cancelledAt, resumePid, resumeStartedAt: cancelledAt });
       propagated += 1;
@@ -443,7 +471,7 @@ export function listScheduleStatuses(workspaceRoot, opts = {}) {
         ? "workspace flow is shadowed by a user flow with the same id"
         : state.lastError || "",
       running: isFlowCurrentlyRunning(workspaceRoot, flow.id, state, opts),
-      waiting: countActiveWaitsForFlow(flow),
+      waiting: countActiveWaitsForFlow(workspaceRoot, flow, opts),
     });
   }
   rows.sort((a, b) => {
@@ -463,17 +491,21 @@ export async function startScheduler(workspaceRoot, opts = {}) {
     const contexts = opts.userId ? [{ userId: opts.userId }] : getAgentflowUserContexts();
     for (const scheduleCtx of contexts) {
     for (const flow of listFlowsJson(workspaceRoot, scheduleCtx)) {
-      if (flow.archived || flow.source === "builtin") continue;
+      if (flow.archived) continue;
       const flowSource = flow.source || "user";
       let resumedWaitingRun = false;
-      for (const run of listRunDirsForFlow(flow)) {
+      for (const run of listRunDirsForFlow(workspaceRoot, flow, scheduleCtx)) {
         if (resumedWaitingRun) break;
         for (const waitState of readWaitStates(run.runDir)) {
           if (!waitState || !waitState.wakeAt || !waitState.instanceId) continue;
           if (waitState.status === "resuming" && !isFlowCurrentlyRunning(workspaceRoot, flow.id, { lastRunUuid: run.uuid }, scheduleCtx)) {
             const nodeStatus = readNodeResultStatus(run.runDir, String(waitState.instanceId));
             writeWaitState(waitState, {
-              status: nodeStatus === "pending" ? "waiting" : "resumed",
+              status:
+                nodeStatus === "pending" ||
+                (waitState.resumeMode === "rerun" && nodeStatus !== "success" && nodeStatus !== "failed")
+                  ? "waiting"
+                  : "resumed",
               reconciledAt: new Date().toISOString(),
             });
             continue;
@@ -505,6 +537,8 @@ export async function startScheduler(workspaceRoot, opts = {}) {
         }
       }
 
+      if (flow.source === "builtin") continue;
+
       const scheduleRes = readFlowSchedule(workspaceRoot, flow.id, flowSource, scheduleCtx);
       if (!scheduleRes.success) {
         log.debug(`[scheduler] ${flow.id}: ${scheduleRes.error}`);