@fieldwangai/agentflow 0.1.93 → 0.1.95

package/bin/lib/ui-server.mjs

@@ -2713,15 +2713,42 @@ function displayShareOutputUrl(shareId, baseUrl = "") {
   }
 }
 
+function normalizePublicBaseUrl(baseUrl = "") {
+  const raw = String(baseUrl || "").trim();
+  if (!raw) return "";
+  try {
+    const url = new URL(raw);
+    if (url.hostname === "0.0.0.0" || url.hostname === "::" || url.hostname === "[::]") {
+      url.hostname = "127.0.0.1";
+    }
+    return url.origin;
+  } catch {
+    return "";
+  }
+}
+
 function requestPublicBaseUrl(req) {
   const origin = String(req?.headers?.origin || "").trim();
-  if (/^https?:\/\//i.test(origin)) return origin;
+  if (/^https?:\/\//i.test(origin)) return normalizePublicBaseUrl(origin);
   const forwardedHost = String(req?.headers?.["x-forwarded-host"] || "").split(",")[0].trim();
   const host = forwardedHost || String(req?.headers?.host || "").trim();
   if (!host) return "";
   const forwardedProto = String(req?.headers?.["x-forwarded-proto"] || "").split(",")[0].trim();
   const proto = /^https?$/i.test(forwardedProto) ? forwardedProto.toLowerCase() : "http";
-  return `${proto}://${host}`;
+  return normalizePublicBaseUrl(`${proto}://${host}`);
+}
+
+function configuredPublicBaseUrl(payload = null) {
+  const envBase = normalizePublicBaseUrl(process.env.AGENTFLOW_PUBLIC_BASE_URL || process.env.AGENTFLOW_SHARE_BASE_URL || "");
+  if (envBase) return envBase;
+  const payloadBase = payload && typeof payload === "object" && !Array.isArray(payload)
+    ? normalizePublicBaseUrl(payload.publicBaseUrl || payload.public_base_url || payload.reviewBaseUrl || payload.review_base_url || "")
+    : "";
+  return payloadBase;
+}
+
+function serverPublicBaseUrl(req, host, port, payload = null) {
+  return configuredPublicBaseUrl(payload) || requestPublicBaseUrl(req) || normalizePublicBaseUrl(`http://${host}:${port}`);
 }
 
 function normalizeRunEnvKey(key) {
@@ -7046,6 +7073,11 @@ function prdWorkflowEventsPath(scopedRoot, tapdId) {
   return path.join(rootDir, ".workspace", "prd-flow", "workflow-state", `${prdWorkflowSafeStateId(tapdId)}.events.json`);
 }
 
+function prdWorkflowAuditPath(scopedRoot, tapdId) {
+  const rootDir = scopedRoot || process.cwd();
+  return path.join(rootDir, ".workspace", "prd-flow", "workflow-state", `${prdWorkflowSafeStateId(tapdId)}.audit.jsonl`);
+}
+
 function prdWorkflowReviewDir(scopedRoot, tapdId) {
   const rootDir = path.resolve(scopedRoot || process.cwd());
   return path.join(rootDir, ".workspace", "prd-flow", "reviews", prdWorkflowSafeStateId(tapdId));
@@ -7116,13 +7148,48 @@ function prdWorkflowReviewSplitFrontmatter(markdown) {
 
 function prdWorkflowReviewRenderFrontmatter(frontmatter) {
   if (!String(frontmatter || "").trim()) return "";
-  const rows = String(frontmatter || "").split(/\r?\n/)
-    .map((line) => {
-      const match = line.match(/^([^:]+):\s*(.*)$/);
-      if (!match) return `<tr><td colspan="2">${prdWorkflowReviewInlineMarkdown(line)}</td></tr>`;
-      return `<tr><th>${htmlEscapeAttribute(match[1].trim())}</th><td>${prdWorkflowReviewInlineMarkdown(match[2].trim())}</td></tr>`;
-    })
-    .join("");
+  const rows = [];
+  const lines = String(frontmatter || "").split(/\r?\n/);
+  let current = null;
+  const flush = () => {
+    if (!current) return;
+    let valueHtml = "";
+    if (current.items.length) {
+      valueHtml = `<ul class="frontmatter-list">${current.items.map((item) => `<li>${prdWorkflowReviewInlineMarkdown(item)}</li>`).join("")}</ul>`;
+    } else {
+      valueHtml = prdWorkflowReviewInlineMarkdown(current.value);
+    }
+    rows.push(`<tr><th>${htmlEscapeAttribute(current.key)}</th><td>${valueHtml}</td></tr>`);
+    current = null;
+  };
+  for (const rawLine of lines) {
+    const line = String(rawLine || "");
+    const keyValue = line.match(/^([^:\s][^:]*):\s*(.*)$/);
+    if (keyValue) {
+      flush();
+      const key = keyValue[1].trim();
+      const value = keyValue[2].trim();
+      const inlineList = value.match(/^\[(.*)\]$/);
+      current = {
+        key,
+        value: inlineList ? "" : value,
+        items: inlineList
+          ? inlineList[1].split(",").map((item) => item.trim()).filter(Boolean)
+          : [],
+      };
+      continue;
+    }
+    const listItem = line.match(/^\s*-\s+(.+)$/);
+    if (listItem && current) {
+      current.items.push(listItem[1].trim());
+      continue;
+    }
+    if (line.trim()) {
+      flush();
+      rows.push(`<tr><td colspan="2">${prdWorkflowReviewInlineMarkdown(line.trim())}</td></tr>`);
+    }
+  }
+  flush();
   return `<details class="frontmatter" open><summary>文档元数据</summary><table>${rows}</table></details>`;
 }
 
@@ -7233,6 +7300,13 @@ function prdWorkflowReviewHtml(title, markdown, meta = {}) {
     meta.issueKey ? `issue ${meta.issueKey}` : "",
     meta.createdAt || "",
   ].filter(Boolean).join(" · "));
+  const durability = String(meta.durability || "").trim().toLowerCase();
+  const lifecycle = [
+    durability === "temporary" ? "Temporary review link" : durability === "durable" ? "Durable preview" : "",
+    meta.expiresAt ? `Expires ${meta.expiresAt}` : "",
+    meta.persistence ? `persistence ${meta.persistence}` : "",
+  ].filter(Boolean).join(" · ");
+  const escapedLifecycle = htmlEscapeAttribute(lifecycle);
   const renderedMarkdown = prdWorkflowReviewMarkdownToHtml(markdown || "");
   const rawHref = htmlEscapeAttribute(meta.rawHref || "?raw=1");
   return `<!doctype html>
@@ -7294,6 +7368,7 @@ function prdWorkflowReviewHtml(title, markdown, meta = {}) {
     .toolbar { flex: 0 0 auto; display: flex; flex-wrap: wrap; justify-content: flex-end; gap: 10px; }
     .raw, .theme-toggle { border: 1px solid rgba(124,58,237,.34); border-radius: 999px; color: var(--button-text); background: var(--button); padding: 9px 14px; text-decoration: none; font-size: 13px; font-weight: 800; line-height: 1.2; }
     .theme-toggle { cursor: pointer; font-family: inherit; }
+    .lifecycle { margin-top: 10px; display: inline-flex; max-width: 100%; border: 1px solid rgba(124,58,237,.30); border-radius: 999px; background: rgba(124,58,237,.12); color: var(--button-text); padding: 6px 10px; font-size: 12px; font-weight: 800; line-height: 1.35; overflow-wrap: anywhere; }
     article { min-width: 0; border: 1px solid var(--border); border-radius: 14px; background: var(--panel); box-shadow: 0 28px 80px var(--shadow); padding: clamp(20px, 4vw, 34px); }
     article > *:first-child { margin-top: 0; }
     article > *:last-child { margin-bottom: 0; }
@@ -7319,6 +7394,7 @@ function prdWorkflowReviewHtml(title, markdown, meta = {}) {
     .frontmatter summary { cursor: pointer; color: var(--body); font-weight: 800; }
     .frontmatter table { min-width: 0; margin-top: .7rem; }
     .frontmatter th { width: min(34%, 12rem); background: var(--panel-soft); color: var(--body); }
+    .frontmatter-list { margin: 0; padding-left: 1.1rem; }
     @media (max-width: 720px) { main { padding: 28px 14px 48px; } header { display: block; } .toolbar { justify-content: flex-start; margin-top: 14px; } article { padding: 18px; } th, td { padding: .58rem .65rem; } }
   </style>
 </head>
@@ -7328,6 +7404,7 @@ function prdWorkflowReviewHtml(title, markdown, meta = {}) {
       <div>
         <h1>${escapedTitle}</h1>
         ${escapedMeta ? `<p class="meta">${escapedMeta}</p>` : ""}
+        ${escapedLifecycle ? `<p class="lifecycle">${escapedLifecycle}</p>` : ""}
       </div>
       <div class="toolbar">
         <button class="theme-toggle" type="button" data-theme-toggle>明亮模式</button>
@@ -7396,6 +7473,19 @@ function prdWorkflowCreateReview(scopedRoot, tapdId, payload = {}, urlBase = "")
   fs.writeFileSync(paths.markdownPath, content.trimEnd() + "\n", "utf-8");
   fs.writeFileSync(paths.metaPath, JSON.stringify(meta, null, 2) + "\n", "utf-8");
   prdWorkflowPruneReviews(scopedRoot, tapdId);
+  prdWorkflowAppendAudit(scopedRoot, tapdId, {
+    type: "review-created",
+    reviewId: paths.id,
+    title,
+    stage: meta.stage,
+    action: meta.action,
+    issueKey: meta.issueKey,
+    durability,
+    persistence: "runtime",
+    sourceKind: String(meta.source?.kind || ""),
+    expiresAt,
+    contentBytes: Buffer.byteLength(content, "utf-8"),
+  });
   const url = `${String(urlBase || "").replace(/\/+$/, "")}/api/prd-workflow/review/${encodeURIComponent(prdWorkflowSafeStateId(tapdId))}/${encodeURIComponent(paths.id)}`;
   return { ...meta, url, markdownPath: paths.markdownPath };
 }
@@ -7445,6 +7535,19 @@ function prdWorkflowWriteJsonFile(filePath, data) {
   return data;
 }
 
+function prdWorkflowAppendAudit(scopedRoot, tapdId, event = {}) {
+  try {
+    const p = prdWorkflowAuditPath(scopedRoot, tapdId);
+    fs.mkdirSync(path.dirname(p), { recursive: true });
+    const entry = {
+      at: new Date().toISOString(),
+      tapdId: String(tapdId || ""),
+      ...event,
+    };
+    fs.appendFileSync(p, JSON.stringify(entry) + "\n", "utf-8");
+  } catch (_) {}
+}
+
 function prdWorkflowReadProjectState(scopedRoot, tapdId) {
   return prdWorkflowReadJsonFile(prdWorkflowProjectPath(scopedRoot, tapdId), {
     version: 1,
@@ -7685,12 +7788,25 @@ function prdWorkflowMergedClientIssues(clientRows = []) {
   return out;
 }
 
+function prdWorkflowArrayCount(value) {
+  return Array.isArray(value) ? value.length : 0;
+}
+
+function prdWorkflowSnapshotActionCount(snapshot = {}) {
+  return prdWorkflowArrayCount(snapshot?.actions) +
+    prdWorkflowArrayCount(snapshot?.workflowActions) +
+    prdWorkflowArrayCount(snapshot?.workflow_actions) +
+    prdWorkflowArrayCount(snapshot?.timeline) +
+    prdWorkflowArrayCount(snapshot?.history);
+}
+
 function prdWorkflowMaterializeSnapshot(root, scopedRoot, tapdId, userCtx = {}, opts = {}) {
   const flowSource = String(opts.flowSource || "user").trim() || "user";
   const flowId = String(opts.flowId || "").trim();
   const project = prdWorkflowReadProjectStateWithFallback(root, scopedRoot, tapdId);
   const legacy = prdWorkflowReadCachedSnapshotWithFallback(root, scopedRoot, tapdId);
   const latestClient = prdWorkflowLatestClientSnapshot(root, scopedRoot, tapdId);
+  const baseSource = project?.snapshot ? "project" : latestClient ? "client-observations" : legacy?.snapshot ? "legacy-cache" : "empty";
   const base = (
     project?.snapshot ||
     latestClient ||
@@ -7716,6 +7832,45 @@ function prdWorkflowMaterializeSnapshot(root, scopedRoot, tapdId, userCtx = {},
   }));
   const clientRows = prdWorkflowClientObservationRows(root, scopedRoot, tapdId);
   const clientIssues = prdWorkflowMergedClientIssues(clientRows);
+  const runtimeState = prdWorkflowReadRuntimeEvents(scopedRoot, tapdId);
+  const projectionAudit = [
+    {
+      step: "select-base",
+      source: baseSource,
+      reason: project?.snapshot
+        ? "project materialized snapshot is available"
+        : latestClient
+          ? "no project snapshot; latest client current observation is used as display base"
+          : legacy?.snapshot
+            ? "no project/client snapshot; legacy projection cache is used"
+            : "no stored workflow projection exists",
+      projectSnapshot: Boolean(project?.snapshot),
+      latestClientSnapshot: Boolean(latestClient),
+      legacySnapshot: Boolean(legacy?.snapshot),
+      clientObservationCount: clientRows.length,
+      runtimeEventCount: runtimeState.events.length,
+      baseActionCount: prdWorkflowSnapshotActionCount(base),
+      latestClientRevision: String(latestClient?.revision || ""),
+      projectRevision: String(project?.snapshot?.revision || ""),
+    },
+    {
+      step: "merge-client-issues",
+      source: "clients",
+      applied: !project?.snapshot && clientIssues.length > 0,
+      issueCount: clientIssues.length,
+      reason: project?.snapshot
+        ? "project snapshot owns issue projection"
+        : clientIssues.length
+          ? "merged issue views from client observations"
+          : "no client issue projection available",
+    },
+    {
+      step: "merge-runtime-events",
+      source: "runtime-events",
+      eventCount: runtimeState.events.length,
+      reason: "runtime events are merged after base selection and must not replace durable facts",
+    },
+  ];
   const materialized = prdWorkflowMergeRuntimeEvents(scopedRoot, tapdId, {
     ...base,
     issues: project?.snapshot ? base.issues : clientIssues.length ? clientIssues : base.issues,
@@ -7731,6 +7886,32 @@ function prdWorkflowMaterializeSnapshot(root, scopedRoot, tapdId, userCtx = {},
       clientsUpdatedAt: prdWorkflowReadClientStateWithFallback(root, scopedRoot, tapdId).updatedAt || "",
       checkedAt: new Date().toISOString(),
     },
+    projectionAudit,
+  });
+  materialized.projectionAudit = [
+    ...projectionAudit,
+    {
+      step: "result",
+      source: "materialized",
+      phase: String(materialized.phase || ""),
+      pointer: String(materialized.pointer || ""),
+      actionCount: prdWorkflowSnapshotActionCount(materialized) + prdWorkflowArrayCount(materialized.runtimeEvents) + prdWorkflowArrayCount(materialized.runtime_events),
+      revision: String(materialized.revision || ""),
+    },
+  ];
+  prdWorkflowAppendAudit(scopedRoot, tapdId, {
+    type: "projection-materialized",
+    flowSource,
+    flowId,
+    baseSource,
+    projectSnapshot: Boolean(project?.snapshot),
+    latestClientSnapshot: Boolean(latestClient),
+    legacySnapshot: Boolean(legacy?.snapshot),
+    clientObservationCount: clientRows.length,
+    runtimeEventCount: runtimeState.events.length,
+    baseActionCount: prdWorkflowSnapshotActionCount(base),
+    resultActionCount: prdWorkflowSnapshotActionCount(materialized) + prdWorkflowArrayCount(materialized.runtimeEvents) + prdWorkflowArrayCount(materialized.runtime_events),
+    revision: String(materialized.revision || ""),
   });
   if (!project?.snapshot && latestClient) {
     materialized.optionalGaps = [
@@ -7992,13 +8173,15 @@ function prdWorkflowAppendRuntimeEvent(scopedRoot, tapdId, event = {}) {
       if (String(item?.idempotencyKey || "").trim() === entryIdem) return true;
       return Array.isArray(item?.idempotencyHistory) && item.idempotencyHistory.includes(entryIdem);
     });
+    const updatedExisting = index >= 0;
+    let artifactConflict = false;
     const events = [...current.events];
     if (index >= 0) {
       const prevArtifact = prdWorkflowRuntimeEventArtifactSignature(events[index]);
       const nextArtifact = prdWorkflowRuntimeEventArtifactSignature(entry);
-      const artifactConflict = prevArtifact && nextArtifact && prevArtifact !== nextArtifact &&
+      artifactConflict = Boolean(prevArtifact && nextArtifact && prevArtifact !== nextArtifact &&
         prdWorkflowRuntimeEventShouldConflictOnArtifact(events[index]) &&
-        prdWorkflowRuntimeEventShouldConflictOnArtifact(entry);
+        prdWorkflowRuntimeEventShouldConflictOnArtifact(entry));
       const idempotencyHistory = [
         ...(events[index].idempotencyKey ? [events[index].idempotencyKey] : []),
         ...(entry.idempotencyKey ? [entry.idempotencyKey] : []),
@@ -8033,6 +8216,26 @@ function prdWorkflowAppendRuntimeEvent(scopedRoot, tapdId, event = {}) {
       events.push(entry);
     }
     prdWorkflowWriteRuntimeEvents(scopedRoot, tapdId, events);
+    prdWorkflowAppendAudit(scopedRoot, tapdId, {
+      type: "runtime-event-stored",
+      eventId: entry.id,
+      eventType: entry.type,
+      source: entry.source,
+      scope: entry.scope || "",
+      issueKey: entry.issueKey || entry.issue_key || entry.issue || "",
+      platform: entry.platform || "",
+      stage: entry.stage || entry.stageKey || entry.stage_key || "",
+      action: entry.action || entry.actionId || entry.action_id || "",
+      status: entry.status || "",
+      truth: entry.truth || "",
+      authority: entry.authority || "",
+      persistence: entry.persistence || "",
+      idempotencyKey: entry.idempotencyKey || "",
+      updatedExisting,
+      artifactConflict,
+      eventCount: events.length,
+      note: "runtime event stored as append-only workflow event; projection may merge it into the visible timeline",
+    });
     return entry;
   } catch {
     return null;
@@ -9488,6 +9691,23 @@ export function startUiServer({
         };
         const storedObservationSnapshot = prdWorkflowStoredObservationSnapshot(normalizedSnapshot, reportSource);
         prdWorkflowWriteClientObservation(scopedRoot, tapdId, reportMeta, storedObservationSnapshot);
+        prdWorkflowAppendAudit(scopedRoot, tapdId, {
+          type: "client-observation-stored",
+          flowSource,
+          flowId,
+          clientId: reportMeta.clientId,
+          userId: reportMeta.userId,
+          observedAt: reportMeta.observedAt,
+          reportedAt: reportMeta.reportedAt,
+          phase: String(storedObservationSnapshot?.phase || ""),
+          pointer: String(storedObservationSnapshot?.pointer || ""),
+          revision: String(storedObservationSnapshot?.revision || ""),
+          actionCount: prdWorkflowSnapshotActionCount(storedObservationSnapshot),
+          truth: "observation",
+          authority: "client",
+          persistence: "runtime",
+          note: "ordinary current snapshot stored as client observation; it must not overwrite project state",
+        });
 
         const projectFactSource = reportMeta.scope === "project"
           ? prdWorkflowProjectFactSource(payload, rawSnapshot)
@@ -9546,6 +9766,20 @@ export function startUiServer({
               observedAt: reportMeta.observedAt,
             },
           });
+          prdWorkflowAppendAudit(scopedRoot, tapdId, {
+            type: "project-fact-stored",
+            flowSource,
+            flowId,
+            clientId: reportMeta.clientId,
+            observedAt: reportMeta.observedAt,
+            phase: String(projectFactSnapshot?.phase || ""),
+            pointer: String(projectFactSnapshot?.pointer || ""),
+            revision: String(projectFactSnapshot?.revision || ""),
+            actionCount: prdWorkflowSnapshotActionCount(projectFactSnapshot),
+            truth: projectFactSource.truth,
+            authority: projectFactSource.authority,
+            persistence: projectFactSource.persistence,
+          });
         }
         const materialized = prdWorkflowMaterializeSnapshot(root, scopedRoot, tapdId, userCtx, { flowSource, flowId });
         const withDiagnostic = prdWorkflowWithAgentflowTokenDiagnostic(materialized, getSessionTokenFromRequest(req) || "");
@@ -9814,7 +10048,7 @@ export function startUiServer({
             json(res, 200, result);
             return;
           }
-          const runtimeEventUrl = `http://${host}:${uiPort}/api/prd-workflow/event`;
+          const runtimeEventUrl = `${serverPublicBaseUrl(req, host, uiPort)}/api/prd-workflow/event`;
           const commandResult = await runPrdWorkflowCommand(root, scopedRoot, normalized.args, userCtx, {
             timeout: 300000,
             env: {
@@ -10105,7 +10339,7 @@ export function startUiServer({
           }
           scopedRoot = scoped.root;
         }
-        const review = prdWorkflowCreateReview(scopedRoot, tapdId, payload, `http://${host}:${uiPort}`);
+        const review = prdWorkflowCreateReview(scopedRoot, tapdId, payload, serverPublicBaseUrl(req, host, uiPort, payload));
         const query = new URLSearchParams();
         if (flowId) query.set("flowId", flowId);
         if (flowSource) query.set("flowSource", flowSource);