plugin-git-manager 1.1.10 → 1.2.0

package/dist/server/actions/review.d.ts

@@ -1,5 +1,6 @@
 import { Context } from '@nocobase/actions';
 import type { Application } from '@nocobase/server';
+export declare const WORKER_JOB_GIT_REVIEW_PROCESS = "git-review:process";
 interface TriggerArgs {
     flowId?: number | null;
     repositoryId: number;
@@ -14,8 +15,8 @@ interface TriggerArgs {
 }
 /**
  * Trigger an AI-driven code review for an MR / commit / branch.
- * The review record is upserted synchronously, then AIEmployee.invoke runs in
- * the background. The action returns immediately with the reviewId.
+ * The review record is upserted synchronously, then queued for an available
+ * git-review worker. The action returns immediately with the reviewId.
  */
 export declare function triggerReview(ctx: Context, next: () => Promise<void>): Promise<void>;
 /**
@@ -23,6 +24,8 @@ export declare function triggerReview(ctx: Context, next: () => Promise<void>):
  * Returns the reviewId of the upserted record.
  */
 export declare function triggerReviewInternal(app: Application, args: TriggerArgs): Promise<number>;
+export declare function registerReviewQueue(app: Application): void;
+export declare function unregisterReviewQueue(app: Application): void;
 /**
  * Mark a review as approved and post its content to GitLab as an MR note.
  */

package/dist/server/actions/review.js

@@ -1,12 +1,3 @@
-/**
- * This file is part of the NocoBase (R) project.
- * Copyright (c) 2020-2024 NocoBase Co., Ltd.
- * Authors: NocoBase Team.
- *
- * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
- * For more information, please refer to: https://www.nocobase.com/agreement.
- */
-
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
@@ -26,17 +17,41 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var review_exports = {};
 __export(review_exports, {
+  WORKER_JOB_GIT_REVIEW_PROCESS: () => WORKER_JOB_GIT_REVIEW_PROCESS,
   branchMatches: () => branchMatches,
   pickFlowMatchingBranch: () => pickFlowMatchingBranch,
   recoverStuckReviews: () => recoverStuckReviews,
+  registerReviewQueue: () => registerReviewQueue,
   reviewApprovePost: () => reviewApprovePost,
   reviewReject: () => reviewReject,
   triggerReview: () => triggerReview,
-  triggerReviewInternal: () => triggerReviewInternal
+  triggerReviewInternal: () => triggerReviewInternal,
+  unregisterReviewQueue: () => unregisterReviewQueue
 });
 module.exports = __toCommonJS(review_exports);
 var import_gitlab_url = require("../utils/gitlab-url");
 var import_redact = require("../utils/redact");
+const WORKER_JOB_GIT_REVIEW_PROCESS = "git-review:process";
+const REVIEW_QUEUE_CHANNEL = "plugin-git-manager.review";
+const REVIEW_QUEUE_CONCURRENCY = Math.max(
+  1,
+  Number.parseInt(process.env.GIT_REVIEW_QUEUE_CONCURRENCY || process.env.GIT_REVIEW_MAX_CONCURRENCY || "3", 10) || 3
+);
+const REVIEW_QUEUE_TIMEOUT_MS = Math.max(
+  6e4,
+  Number.parseInt(process.env.GIT_REVIEW_QUEUE_TIMEOUT_MS || "", 10) || 10 * 60 * 1e3
+);
+const REVIEW_QUEUE_POLL_INTERVAL_MS = Math.max(
+  1e3,
+  Number.parseInt(process.env.GIT_REVIEW_QUEUE_POLL_INTERVAL_MS || "", 10) || 5e3
+);
+const REVIEW_PROCESS_LOCK_TTL_MS = Math.max(REVIEW_QUEUE_TIMEOUT_MS + 6e4, 11 * 60 * 1e3);
+const REVIEW_QUEUE_WAKE_CHANNEL = "plugin-git-manager.review.wake";
+const REVIEW_QUEUE_REDIS_CONNECTION = "plugin-git-manager.review.queue";
+let reviewQueueTimer = null;
+let reviewQueueKickTimer = null;
+let reviewQueueProcessing = false;
+let reviewWakeHandler = null;
 function getActionParams(ctx) {
   var _a, _b;
   return { ...ctx.action.params, ...(_a = ctx.action.params) == null ? void 0 : _a.values, ...((_b = ctx.request) == null ? void 0 : _b.body) || {} };
@@ -54,15 +69,7 @@ async function withTriggerLock(app, key, fn) {
 async function triggerReview(ctx, next) {
   var _a, _b;
   const params = getActionParams(ctx);
-  const {
-    flowId,
-    repositoryId,
-    targetType,
-    mrIid,
-    commitSha,
-    branch,
-    extraInstructions
-  } = params;
+  const { flowId, repositoryId, targetType, mrIid, commitSha, branch, extraInstructions } = params;
   if (!repositoryId) ctx.throw(400, "repositoryId is required");
   if (!targetType) ctx.throw(400, "targetType is required");
   if (!["mr", "commit", "branch"].includes(targetType)) ctx.throw(400, "invalid targetType");
@@ -142,14 +149,20 @@ async function triggerReviewInternalLocked(app, args) {
     latestSha: headSha || existingLatestSha || null,
     triggeredBy: args.triggeredBy || "manual",
     status: "pending",
-    // Stamp startedAt synchronously so `recoverStuckReviews` can sweep rows
-    // that get stuck in `pending` (process died before runReview ran).
-    // runReview's own update will refresh this on actual start.
-    startedAt: /* @__PURE__ */ new Date(),
+    // `startedAt` is stamped by the queue worker when execution actually
+    // starts. Pending rows are durable queue items for worker polling.
+    startedAt: null,
     finishedAt: null,
     durationMs: null,
-    postStatus: flow.get("postMode") === "disabled" ? "skipped" : "pending_approval",
-    error: null
+    postStatus: getInitialPostStatus(flow, args.targetType),
+    error: null,
+    metadata: {
+      queuedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      aiEmployeeUsername,
+      extraInstructions: args.extraInstructions || null,
+      userId: args.userId ?? null,
+      flowSnapshot: createFlowSnapshot(flow)
+    }
   };
   let reviewId;
   if (existing) {
@@ -166,26 +179,343 @@ async function triggerReviewInternalLocked(app, args) {
     const review = await reviewsRepo.create({ values: baseValues });
     reviewId = review.get("id");
   }
-  setImmediate(
-    () => runReview(app, {
-      reviewId,
-      flow,
-      repo,
-      targetType: args.targetType,
-      mrIid: args.targetType === "mr" ? args.mrIid : null,
-      commitSha: args.targetType === "commit" ? args.commitSha : null,
-      branch: args.branch || void 0,
-      headSha,
-      aiEmployeeUsername,
-      extraInstructions: args.extraInstructions,
-      userId: args.userId ?? null
-    }).catch((err) => {
-      var _a, _b;
-      (_b = (_a = app.log) == null ? void 0 : _a.error) == null ? void 0 : _b.call(_a, "runReview background error", err);
-    })
-  );
+  await enqueueReview(app, {
+    reviewId,
+    repositoryId: args.repositoryId,
+    targetType: args.targetType,
+    mrIid: args.targetType === "mr" ? args.mrIid : null,
+    commitSha: args.targetType === "commit" ? args.commitSha : null,
+    branch: args.branch || void 0,
+    headSha,
+    aiEmployeeUsername,
+    extraInstructions: args.extraInstructions,
+    userId: args.userId ?? null,
+    flowSnapshot: createFlowSnapshot(flow)
+  });
   return reviewId;
 }
+function registerReviewQueue(app) {
+  app.eventQueue.subscribe(REVIEW_QUEUE_CHANNEL, {
+    concurrency: REVIEW_QUEUE_CONCURRENCY,
+    idle: () => isGitReviewWorker(app),
+    process: async (message) => {
+      await processQueuedReview(app, message);
+    }
+  });
+  if (!isGitReviewWorker(app)) {
+    app.on("afterStart", () => clearLocalReviewMemoryQueue(app));
+  }
+  startReviewQueueProcessor(app);
+}
+function unregisterReviewQueue(app) {
+  app.eventQueue.unsubscribe(REVIEW_QUEUE_CHANNEL);
+  stopReviewQueueProcessor(app);
+}
+function createFlowSnapshot(flow) {
+  return {
+    id: Number(flow.get("id")),
+    name: flow.get("name"),
+    postMode: flow.get("postMode"),
+    llmService: flow.get("llmService"),
+    model: flow.get("model"),
+    instructions: flow.get("instructions")
+  };
+}
+function createFlowFromSnapshot(snapshot, fallback) {
+  return {
+    get(name) {
+      var _a;
+      if (snapshot && Object.prototype.hasOwnProperty.call(snapshot, name)) {
+        return snapshot[name];
+      }
+      return (_a = fallback == null ? void 0 : fallback.get) == null ? void 0 : _a.call(fallback, name);
+    }
+  };
+}
+function isGitReviewWorker(app) {
+  const workerMode = process.env.WORKER_MODE || "";
+  return app.serving(WORKER_JOB_GIT_REVIEW_PROCESS) || workerMode === "worker" || workerMode === "task" || process.env.APP_ROLE === "worker";
+}
+function clearLocalReviewMemoryQueue(app) {
+  var _a, _b, _c, _d, _e;
+  const eventQueue = app.eventQueue;
+  const adapter = eventQueue == null ? void 0 : eventQueue.adapter;
+  const fullChannel = (_a = eventQueue == null ? void 0 : eventQueue.getFullChannel) == null ? void 0 : _a.call(eventQueue, REVIEW_QUEUE_CHANNEL);
+  const queue = fullChannel ? (_c = (_b = adapter == null ? void 0 : adapter.queues) == null ? void 0 : _b.get) == null ? void 0 : _c.call(_b, fullChannel) : null;
+  if (!(queue == null ? void 0 : queue.length)) return;
+  adapter.queues.set(fullChannel, []);
+  (_e = (_d = app.log) == null ? void 0 : _d.warn) == null ? void 0 : _e.call(
+    _d,
+    `git review queue: cleared ${queue.length} stale local memory message(s) on non-worker node; pending DB rows will be picked up by workers`
+  );
+}
+function getReviewQueueRedisKey(app) {
+  const appName = app.name || process.env.APP_NAME || "main";
+  return `${appName}:plugin-git-manager:review:queue`;
+}
+async function getReviewQueueRedis(app) {
+  var _a, _b;
+  const manager = app.redisConnectionManager;
+  if (!(manager == null ? void 0 : manager.getConnectionSync)) {
+    return null;
+  }
+  try {
+    const connectionString = process.env.QUEUE_ADAPTER_REDIS_URL || process.env.REDIS_URL;
+    return await manager.getConnectionSync(
+      REVIEW_QUEUE_REDIS_CONNECTION,
+      connectionString ? { connectionString } : void 0
+    );
+  } catch (err) {
+    (_b = (_a = app.log) == null ? void 0 : _a.debug) == null ? void 0 : _b.call(_a, `git review queue: Redis queue unavailable, falling back to DB polling: ${(err == null ? void 0 : err.message) || err}`);
+    return null;
+  }
+}
+async function enqueueReviewToRedis(app, message) {
+  var _a, _b;
+  const redis = await getReviewQueueRedis(app);
+  if (!redis) return false;
+  await redis.sendCommand(["RPUSH", getReviewQueueRedisKey(app), JSON.stringify(message)]);
+  (_b = (_a = app.log) == null ? void 0 : _a.debug) == null ? void 0 : _b.call(_a, `git review queue: enqueued review ${message.reviewId} to Redis`);
+  return true;
+}
+async function publishReviewQueueWake(app, reviewId) {
+  var _a, _b, _c, _d;
+  try {
+    await ((_b = (_a = app.pubSubManager) == null ? void 0 : _a.publish) == null ? void 0 : _b.call(
+      _a,
+      REVIEW_QUEUE_WAKE_CHANNEL,
+      { reviewId },
+      { skipSelf: !isGitReviewWorker(app) }
+    ));
+  } catch (err) {
+    (_d = (_c = app.log) == null ? void 0 : _c.debug) == null ? void 0 : _d.call(_c, `git review queue: wake publish skipped: ${(err == null ? void 0 : err.message) || err}`);
+  }
+}
+function startReviewQueueProcessor(app) {
+  var _a, _b, _c, _d, _e, _f, _g;
+  if (!isGitReviewWorker(app)) {
+    (_b = (_a = app.log) == null ? void 0 : _a.debug) == null ? void 0 : _b.call(_a, "plugin-git-manager: review queue processor disabled on non-worker node");
+    return;
+  }
+  if (reviewQueueTimer) return;
+  reviewWakeHandler = async () => {
+    scheduleReviewQueueTick(app, 0);
+  };
+  const subscribe = (_d = (_c = app.pubSubManager) == null ? void 0 : _c.subscribe) == null ? void 0 : _d.call(_c, REVIEW_QUEUE_WAKE_CHANNEL, reviewWakeHandler);
+  if (subscribe == null ? void 0 : subscribe.catch) {
+    subscribe.catch((err) => {
+      var _a2, _b2;
+      return (_b2 = (_a2 = app.log) == null ? void 0 : _a2.debug) == null ? void 0 : _b2.call(_a2, `git review queue: wake subscribe skipped: ${(err == null ? void 0 : err.message) || err}`);
+    });
+  }
+  reviewQueueTimer = setInterval(() => scheduleReviewQueueTick(app, 0), REVIEW_QUEUE_POLL_INTERVAL_MS);
+  (_e = reviewQueueTimer.unref) == null ? void 0 : _e.call(reviewQueueTimer);
+  scheduleReviewQueueTick(app, 1e3);
+  (_g = (_f = app.log) == null ? void 0 : _f.info) == null ? void 0 : _g.call(_f, `plugin-git-manager: review queue processor started (interval ${REVIEW_QUEUE_POLL_INTERVAL_MS}ms)`);
+}
+function stopReviewQueueProcessor(app) {
+  var _a, _b;
+  if (reviewQueueTimer) {
+    clearInterval(reviewQueueTimer);
+    reviewQueueTimer = null;
+  }
+  if (reviewQueueKickTimer) {
+    clearTimeout(reviewQueueKickTimer);
+    reviewQueueKickTimer = null;
+  }
+  if (reviewWakeHandler) {
+    const unsubscribe = (_b = (_a = app.pubSubManager) == null ? void 0 : _a.unsubscribe) == null ? void 0 : _b.call(_a, REVIEW_QUEUE_WAKE_CHANNEL, reviewWakeHandler);
+    if (unsubscribe == null ? void 0 : unsubscribe.catch) {
+      unsubscribe.catch(() => void 0);
+    }
+    reviewWakeHandler = null;
+  }
+  reviewQueueProcessing = false;
+}
+function scheduleReviewQueueTick(app, delayMs) {
+  var _a;
+  if (reviewQueueKickTimer) return;
+  reviewQueueKickTimer = setTimeout(() => {
+    reviewQueueKickTimer = null;
+    runReviewQueueTick(app).catch((err) => {
+      var _a2, _b;
+      return (_b = (_a2 = app.log) == null ? void 0 : _a2.error) == null ? void 0 : _b.call(_a2, "git review queue: processor tick failed", err);
+    });
+  }, delayMs);
+  (_a = reviewQueueKickTimer.unref) == null ? void 0 : _a.call(reviewQueueKickTimer);
+}
+async function runReviewQueueTick(app) {
+  if (reviewQueueProcessing || !isGitReviewWorker(app)) return;
+  reviewQueueProcessing = true;
+  try {
+    const redisMessages = await drainRedisReviewQueue(app, REVIEW_QUEUE_CONCURRENCY);
+    await processReviewQueueMessages(app, redisMessages);
+    const remaining = Math.max(1, REVIEW_QUEUE_CONCURRENCY - redisMessages.length);
+    await processPendingReviews(app, remaining);
+  } finally {
+    reviewQueueProcessing = false;
+  }
+}
+async function drainRedisReviewQueue(app, count) {
+  var _a, _b;
+  const redis = await getReviewQueueRedis(app);
+  if (!redis) return [];
+  const key = getReviewQueueRedisKey(app);
+  const messages = [];
+  for (let i = 0; i < count; i += 1) {
+    const raw = await redis.sendCommand(["LPOP", key]);
+    if (!raw) break;
+    try {
+      messages.push(JSON.parse(String(raw)));
+    } catch (err) {
+      (_b = (_a = app.log) == null ? void 0 : _a.warn) == null ? void 0 : _b.call(_a, `git review queue: dropped invalid Redis message: ${(err == null ? void 0 : err.message) || err}`);
+    }
+  }
+  return messages;
+}
+function getQueuedReviewMetadata(review) {
+  var _a;
+  const raw = (_a = review == null ? void 0 : review.get) == null ? void 0 : _a.call(review, "metadata");
+  if (!raw) return {};
+  if (typeof raw === "string") {
+    try {
+      return JSON.parse(raw) || {};
+    } catch {
+      return {};
+    }
+  }
+  return typeof raw === "object" ? raw : {};
+}
+function toNullableNumber(value) {
+  if (value === null || value === void 0 || value === "") return null;
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? parsed : null;
+}
+function createReviewQueueMessageFromReview(review) {
+  const metadata = getQueuedReviewMetadata(review);
+  const targetType = review.get("targetType");
+  return {
+    reviewId: Number(review.get("id")),
+    repositoryId: Number(review.get("repositoryId")),
+    targetType,
+    mrIid: targetType === "mr" ? toNullableNumber(review.get("mrIid")) : null,
+    commitSha: targetType === "commit" ? review.get("commitSha") : null,
+    branch: targetType === "branch" ? review.get("branch") : null,
+    headSha: review.get("headSha"),
+    aiEmployeeUsername: metadata.aiEmployeeUsername || "",
+    extraInstructions: metadata.extraInstructions || void 0,
+    userId: metadata.userId ?? null,
+    flowSnapshot: metadata.flowSnapshot
+  };
+}
+async function processPendingReviews(app, count) {
+  const pending = await app.db.getRepository("gitCodeReviews").find({
+    filter: { status: "pending" },
+    sort: ["createdAt"],
+    limit: count
+  });
+  if (!(pending == null ? void 0 : pending.length)) return;
+  await processReviewQueueMessages(app, pending.map(createReviewQueueMessageFromReview));
+}
+async function processReviewQueueMessages(app, messages) {
+  if (!messages.length) return;
+  await Promise.all(messages.map((message) => processQueuedReview(app, message)));
+}
+async function withReviewProcessLock(app, reviewId, fn) {
+  const lockKey = `git-review:process:${reviewId}`;
+  return app.lockManager.runExclusive(lockKey, fn, REVIEW_PROCESS_LOCK_TTL_MS);
+}
+async function enqueueReview(app, message) {
+  var _a, _b;
+  try {
+    const queuedInRedis = await enqueueReviewToRedis(app, message);
+    if (queuedInRedis) {
+      await publishReviewQueueWake(app, message.reviewId);
+      return;
+    }
+    await publishReviewQueueWake(app, message.reviewId);
+    if (isGitReviewWorker(app)) {
+      await app.eventQueue.publish(REVIEW_QUEUE_CHANNEL, message, {
+        timeout: REVIEW_QUEUE_TIMEOUT_MS,
+        maxRetries: 1
+      });
+      return;
+    }
+    (_b = (_a = app.log) == null ? void 0 : _a.warn) == null ? void 0 : _b.call(
+      _a,
+      `git review queue: Redis queue is unavailable; review ${message.reviewId} will remain pending until a worker DB poller picks it up`
+    );
+  } catch (err) {
+    const safeMessage = (0, import_redact.redactPat)((err == null ? void 0 : err.message) || String(err));
+    await app.db.getRepository("gitCodeReviews").update({
+      filterByTk: message.reviewId,
+      values: {
+        status: "failed",
+        error: `Failed to enqueue review: ${safeMessage}`,
+        finishedAt: /* @__PURE__ */ new Date()
+      }
+    });
+    throw err;
+  }
+}
+async function failQueuedReview(app, reviewId, err) {
+  const safeMessage = (0, import_redact.redactPat)((err == null ? void 0 : err.message) || String(err));
+  await app.db.getRepository("gitCodeReviews").update({
+    filterByTk: reviewId,
+    values: {
+      status: "failed",
+      error: safeMessage,
+      finishedAt: /* @__PURE__ */ new Date()
+    }
+  });
+}
+async function processQueuedReview(app, message) {
+  await withReviewProcessLock(app, message.reviewId, async () => {
+    var _a, _b, _c, _d, _e, _f;
+    const db = app.db;
+    const reviewsRepo = db.getRepository("gitCodeReviews");
+    const review = await reviewsRepo.findOne({ filterByTk: message.reviewId });
+    if (!review) {
+      (_b = (_a = app.log) == null ? void 0 : _a.warn) == null ? void 0 : _b.call(_a, `git review queue: review ${message.reviewId} not found, skipping`);
+      return;
+    }
+    if (review.get("status") !== "pending") {
+      (_d = (_c = app.log) == null ? void 0 : _c.info) == null ? void 0 : _d.call(_c, `git review queue: review ${message.reviewId} is ${review.get("status")}, skipping`);
+      return;
+    }
+    const metadata = getQueuedReviewMetadata(review);
+    const targetType = message.targetType || review.get("targetType");
+    try {
+      const repo = await db.getRepository("gitRepositories").findOne({
+        filterByTk: message.repositoryId || review.get("repositoryId")
+      });
+      if (!repo) throw new Error("Repository not found");
+      const flowSnapshot = message.flowSnapshot || metadata.flowSnapshot;
+      const storedFlow = await db.getRepository("gitReviewFlows").findOne({
+        filterByTk: (flowSnapshot == null ? void 0 : flowSnapshot.id) || review.get("flowId")
+      });
+      const flow = createFlowFromSnapshot(flowSnapshot, storedFlow);
+      const aiEmployeeUsername = message.aiEmployeeUsername || metadata.aiEmployeeUsername || flow.get("aiEmployeeUsername");
+      if (!aiEmployeeUsername) throw new Error("Flow has no AI employee configured");
+      await runReview(app, {
+        reviewId: message.reviewId,
+        flow,
+        repo,
+        targetType,
+        mrIid: targetType === "mr" ? message.mrIid ?? toNullableNumber(review.get("mrIid")) : null,
+        commitSha: targetType === "commit" ? message.commitSha || review.get("commitSha") : null,
+        branch: message.branch || review.get("branch"),
+        headSha: message.headSha || review.get("headSha"),
+        aiEmployeeUsername,
+        extraInstructions: message.extraInstructions ?? metadata.extraInstructions ?? void 0,
+        userId: message.userId ?? metadata.userId ?? null
+      });
+    } catch (err) {
+      (_f = (_e = app.log) == null ? void 0 : _e.error) == null ? void 0 : _f.call(_e, "git review queue: failed before review execution", err);
+      await failQueuedReview(app, message.reviewId, err);
+    }
+  });
+}
 async function reviewApprovePost(ctx, next) {
   var _a, _b;
   const params = getActionParams(ctx);
@@ -211,7 +541,8 @@ async function reviewApprovePost(ctx, next) {
       postStatus: "posted",
       postedNoteId: String(noteId),
       approvedBy: userId ? String(userId) : null,
-      approvedAt: /* @__PURE__ */ new Date()
+      approvedAt: /* @__PURE__ */ new Date(),
+      error: null
     }
   });
   ctx.body = { success: true, data: { reviewId, postedNoteId: noteId } };
@@ -323,7 +654,8 @@ async function runReview(app, args) {
       } catch {
       }
     }
-    if (!AIEmployee) throw new Error("AIEmployee class not found \u2014 plugin-ai may not be installed or its exports changed");
+    if (!AIEmployee)
+      throw new Error("AIEmployee class not found \u2014 plugin-ai may not be installed or its exports changed");
     const llmService = args.flow.get("llmService");
     const model = args.flow.get("model");
     const modelRef = llmService && model ? { llmService, model } : void 0;
@@ -348,7 +680,7 @@ async function runReview(app, args) {
         ]
       }),
       new Promise(
-        (_, reject) => setTimeout(() => reject(new Error("AI review timed out after 5 minutes")), REVIEW_TIMEOUT_MS)
+        (_resolve, reject) => setTimeout(() => reject(new Error("AI review timed out after 5 minutes")), REVIEW_TIMEOUT_MS)
       )
     ]);
     const content = extractLastAiMessageContent(result);
@@ -357,9 +689,10 @@ async function runReview(app, args) {
     }
     const finishedAt = /* @__PURE__ */ new Date();
     const durationMs = finishedAt.getTime() - startedAt.getTime();
-    const postMode = args.flow.get("postMode");
-    let postStatus = "pending_approval";
+    const postMode = getFlowPostMode(args.flow);
+    let postStatus = getInitialPostStatus(args.flow, args.targetType);
     let postedNoteId = null;
+    let autoPostError = null;
     if (postMode === "disabled") {
       postStatus = "skipped";
     } else if (postMode === "auto" && args.targetType === "mr" && args.mrIid) {
@@ -367,6 +700,8 @@ async function runReview(app, args) {
         postedNoteId = String(await postNoteToGitLab(args.repo, args.mrIid, content));
         postStatus = "posted";
       } catch (err) {
+        autoPostError = (0, import_redact.redactPat)((err == null ? void 0 : err.message) || String(err));
+        postStatus = "post_failed";
         (_c = (_b = app.log) == null ? void 0 : _b.error) == null ? void 0 : _c.call(_b, "Auto-post review note failed", err);
       }
     }
@@ -384,11 +719,14 @@ async function runReview(app, args) {
         finishedAt,
         postStatus,
         postedNoteId,
+        error: autoPostError ? `Auto-post failed: ${autoPostError}` : null,
         metadata: {
           flowName: args.flow.get("name"),
           aiEmployeeUsername: args.aiEmployeeUsername,
           llmService,
-          model
+          model,
+          postMode,
+          autoPostError
         }
       }
     });
@@ -418,19 +756,29 @@ function buildReviewPrompt(args) {
   lines.push("");
   if (args.targetType === "mr") {
     lines.push(`Target: Merge Request !${args.mrIid}.`);
-    lines.push(`Use the \`git_get_merge_request\` tool with repositoryId=${args.repo.get("id")} and mrIid=${args.mrIid} to fetch the diff and metadata.`);
+    lines.push(
+      `Use the \`git_get_merge_request\` tool with repositoryId=${args.repo.get("id")} and mrIid=${args.mrIid} to fetch the diff and metadata.`
+    );
     lines.push("Optionally call `git_get_merge_request_notes` to avoid duplicating prior comments.");
   } else if (args.targetType === "commit") {
     lines.push(`Target: Commit ${args.commitSha}.`);
-    lines.push(`Use the \`git_get_commit\` tool with repositoryId=${args.repo.get("id")} and commitHash=${args.commitSha} to fetch the diff.`);
+    lines.push(
+      `Use the \`git_get_commit\` tool with repositoryId=${args.repo.get("id")} and commitHash=${args.commitSha} to fetch the diff.`
+    );
   } else {
     lines.push(`Target: Branch ${args.branch}.`);
-    lines.push(`Use \`git_list_commits\`, \`git_get_diff\`, and \`git_get_file_content\` (with repositoryId=${args.repo.get("id")}) to inspect recent changes on this branch.`);
+    lines.push(
+      `Use \`git_list_commits\`, \`git_get_diff\`, and \`git_get_file_content\` (with repositoryId=${args.repo.get(
+        "id"
+      )}) to inspect recent changes on this branch.`
+    );
   }
   lines.push("");
   lines.push("Produce a thorough but concise code review report in Markdown. Required sections:");
   lines.push("1. **Summary** \u2014 overall assessment.");
-  lines.push("2. **Findings** \u2014 issues grouped by severity (`Critical`, `High`, `Medium`, `Low`, `Info`). For each finding include the file path, line/range when possible, the problem, and a suggested fix.");
+  lines.push(
+    "2. **Findings** \u2014 issues grouped by severity (`Critical`, `High`, `Medium`, `Low`, `Info`). For each finding include the file path, line/range when possible, the problem, and a suggested fix."
+  );
   lines.push("3. **Suggestions** \u2014 non-blocking improvements.");
   lines.push("4. **Verdict** \u2014 one of: `LGTM`, `Approve with comments`, `Request changes`, `Block`.");
   lines.push("");
@@ -497,7 +845,7 @@ async function fetchMrHeadSha(repo, mrIid) {
     if (isGitHub) {
       const { projectPath } = (0, import_gitlab_url.parseGitLabProject)(repoUrl);
       const response = await fetch(`https://api.github.com/repos/${projectPath}/pulls/${mrIid}`, {
-        headers: { "Authorization": `Bearer ${pat}`, Accept: "application/vnd.github.v3+json" }
+        headers: { Authorization: `Bearer ${pat}`, Accept: "application/vnd.github.v3+json" }
       });
       if (!response.ok) return null;
       const data = await response.json();
@@ -525,9 +873,9 @@ async function postNoteToGitLab(repo, mrIid, body) {
     const response = await fetch(`https://api.github.com/repos/${projectPath}/issues/${mrIid}/comments`, {
       method: "POST",
       headers: {
-        "Authorization": `Bearer ${pat}`,
+        Authorization: `Bearer ${pat}`,
         "Content-Type": "application/json",
-        "Accept": "application/vnd.github.v3+json"
+        Accept: "application/vnd.github.v3+json"
       },
       body: JSON.stringify({ body })
     });
@@ -545,7 +893,7 @@ async function postNoteToGitLab(repo, mrIid, body) {
       headers: {
         "PRIVATE-TOKEN": pat,
         "Content-Type": "application/json",
-        "Accept": "application/json"
+        Accept: "application/json"
       },
       body: JSON.stringify({ body })
     });
@@ -559,11 +907,30 @@ async function postNoteToGitLab(repo, mrIid, body) {
 }
 const MAX_BRANCH_FILTER_LENGTH = 200;
 const loggedBadFilters = /* @__PURE__ */ new Set();
+function getFlowPostMode(flow) {
+  var _a;
+  const rawValue = (_a = flow == null ? void 0 : flow.get) == null ? void 0 : _a.call(flow, "postMode");
+  const value = rawValue && typeof rawValue === "object" && "value" in rawValue ? rawValue.value : rawValue;
+  const normalized = String(value || "manual").trim().toLowerCase().replace(/[\s-]+/g, "_");
+  if (["auto", "auto_post", "autopost", "auto_post_to_mr"].includes(normalized)) return "auto";
+  if (["disabled", "disable", "do_not_post", "dont_post", "none", "skip", "skipped"].includes(normalized)) {
+    return "disabled";
+  }
+  return "manual";
+}
+function getInitialPostStatus(flow, targetType) {
+  const postMode = getFlowPostMode(flow);
+  if (postMode === "disabled") return "skipped";
+  if (postMode === "auto" && targetType !== "mr") return "skipped";
+  return "pending_approval";
+}
 function warnInvalidBranchFilter(filter, reason) {
   if (loggedBadFilters.has(filter)) return;
   loggedBadFilters.add(filter);
   console.warn(
-    `[plugin-git-manager] branchFilter rejected (${reason}): ${JSON.stringify(filter)}. Flow will not match any branch.`
+    `[plugin-git-manager] branchFilter rejected (${reason}): ${JSON.stringify(
+      filter
+    )}. Flow will not match any branch.`
   );
 }
 function branchMatches(flow, branch) {
@@ -601,7 +968,7 @@ async function recoverStuckReviews(app) {
     const cutoff = new Date(Date.now() - STUCK_REVIEW_CUTOFF_MS);
     const stuck = await reviewsRepo.find({
       filter: {
-        status: { $in: ["running", "pending"] },
+        status: "running",
         startedAt: { $lt: cutoff }
       }
     });
@@ -629,11 +996,14 @@ async function recoverStuckReviews(app) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  WORKER_JOB_GIT_REVIEW_PROCESS,
   branchMatches,
   pickFlowMatchingBranch,
   recoverStuckReviews,
+  registerReviewQueue,
   reviewApprovePost,
   reviewReject,
   triggerReview,
-  triggerReviewInternal
+  triggerReviewInternal,
+  unregisterReviewQueue
 });

package/dist/server/ai-tools.js

@@ -1,12 +1,3 @@
-/**
- * This file is part of the NocoBase (R) project.
- * Copyright (c) 2020-2024 NocoBase Co., Ltd.
- * Authors: NocoBase Team.
- *
- * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
- * For more information, please refer to: https://www.nocobase.com/agreement.
- */
-
 var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;