@fieldwangai/agentflow 0.1.113 → 0.1.115

package/bin/lib/ui-server.mjs

@@ -126,6 +126,7 @@ import {
   readRunLedgerEvents,
   runLedgerId,
 } from "./run-ledger.mjs";
+import { readAdminRunDetail } from "./admin-run-detail.mjs";
 import {
   appendWorkspaceRunLogEvent,
   createWorkspaceRunLogSession,
@@ -7723,6 +7724,78 @@ function prdWorkflowReviewPaths(scopedRoot, tapdId, reviewId) {
   };
 }
 
+function prdWorkflowReviewIndexPath(tapdId, reviewId) {
+  return path.join(
+    getAgentflowDataRoot(),
+    "prd-workflow-review-index",
+    prdWorkflowSafeStateId(tapdId),
+    `${prdWorkflowSafeStateId(reviewId)}.json`,
+  );
+}
+
+function prdWorkflowWriteReviewIndex(ownerId, tapdId, reviewId) {
+  const indexPath = prdWorkflowReviewIndexPath(tapdId, reviewId);
+  const tempPath = `${indexPath}.${process.pid}.${Date.now()}.tmp`;
+  fs.mkdirSync(path.dirname(indexPath), { recursive: true });
+  fs.writeFileSync(tempPath, JSON.stringify({
+    version: 1,
+    tapdId: String(tapdId || ""),
+    reviewId: prdWorkflowSafeStateId(reviewId),
+    ownerId: String(ownerId || "").trim(),
+    updatedAt: new Date().toISOString(),
+  }, null, 2) + "\n", "utf-8");
+  fs.renameSync(tempPath, indexPath);
+}
+
+function prdWorkflowReadReviewIndex(tapdId, reviewId) {
+  try {
+    const parsed = JSON.parse(fs.readFileSync(prdWorkflowReviewIndexPath(tapdId, reviewId), "utf-8"));
+    if (
+      String(parsed?.tapdId || "") !== String(tapdId || "")
+      || prdWorkflowSafeStateId(parsed?.reviewId) !== prdWorkflowSafeStateId(reviewId)
+    ) {
+      return null;
+    }
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+
+function prdWorkflowReviewFileExists(paths) {
+  try {
+    return fs.existsSync(paths.markdownPath) && fs.statSync(paths.markdownPath).isFile();
+  } catch {
+    return false;
+  }
+}
+
+function prdWorkflowResolveReviewPaths(scopedRoot, tapdId, reviewId) {
+  const direct = prdWorkflowReviewPaths(scopedRoot, tapdId, reviewId);
+  if (prdWorkflowReviewFileExists(direct)) return direct;
+
+  const indexed = prdWorkflowReadReviewIndex(tapdId, reviewId);
+  if (indexed) {
+    const indexedPaths = prdWorkflowReviewPaths(
+      getAgentflowUserDataRoot(indexed.ownerId || ""),
+      tapdId,
+      reviewId,
+    );
+    if (prdWorkflowReviewFileExists(indexedPaths)) return indexedPaths;
+  }
+
+  const candidateOwners = ["", ...listAgentflowUserIds()];
+  for (const ownerId of candidateOwners) {
+    const candidate = prdWorkflowReviewPaths(getAgentflowUserDataRoot(ownerId), tapdId, reviewId);
+    if (!prdWorkflowReviewFileExists(candidate)) continue;
+    try {
+      prdWorkflowWriteReviewIndex(ownerId, tapdId, reviewId);
+    } catch (_) {}
+    return candidate;
+  }
+  return direct;
+}
+
 function prdWorkflowMigrateLegacyState(legacyRoot, stateRoot, tapdId) {
   const sourceRoot = path.resolve(legacyRoot || "");
   const destinationRoot = path.resolve(stateRoot || "");
@@ -7752,6 +7825,75 @@ function prdWorkflowMigrateLegacyState(legacyRoot, stateRoot, tapdId) {
   } catch (_) {}
 }
 
+function prdWorkflowReviewShortLinkDir(root) {
+  return path.join(path.resolve(root || process.cwd()), ".workspace", "prd-flow", "review-short-links");
+}
+
+function prdWorkflowReviewShortLinkPath(root, shortCode) {
+  return path.join(
+    prdWorkflowReviewShortLinkDir(root),
+    `${String(shortCode || "").trim()}.json`,
+  );
+}
+
+function prdWorkflowReadReviewShortLink(root, shortCode) {
+  const code = String(shortCode || "").trim();
+  if (!/^[A-Za-z0-9_-]{8,32}$/.test(code)) return null;
+  try {
+    const filePath = prdWorkflowReviewShortLinkPath(root, code);
+    if (!fs.existsSync(filePath) || !fs.statSync(filePath).isFile()) return null;
+    const link = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+    const targetPath = String(link?.targetPath || "").trim();
+    if (!targetPath.startsWith("/api/prd-workflow/review/") || /[\r\n]/.test(targetPath)) return null;
+    return {
+      ...link,
+      shortCode: code,
+      targetPath,
+      filePath,
+    };
+  } catch {
+    return null;
+  }
+}
+
+function prdWorkflowCreateReviewShortLink(root, reviewUrl, review = {}) {
+  let parsed;
+  try {
+    parsed = new URL(String(reviewUrl || ""));
+  } catch {
+    return null;
+  }
+  const targetPath = `${parsed.pathname}${parsed.search}`;
+  if (!targetPath.startsWith("/api/prd-workflow/review/")) return null;
+  const digest = crypto.createHash("sha256").update(targetPath).digest("base64url");
+  const dir = prdWorkflowReviewShortLinkDir(root);
+  fs.mkdirSync(dir, { recursive: true });
+  for (let length = 8; length <= 24; length += 2) {
+    const shortCode = digest.slice(0, length);
+    const existing = prdWorkflowReadReviewShortLink(root, shortCode);
+    if (existing && existing.targetPath !== targetPath) continue;
+    const link = {
+      shortCode,
+      targetPath,
+      tapdId: String(review?.tapdId || ""),
+      reviewId: String(review?.id || ""),
+      durability: String(review?.durability || "temporary"),
+      expiresAt: String(review?.expiresAt || ""),
+      createdAt: String(review?.createdAt || new Date().toISOString()),
+    };
+    fs.writeFileSync(
+      prdWorkflowReviewShortLinkPath(root, shortCode),
+      JSON.stringify(link, null, 2) + "\n",
+      "utf-8",
+    );
+    return {
+      ...link,
+      shortUrl: `${parsed.origin}/r/${shortCode}`,
+    };
+  }
+  throw new Error("Unable to allocate a unique review short code");
+}
+
 function prdWorkflowPruneReviews(scopedRoot, tapdId, maxReviews = 200) {
   try {
     const dir = prdWorkflowReviewDir(scopedRoot, tapdId);
@@ -7772,10 +7914,12 @@ function prdWorkflowPruneReviews(scopedRoot, tapdId, maxReviews = 200) {
     for (const entry of entries.filter((item) => Number.isFinite(item.expiresMs) && item.expiresMs < now)) {
       try { fs.unlinkSync(entry.abs); } catch (_) {}
       try { fs.unlinkSync(path.join(dir, `${entry.id}.md`)); } catch (_) {}
+      try { fs.unlinkSync(prdWorkflowReviewIndexPath(tapdId, entry.id)); } catch (_) {}
     }
     for (const entry of entries.filter((item) => !(Number.isFinite(item.expiresMs) && item.expiresMs < now)).slice(maxReviews)) {
       try { fs.unlinkSync(entry.abs); } catch (_) {}
       try { fs.unlinkSync(path.join(dir, `${entry.id}.md`)); } catch (_) {}
+      try { fs.unlinkSync(prdWorkflowReviewIndexPath(tapdId, entry.id)); } catch (_) {}
     }
   } catch (_) {}
 }
@@ -7804,6 +7948,30 @@ function prdWorkflowReviewSplitFrontmatter(markdown) {
   return { frontmatter: match[1].trim(), body: text.slice(match[0].length) };
 }
 
+function prdWorkflowReviewStripLegacyMetadata(body) {
+  const lines = String(body || "").replace(/\r\n/g, "\n").split("\n");
+  const visible = [];
+  let fenced = false;
+  let hidden = false;
+  for (const line of lines) {
+    if (!hidden && /^\s*```/.test(line)) {
+      fenced = !fenced;
+      visible.push(line);
+      continue;
+    }
+    if (!fenced && !hidden && /<!--\s*prd-flow-start\b/.test(line)) {
+      hidden = !/prd-flow-end\s*-->/.test(line);
+      continue;
+    }
+    if (hidden) {
+      if (/prd-flow-end\s*-->/.test(line)) hidden = false;
+      continue;
+    }
+    visible.push(line);
+  }
+  return visible.join("\n");
+}
+
 function prdWorkflowReviewRenderFrontmatter(frontmatter) {
   if (!String(frontmatter || "").trim()) return "";
   const rows = [];
@@ -8050,20 +8218,24 @@ export function prdWorkflowReviewMarkdownToHtml(markdown) {
   const { frontmatter, body } = prdWorkflowReviewSplitFrontmatter(markdown);
   return [
     prdWorkflowReviewRenderFrontmatter(frontmatter),
-    prdWorkflowReviewBodyToHtml(body),
+    prdWorkflowReviewBodyToHtml(prdWorkflowReviewStripLegacyMetadata(body)),
   ].filter(Boolean).join("\n");
 }
 
 function prdWorkflowReviewExtractPageTitle(markdown, fallbackTitle) {
   const { frontmatter, body } = prdWorkflowReviewSplitFrontmatter(markdown);
-  const lines = String(body || "").replace(/\r\n/g, "\n").split("\n");
+  const visibleBody = prdWorkflowReviewStripLegacyMetadata(body);
+  const lines = String(visibleBody || "").replace(/\r\n/g, "\n").split("\n");
   const firstContentIndex = lines.findIndex((line) => String(line || "").trim());
   const heading = firstContentIndex >= 0
     ? String(lines[firstContentIndex] || "").trim().match(/^#\s+(.+)$/)
     : null;
   if (!heading) {
     return {
-      markdown: String(markdown || ""),
+      markdown: [
+        frontmatter ? `---\n${frontmatter}\n---` : "",
+        visibleBody,
+      ].filter(Boolean).join("\n\n"),
       title: String(fallbackTitle || "PRD Workflow Review"),
     };
   }
@@ -8275,7 +8447,7 @@ export function prdWorkflowReviewHtml(title, markdown, meta = {}) {
 </html>`;
 }
 
-function prdWorkflowCreateReview(scopedRoot, tapdId, payload = {}, urlBase = "") {
+function prdWorkflowCreateReview(scopedRoot, tapdId, payload = {}, urlBase = "", ownerId = "") {
   const content = String(payload.markdown || payload.content || payload.rawOutput || "").slice(0, 500000);
   if (!content.trim()) throw new Error("Missing review markdown");
   const title = String(payload.title || payload.label || "PRD Workflow Review").trim().slice(0, 160) || "PRD Workflow Review";
@@ -8311,6 +8483,7 @@ function prdWorkflowCreateReview(scopedRoot, tapdId, payload = {}, urlBase = "")
   fs.mkdirSync(paths.dir, { recursive: true });
   fs.writeFileSync(paths.markdownPath, content.trimEnd() + "\n", "utf-8");
   fs.writeFileSync(paths.metaPath, JSON.stringify(meta, null, 2) + "\n", "utf-8");
+  prdWorkflowWriteReviewIndex(ownerId, tapdId, paths.id);
   prdWorkflowPruneReviews(scopedRoot, tapdId);
   prdWorkflowAppendAudit(scopedRoot, tapdId, {
     type: "review-created",
@@ -10698,6 +10871,7 @@ function normalizeContextInstanceIds(raw) {
  * @param {string} opts.workspaceRoot
  * @param {number} opts.port
  * @param {boolean} [opts.hideCommunityLinks]
+ * @param {boolean} [opts.enableWorkspaceScheduler]
  * @param {string} [opts.staticDir] 默认 PACKAGE_ROOT/builtin/web-ui/dist（npm run build 产出）
  * @returns {Promise<import('http').Server>}
  */
@@ -10706,6 +10880,7 @@ export function startUiServer({
   port,
   host = "127.0.0.1",
   hideCommunityLinks = false,
+  enableWorkspaceScheduler = true,
   staticDir = path.join(PACKAGE_ROOT, "builtin", "web-ui", "dist"),
 }) {
   const root = path.resolve(workspaceRoot);
@@ -11095,7 +11270,19 @@ export function startUiServer({
           baseSnapshot,
           getSessionTokenFromRequest(req) || "",
         );
-        json(res, 200, { ok: true, snapshot });
+        const workflowShare = workflowScope.collaboration?.shareToken
+          ? prdWorkflowShareLinkSummary(
+              workflowScope.collaboration,
+              workflowScope.collaboration.shareToken,
+              serverPublicBaseUrl(req, host, uiPort),
+              userCtx.userId,
+            )
+          : null;
+        json(res, 200, {
+          ok: true,
+          snapshot,
+          ...(workflowShare ? { workflowShare, shareUrl: workflowShare.url } : {}),
+        });
       } catch (e) {
         json(res, 500, { error: (e && e.message) || String(e) });
       }
@@ -11120,6 +11307,22 @@ export function startUiServer({
           json(res, 400, { error: "Missing tapdId" });
           return;
         }
+        const rawSnapshot = payload.snapshot && typeof payload.snapshot === "object" && !Array.isArray(payload.snapshot)
+          ? payload.snapshot
+          : payload.prd || payload.next ? payload : null;
+        if (!rawSnapshot) {
+          json(res, 400, { error: "Missing snapshot" });
+          return;
+        }
+        const existingCollaboration = getPrdWorkflowCollaborationForUser(tapdId, userCtx.userId);
+        const existingAccess = prdWorkflowCollaborationAccess(existingCollaboration, userCtx.userId);
+        const shareResult = existingCollaboration && existingAccess.role !== "owner"
+          ? { record: existingCollaboration, created: false }
+          : ensurePrdWorkflowShareLink({ tapdId, userId: userCtx.userId });
+        if (shareResult.error) {
+          json(res, shareResult.status || 400, { error: shareResult.error });
+          return;
+        }
         const flowId = String(payload.flowId || "").trim();
         const flowSource = String(payload.flowSource || "user").trim() || "user";
         const archived = payload.archived === true || payload.flowArchived === true;
@@ -11136,13 +11339,6 @@ export function startUiServer({
         }
         const scopedRoot = workflowScope.stateRoot;
         prdWorkflowMigrateLegacyState(workflowScope.executionRoot, scopedRoot, tapdId);
-        const rawSnapshot = payload.snapshot && typeof payload.snapshot === "object" && !Array.isArray(payload.snapshot)
-          ? payload.snapshot
-          : payload.prd || payload.next ? payload : null;
-        if (!rawSnapshot) {
-          json(res, 400, { error: "Missing snapshot" });
-          return;
-        }
         const normalizedSnapshot = {
           ...prdWorkflowSnapshotFromParsed(scopedRoot, tapdId, rawSnapshot, userCtx, { flowSource, flowId }),
           clientReportedAt: new Date().toISOString(),
@@ -11262,8 +11458,20 @@ export function startUiServer({
         }
         const materialized = prdWorkflowMaterializeSnapshot(workflowScope.executionRoot, scopedRoot, tapdId, userCtx, { flowSource, flowId });
         const withDiagnostic = prdWorkflowWithAgentflowTokenDiagnostic(materialized, getSessionTokenFromRequest(req) || "");
+        const workflowShare = shareResult.record?.shareToken
+          ? prdWorkflowShareLinkSummary(
+              shareResult.record,
+              shareResult.record.shareToken,
+              serverPublicBaseUrl(req, host, uiPort, payload),
+              userCtx.userId,
+            )
+          : null;
         prdWorkflowBroadcast(prdWorkflowKey(userCtx, flowSource, flowId, tapdId), { type: "snapshot-report", tapdId, snapshot: withDiagnostic });
-        json(res, 200, { ok: true, snapshot: withDiagnostic });
+        json(res, 200, {
+          ok: true,
+          snapshot: withDiagnostic,
+          ...(workflowShare ? { workflowShare, shareUrl: workflowShare.url } : {}),
+        });
       } catch (e) {
         json(res, 500, { error: (e && e.message) || String(e) });
       }
@@ -11966,8 +12174,26 @@ export function startUiServer({
         }
         const scopedRoot = workflowScope.stateRoot;
         prdWorkflowMigrateLegacyState(workflowScope.executionRoot, scopedRoot, tapdId);
-        const review = prdWorkflowCreateReview(scopedRoot, tapdId, payload, serverPublicBaseUrl(req, host, uiPort, payload));
-        const reviewUrl = review.url;
+        const review = prdWorkflowCreateReview(
+          scopedRoot,
+          tapdId,
+          payload,
+          serverPublicBaseUrl(req, host, uiPort, payload),
+          workflowScope.ownerId,
+        );
+        const query = new URLSearchParams();
+        if (flowId) query.set("flowId", flowId);
+        if (flowId && flowSource && flowSource !== "user") query.set("flowSource", flowSource);
+        if (archived) query.set("archived", "1");
+        const reviewUrl = query.toString() ? `${review.url}?${query.toString()}` : review.url;
+        let shortLink = null;
+        try {
+          shortLink = prdWorkflowCreateReviewShortLink(root, reviewUrl, review);
+        } catch (e) {
+          log.debug(`[prd-workflow] review short link failed: ${(e && e.message) || String(e)}`);
+        }
+        const shortUrl = shortLink?.shortUrl || "";
+        const displayUrl = shortUrl || reviewUrl;
         const durability = review.durability || "temporary";
         const reviewSource = review.source && typeof review.source === "object" && !Array.isArray(review.source)
           ? review.source
@@ -11979,7 +12205,9 @@ export function startUiServer({
           durability,
           source: reviewSource,
           confirmed: payload.confirmed === true || payload.confirmed === "1",
-          url: reviewUrl,
+          url: displayUrl,
+          canonicalUrl: reviewUrl,
+          shortUrl,
           expiresAt: review.expiresAt || "",
         };
         const event = prdWorkflowAppendRuntimeEvent(scopedRoot, tapdId, {
@@ -11998,15 +12226,35 @@ export function startUiServer({
           sourceArtifact: reviewSource,
           expiresAt: review.expiresAt || "",
           artifacts: [artifact],
-          links: [{ label: "Markdown Review", url: reviewUrl, persistence: "runtime", durability, source: reviewSource, expiresAt: review.expiresAt || "" }],
+          links: [{
+            label: "Markdown Review",
+            url: displayUrl,
+            canonicalUrl: reviewUrl,
+            shortUrl,
+            persistence: "runtime",
+            durability,
+            source: reviewSource,
+            expiresAt: review.expiresAt || "",
+          }],
           reviewId: review.id,
+          reviewShortCode: shortLink?.shortCode || "",
         });
         const snapshot = prdWorkflowWithAgentflowTokenDiagnostic(
           await prdWorkflowSnapshot(workflowScope.executionRoot, scopedRoot, tapdId, userCtx, { flowSource, flowId }),
           getSessionTokenFromRequest(req) || "",
         );
         prdWorkflowBroadcast(prdWorkflowKey(userCtx, flowSource, flowId, tapdId), { type: "review-link", tapdId, event, snapshot });
-        json(res, 200, { ok: true, review: { ...review, url: reviewUrl }, event, snapshot });
+        json(res, 200, {
+          ok: true,
+          review: {
+            ...review,
+            url: reviewUrl,
+            shortUrl,
+            shortCode: shortLink?.shortCode || "",
+          },
+          event,
+          snapshot,
+        });
       } catch (e) {
         json(res, 500, { error: (e && e.message) || String(e) });
       }
@@ -12053,6 +12301,41 @@ export function startUiServer({
       return;
     }
 
+    if (req.method === "GET" && url.pathname.startsWith("/r/")) {
+      try {
+        const parts = url.pathname.split("/").filter(Boolean);
+        const shortCode = decodeURIComponent(parts[1] || "");
+        if (parts.length !== 2) {
+          res.writeHead(404);
+          res.end("Not found");
+          return;
+        }
+        const link = prdWorkflowReadReviewShortLink(root, shortCode);
+        if (!link) {
+          res.writeHead(404);
+          res.end("Not found");
+          return;
+        }
+        const expiresMs = Date.parse(link.expiresAt || "");
+        if (Number.isFinite(expiresMs) && expiresMs < Date.now()) {
+          try { fs.unlinkSync(link.filePath); } catch (_) {}
+          res.writeHead(410, { "Content-Type": "text/plain; charset=utf-8" });
+          res.end("Review link expired");
+          return;
+        }
+        res.writeHead(302, {
+          Location: link.targetPath,
+          "Cache-Control": "no-store",
+          "Referrer-Policy": "no-referrer",
+        });
+        res.end();
+      } catch {
+        res.writeHead(404);
+        res.end("Not found");
+      }
+      return;
+    }
+
     if (req.method === "GET" && url.pathname.startsWith("/api/prd-workflow/review/")) {
       try {
         const parts = url.pathname.split("/").filter(Boolean);
@@ -12081,8 +12364,8 @@ export function startUiServer({
         }
         const scopedRoot = workflowScope.stateRoot;
         prdWorkflowMigrateLegacyState(workflowScope.executionRoot, scopedRoot, tapdId);
-        const paths = prdWorkflowReviewPaths(scopedRoot, tapdId, reviewId);
-        if (!fs.existsSync(paths.markdownPath) || !fs.statSync(paths.markdownPath).isFile()) {
+        const paths = prdWorkflowResolveReviewPaths(scopedRoot, tapdId, reviewId);
+        if (!prdWorkflowReviewFileExists(paths)) {
           res.writeHead(404);
           res.end("Not found");
           return;
@@ -12364,6 +12647,35 @@ export function startUiServer({
       return;
     }
 
+    if (req.method === "GET" && url.pathname === "/api/admin/run-detail") {
+      if (!authUser?.isAdmin) {
+        json(res, 403, { error: "Admin permission required" });
+        return;
+      }
+      const input = {
+        runType: url.searchParams.get("runType") || "pipeline",
+        userId: url.searchParams.get("userId") || "",
+        flowId: url.searchParams.get("flowId") || "",
+        flowSource: url.searchParams.get("flowSource") || "user",
+        runId: url.searchParams.get("runId") || "",
+      };
+      if (!input.userId || !input.flowId || !input.runId) {
+        json(res, 400, { error: "Missing userId, flowId or runId" });
+        return;
+      }
+      try {
+        const detail = readAdminRunDetail(root, input);
+        if (!detail) {
+          json(res, 404, { error: "Run detail not found" });
+          return;
+        }
+        json(res, 200, detail);
+      } catch (e) {
+        json(res, 500, { error: (e && e.message) || String(e) });
+      }
+      return;
+    }
+
     if (url.pathname === "/api/admin/user-allowlist") {
       if (!authUser?.isAdmin) {
         json(res, 403, { error: "Admin permission required" });
@@ -16639,24 +16951,26 @@ finishedAt: "${new Date().toISOString()}"
     res.end(data);
   });
 
-  const workspaceScheduleTimer = setInterval(() => {
-    try {
-      pollWorkspaceSchedules(root);
-    } catch (e) {
-      log.debug(`[workspace-scheduler] poll failed: ${(e && e.message) || String(e)}`);
-    }
-  }, WORKSPACE_SCHEDULE_POLL_MS);
-  try {
-    workspaceScheduleTimer.unref?.();
-  } catch (_) {}
-  server.on("close", () => clearInterval(workspaceScheduleTimer));
-  setTimeout(() => {
+  if (enableWorkspaceScheduler) {
+    const workspaceScheduleTimer = setInterval(() => {
+      try {
+        pollWorkspaceSchedules(root);
+      } catch (e) {
+        log.debug(`[workspace-scheduler] poll failed: ${(e && e.message) || String(e)}`);
+      }
+    }, WORKSPACE_SCHEDULE_POLL_MS);
     try {
-      pollWorkspaceSchedules(root);
-    } catch (e) {
-      log.debug(`[workspace-scheduler] initial poll failed: ${(e && e.message) || String(e)}`);
-    }
-  }, 1000).unref?.();
+      workspaceScheduleTimer.unref?.();
+    } catch (_) {}
+    server.on("close", () => clearInterval(workspaceScheduleTimer));
+    setTimeout(() => {
+      try {
+        pollWorkspaceSchedules(root);
+      } catch (e) {
+        log.debug(`[workspace-scheduler] initial poll failed: ${(e && e.message) || String(e)}`);
+      }
+    }, 1000).unref?.();
+  }
 
   return new Promise((resolve, reject) => {
     server.once("error", reject);