comfy-pr 0.2.7

package/src/updateCNRepos.ts

@@ -0,0 +1,58 @@
+import { updateCMNodes } from "./CMNodes";
+import { getWorkerInstance } from "./WorkerInstances";
+import { createComfyRegistryPRsFromCandidates } from "./createComfyRegistryPRsFromCandidates";
+import { notifySlack } from "./slack/notifySlack";
+import { updateCMRepos } from "./updateCMRepos";
+import { updateCNReposCRPullsComments } from "./updateCNReposCRPullsComments";
+import { updateCNReposInfo } from "./updateCNReposInfo";
+import { updateCNReposPRCandidate } from "./updateCNReposPRCandidate";
+import { updateCNReposPulls } from "./updateCNReposPulls";
+import { updateCNRepoPullsDashboard } from "./updateCNReposPullsDashboard";
+import { updateCNReposRelatedPulls } from "./updateCNReposRelatedPulls";
+import { updateCRNodes } from "./updateCRNodes";
+import { updateCRRepos } from "./updateCRRepos";
+import { updateComfyTotals } from "./updateComfyTotals";
+import { updateOutdatedPullsTemplates } from "./updateOutdatedPullsTemplates";
+import { tLog } from "./utils/tLog";
+
+if (import.meta.main) {
+  await getWorkerInstance("Updating CNRepos");
+  // await cacheHealthReport();
+  await updateCNRepos();
+  // updateCNReposPRTasks
+  // await scanCNRepoThenPRs();
+  // await pMap(candidates, (e) => updateCNRepoPRStatus(e.repository), { concurrency: 4 });
+  // candidates
+}
+
+export async function updateCNRepos() {
+  await Promise.all([
+    tLog("Report Worker Status", async () => {
+      const worker = await getWorkerInstance("ComfyPR Bot Running");
+      const workerInfo = `${worker.geo.countryCode}/${worker.geo.region}/${worker.geo.city}`;
+      const msg = `COMFY-PR BOT RUNNING ${new Date().toISOString()}\nWorker: ${workerInfo}`;
+      return [await notifySlack(msg, { unique: true, silent: true })];
+    }),
+    // stage 1: get repos
+    tLog("Update Nodes from ComfyUI Manager", updateCMNodes),
+    tLog("Update Repos from ComfyUI Manager", updateCMRepos),
+    tLog("Update Nodes from ComfyRegistry", updateCRNodes),
+    tLog("Update Repos from ComfyRegistry", updateCRRepos),
+    // stage 2: update repo info & pulls
+    tLog("Update CNRepos for Repo Infos", updateCNReposInfo),
+    tLog("Update CNRepos for Github Pulls", updateCNReposPulls),
+    tLog("Update Pulls Dashboard", updateCNRepoPullsDashboard),
+    // stage 3: update related pulls and comments
+    tLog("Update CNRepos for Related Pulls", updateCNReposRelatedPulls),
+    tLog("Update Outdated Pulls Templates", updateOutdatedPullsTemplates),
+    // stage 4: update related comments
+    tLog("Update CNRepos for Related Comments", updateCNReposCRPullsComments),
+    // stage 5: mark and create PRs
+    tLog("Update CNRepos PR Candidates", updateCNReposPRCandidate),
+    tLog("Create ComfyRegistry PRs", createComfyRegistryPRsFromCandidates),
+    // final
+    tLog("Update Comfy Totals", updateComfyTotals),
+  ]);
+
+  console.log("All repo updated");
+}

package/src/updateCNReposCRPullsComments.ts

@@ -0,0 +1,41 @@
+import pMap from "p-map";
+import { peekYaml } from "peek-log";
+import { CNRepos, type CRPull } from "./CNRepos";
+import { $fresh, $stale } from "./db";
+// import { $filaten } from "./db";
+// import { $pipeline } from "./db/$pipeline";
+import { $filaten } from "@/packages/mongodb-pipeline-ts/$filaten";
+import { $pipeline } from "@/packages/mongodb-pipeline-ts/$pipeline";
+import { getWorkerInstance } from "./WorkerInstances";
+import { fetchIssueComments } from "./gh/fetchIssueComments";
+import { TaskError, TaskOK } from "./utils/Task";
+
+if (import.meta.main) {
+  await getWorkerInstance("updateCNReposCRPullsComments");
+  await updateCNReposCRPullsComments();
+  console.log("All done");
+}
+
+export async function updateCNReposCRPullsComments() {
+  return await pMap(
+    $pipeline(CNRepos)
+      .unwind("$crPulls.data")
+      .match($filaten({ crPulls: { mtime: $fresh("7d"), data: { comments: { mtime: $stale("1d") } } } }))
+      .set($filaten({ "crPulls.data": { repository: "$repository" } }))
+      .replaceRoot({ newRoot: "$crPulls.data" })
+      .aggregate(),
+    async (data) => {
+      const { repository, pull } = data as unknown as { repository: string } & CRPull;
+      const html_url = pull.html_url;
+      const comments = await fetchIssueComments(repository, pull).then(TaskOK).catch(TaskError);
+      return peekYaml([
+        await CNRepos.findOneAndUpdate(
+          $filaten({ repository, crPulls: { data: { pull: { html_url } } } }),
+          { $set: { "crPulls.data.$.comments": comments } },
+          { upsert: true, returnDocument: "after" },
+        ),
+      ]);
+    },
+    { concurrency: 2 },
+  );
+}

package/src/updateCNReposInfo.ts

@@ -0,0 +1,57 @@
+import pMap from "p-map";
+import { dissoc } from "rambda";
+import { match } from "ts-pattern";
+import { CNRepos } from "./CNRepos";
+import { getWorkerInstance } from "./WorkerInstances";
+import { $filaten, $stale } from "./db";
+import { gh } from "./gh";
+import { parseUrlRepoOwner } from "./parseOwnerRepo";
+import { $OK, TaskError, TaskOK } from "./utils/Task";
+import { tLog } from "./utils/tLog";
+
+if (import.meta.main) {
+  await getWorkerInstance("updateCNReposInfo");
+  await tLog("updateCNReposInfo", updateCNReposInfo);
+}
+
+export async function updateCNReposInfo() {
+  await CNRepos.createIndex($filaten({ info: { mtime: 1 } }));
+  return await pMap(
+    CNRepos.find($filaten({ info: { mtime: $stale("1d") } })),
+    async (repo) => {
+      const { repository } = repo;
+      console.log("[INFO] Fetching meta info from " + repository);
+      const _info = await gh.repos
+        .get({ ...parseUrlRepoOwner(repository) })
+        .then(({ data }) => data)
+        .then(TaskOK)
+        .catch(TaskError);
+
+      // Handle renamed repos
+      const { info, url } = await match(_info)
+        .with($OK, async (info) => {
+          const url = info.data.html_url;
+          if (url === repository) return { info, url: repository };
+
+          console.log("[INFO] Migrating renamed repo: \nfrom: ", repository + "\n  to: " + url);
+          // migrate data into new CNRepo
+          await CNRepos.updateOne(
+            { repository: url },
+            {
+              $set: {
+                ...dissoc("_id", { ...(await CNRepos.findOneAndDelete({ repository })) }),
+                repository: url,
+                oldUrls: { $addToSet: repository },
+              },
+            },
+            { upsert: true },
+          );
+          return { info, url };
+        })
+        .otherwise((info) => ({ info, url: repository }));
+
+      return await CNRepos.updateOne({ repository: url }, { $set: { info } }, { upsert: true });
+    },
+    { concurrency: 2 },
+  );
+}

package/src/updateCNReposPRCandidate.ts

@@ -0,0 +1,85 @@
+import { $pipeline } from "@/packages/mongodb-pipeline-ts/$pipeline";
+import pMap from "p-map";
+import { peekYaml } from "peek-log";
+import { match } from "ts-pattern";
+import { CNRepos } from "./CNRepos";
+import { $filaten, $fresh, $stale } from "./db";
+import { updateCNReposPulls } from "./updateCNReposPulls";
+import { updateCNReposRelatedPulls } from "./updateCNReposRelatedPulls";
+import { $OK, TaskOK } from "./utils/Task";
+import { tLog } from "./utils/tLog";
+if (import.meta.main) {
+  console.log(await updateCNReposPRCandidate());
+  // show candidates
+  // console.log(
+  //   YAML.stringify(
+  //     await CNRepos.find($filaten({ candidate: { data: { $eq: true } } }))
+  //       .map((e) => ({
+  //         // candidate: match(e.candidate)
+  //         //   .with($OK, (e) => e)
+  //         //   .otherwise(() => DIE("")).data,
+  //         repo: e.repository + "/pulls?q=",
+  //       }))
+  //       .toArray(),
+  //   ),
+  // );
+  tLog("updateCNReposPulls", updateCNReposPulls);
+  tLog("updateCNReposRelatedPulls", updateCNReposRelatedPulls);
+
+  await CNRepos.createIndex("crPulls.mtime");
+  // show candidates
+  peekYaml(
+    await $pipeline(CNRepos)
+      .match(
+        $filaten({
+          crPulls: { mtime: $stale("7d") },
+          // info: { mtime: $fresh("7d"), data: { private: false, archived: false } },
+          // createdPulls: { mtime: $stale("7d"), data: { $exists: false } },
+        }),
+      )
+      .aggregate()
+      .map((e) => ({
+        repo: e.repository + "/pulls?q=",
+        pulls: match(e.pulls)
+          .with($OK, ({ data }) => data)
+          .otherwise(() => null)?.length,
+        crPulls: match(e.crPulls)
+          .with($OK, ({ data }) => data)
+          .otherwise(() => null)?.length,
+      }))
+      .toArray(),
+  );
+}
+
+export async function updateCNReposPRCandidate() {
+  return await pMap(
+    $pipeline(CNRepos)
+      .match(
+        $filaten({
+          crPulls: { mtime: $fresh("1d"), ...$OK },
+          // info: { mtime: $fresh("7d"), ...$OK, data: { private: false, archived: false } },
+          info: { mtime: $fresh("7d"), ...$OK },
+          // createdPulls: { state: { $ne: "ok" }, mtime: $stale("5m") },
+          candidate: { mtime: $stale("1d") },
+        }),
+      )
+      .aggregate(),
+    async (repo) => {
+      const crPulls = match(repo.crPulls)
+        .with($OK, (e) => e.data)
+        .otherwise(() => null)!;
+      const info = match(repo.info)
+        .with($OK, (e) => e.data)
+        .otherwise(() => null)!;
+
+      const isCandidate = !info.private && !info.archived && crPulls.length === 0;
+      const candidate = TaskOK(isCandidate);
+
+      // silent
+      // if (isCandidate)
+      //   await notifySlackLinks("Found new PR candidate", [repo.repository]);
+      await CNRepos.updateOne({ repository: repo.repository }, { $set: { candidate } });
+      return repo;
+    },
+  );
+}

package/src/updateCNReposPulls.ts

@@ -0,0 +1,28 @@
+import { $pipeline } from "@/packages/mongodb-pipeline-ts/$pipeline";
+import pMap from "p-map";
+import { match } from "ts-pattern";
+import { CNRepos } from "./CNRepos";
+import { $filaten, $stale } from "./db";
+import { fetchGithubPulls } from "./gh/fetchGithubPulls";
+import { $OK, TaskError, TaskOK } from "./utils/Task";
+import { tLog } from "./utils/tLog";
+if (import.meta.main) {
+  console.log(await tLog("Update CNRepos for Github Pulls", updateCNReposPulls));
+}
+export async function updateCNReposPulls() {
+  await CNRepos.createIndex("pulls.mtime");
+  return await pMap(
+    $pipeline(CNRepos)
+      .match($filaten({ pulls: { mtime: $stale("1d") } }))
+      .project({ repository: 1 })
+      .aggregate(),
+    async ({ repository }) => {
+      const pulls = await fetchGithubPulls(repository).then(TaskOK).catch(TaskError);
+      match(pulls)
+        .with($OK, ({ data }) => console.debug(`[DEBUG] updated ${data.length} Pulls from ${repository}`))
+        .otherwise(() => {});
+      return await CNRepos.updateOne({ repository }, { $set: { pulls } });
+    },
+    { concurrency: 2 },
+  );
+}

package/src/updateCNReposPullsDashboard.ts

@@ -0,0 +1,49 @@
+import DIE from "@snomiao/die";
+import { match } from "ts-pattern";
+import { CNRepos } from "./CNRepos";
+import { $filaten, $fresh } from "./db";
+import { gh } from "./gh";
+import { ghUser } from "./ghUser";
+import { parseUrlRepoOwner, stringifyOwnerRepo } from "./parseOwnerRepo";
+import { $OK } from "./utils/Task";
+
+export async function updateCNRepoPullsDashboard() {
+  if (ghUser.login !== "snomiao") return [];
+  const dashBoardIssue = process.env.DASHBOARD_ISSUE_URL || DIE("DASHBOARD_ISSUE_URL not found");
+  const dashBoardRepo = dashBoardIssue.replace(/\/issues\/\d+$/, "");
+  const dashBoardIssueNumber = Number(dashBoardIssue.match(/\/issues\/(\d+)$/)?.[1] || DIE("Issue number not found"));
+  // update dashboard issue if run by @snomiao
+  const repos = await CNRepos.find($filaten({ crPulls: { mtime: $fresh("1d") } })).toArray();
+  const result = repos
+    .map((repo) => {
+      const crPulls = match(repo.crPulls)
+        .with($OK, ({ data }) => data)
+        .otherwise(() => DIE("CR Pulls not found"));
+      const repoName = stringifyOwnerRepo(parseUrlRepoOwner(repo.repository));
+      const body = crPulls
+        .filter((e) => e.pull.prState !== "closed")
+        .map((e) => {
+          const date = new Date(e.pull.createdAt).toISOString().slice(0, 10);
+          const state = e.pull.prState.toUpperCase();
+          return {
+            href: e.pull.html_url,
+            name: `PR ${date} ${state}: ${repoName} #${e.type}`,
+          };
+        })
+        .map(({ href, name }) => `- [${name}](${href})`)
+        .toSorted()
+        .join("\n");
+      return body;
+    })
+    .filter(Boolean)
+    .join("\n");
+  const body = result;
+
+  return [
+    await gh.issues.update({
+      ...parseUrlRepoOwner(dashBoardRepo),
+      issue_number: dashBoardIssueNumber,
+      body,
+    }),
+  ];
+}

package/src/updateCNReposRelatedPulls.ts

@@ -0,0 +1,25 @@
+import DIE from "@snomiao/die";
+import pMap from "p-map";
+import { match } from "ts-pattern";
+import { CNRepos } from "./CNRepos";
+import { $filaten, $stale } from "./db";
+import { matchRelatedPulls } from "./matchRelatedPulls";
+import { $OK, TaskError, TaskOK } from "./utils/Task";
+import { tLog } from "./utils/tLog";
+if (import.meta.main) {
+  await tLog("updateCNReposRelatedPulls", updateCNReposRelatedPulls);
+}
+export async function updateCNReposRelatedPulls() {
+  await CNRepos.createIndex({ "pulls.state": 1, "crPulls.mtime": 1 });
+  return await pMap(
+    CNRepos.find($filaten({ pulls: { state: "ok" }, crPulls: { mtime: $stale("1d") } })),
+    async (repo, i) => {
+      const { repository } = repo;
+      const pulls = match(repo.pulls)
+        .with($OK, (e) => e.data)
+        .otherwise(() => DIE("Pulls not found"));
+      const crPulls = await matchRelatedPulls(pulls).then(TaskOK).catch(TaskError);
+      return await CNRepos.updateOne({ repository }, { $set: { crPulls } });
+    },
+  );
+}

package/src/updateCRNodes.ts

@@ -0,0 +1,50 @@
+import { $pipeline } from "@/packages/mongodb-pipeline-ts/$pipeline";
+import { peekYaml } from "peek-log";
+import { filter, groupBy, values } from "rambda";
+import YAML from "yaml";
+import { CNRepos } from "./CNRepos";
+import { CRNodes } from "./CRNodes";
+import { fetchCRNodes } from "./fetchComfyRegistryNodes";
+import { notifySlack } from "./slack/notifySlack";
+import { TaskOK } from "./utils/Task";
+import { tLog } from "./utils/tLog";
+
+if (import.meta.main) {
+  peekYaml(await tLog(updateCRNodes));
+  console.log("CRNodes updated");
+
+  peekYaml(
+    await $pipeline(CNRepos).project({ repository: 1, on_registry: 1 }).sample({ size: 8 }).aggregate().toArray(),
+  );
+}
+export async function updateCRNodes() {
+  const nodes = await fetchCRNodes();
+
+  // check src duplicated
+  const group = groupBy((e) => e.repository, nodes);
+  const duplicates = filter((e) => e.length > 1, group);
+  if (values(duplicates).length) {
+    const msg =
+      "[WARN] Same repo but different ids found in comfyregistry:\n" + "```\n" + YAML.stringify(duplicates) + "\n```";
+    await notifySlack(msg, { unique: true });
+  }
+
+  return [
+    await $pipeline(CNRepos)
+      .project({ repository: 1 })
+      .set({ on_registry: TaskOK({ $in: ["$repository", nodes.map(({ repository }) => repository).filter(Boolean)] }) })
+      .merge({ into: "CNRepos", on: "repository", whenMatched: "merge", whenNotMatched: "insert" })
+      .aggregate()
+      .next(),
+    await CRNodes.bulkWrite(
+      nodes.map((node) => ({
+        updateOne: {
+          filter: { id: node.id },
+          update: { $set: node },
+          upsert: true,
+        },
+      })),
+      { ordered: false },
+    ),
+  ];
+}

package/src/updateCRRepos.ts

@@ -0,0 +1,26 @@
+import pMap from "p-map";
+import { CNRepos } from "./CNRepos";
+import { CRNodes } from "./CRNodes";
+import { tLog } from "./utils/tLog";
+if (import.meta.main) {
+  await tLog("updateCRRepos", updateCRRepos);
+}
+export async function updateCRRepos() {
+  await CRNodes.createIndex({ repo_id: 1 });
+  return await pMap(CRNodes.find({ repo_id: { $exists: false } }), async (cr, i) => {
+    const { repository, _id } = cr;
+    await CNRepos.updateOne(
+      { repository },
+      {
+        $set: {
+          cr: (await CRNodes.findOneAndUpdate(
+            { _id },
+            { $set: { repo_id: cr._id } },
+            { upsert: true, returnDocument: "after" },
+          ))!,
+        },
+      },
+      { upsert: true },
+    );
+  });
+}

package/src/updateComfyTotals.ts

@@ -0,0 +1,40 @@
+import { match } from "ts-pattern";
+import YAML from "yaml";
+import { Totals } from "./Totals";
+import { analyzeTotals } from "./analyzeTotals";
+import { $filaten, $fresh } from "./db";
+import { notifySlack } from "./slack/notifySlack";
+import { $OK, TaskError, TaskOK } from "./utils/Task";
+import { tsmatch } from "./utils/tsmatch";
+
+if (import.meta.main) {
+  await updateComfyTotals();
+}
+
+export async function updateComfyTotals({ notify = true, fresh = "30m" } = {}) {
+  const today = new Date().toISOString().split("T")[0];
+  const cached = await Totals.findOne($filaten({ today, totals: { mtime: $fresh(fresh), ...$OK } }));
+  if (cached?.totals?.state === "ok")
+    return [
+      tsmatch(cached.totals)
+        .with($OK, ({ data }) => data)
+        .otherwise(() => null),
+    ].flatMap((e) => (e ? [e] : []));
+  const totals = await analyzeTotals().then(TaskOK).catch(TaskError);
+
+  // notify
+  notify &&
+    (await match(totals)
+      .with($OK, async (totals) => {
+        const msg = `Totals: \n${"```"}\n${YAML.stringify(totals)}\n${"```"}`;
+        await notifySlack(msg, { unique: true });
+      })
+      .otherwise(() => null));
+
+  const insertResult = await Totals.insertOne({ totals });
+  return [
+    tsmatch(totals)
+      .with($OK, ({ data }) => data)
+      .otherwise(() => null),
+  ].flatMap((e) => (e ? [e] : []));
+}

package/src/updateFollowRuleSet.ts

@@ -0,0 +1,153 @@
+"use server";
+import { TaskDataOrNull } from "@/app/(dashboard)/rules/TaskDataOrNull";
+import { $elemMatch } from "@/packages/mongodb-pipeline-ts/$elemMatch";
+import { $pipeline } from "@/packages/mongodb-pipeline-ts/$pipeline";
+import DIE from "@snomiao/die";
+import pMap from "p-map";
+import { CNRepos, type CRPull } from "./CNRepos";
+import { FollowRuleSets } from "./FollowRules";
+import type { GithubIssueComment } from "./GithubIssueComments";
+import { analyzePullsStatusPipeline, type PullStatus } from "./analyzePullsStatus";
+import { createIssueComment } from "./createIssueComment";
+import { $filaten } from "./db";
+import { zAddCommentAction, zFollowUpRules } from "./followRuleSchema";
+import { notifySlackLinks } from "./slack/notifySlackLinks";
+import { TaskError, TaskOK } from "./utils/Task";
+import { prettyMs } from "./utils/tLog";
+import { yaml } from "./utils/yaml";
+
+if (import.meta.main) {
+  // updateFollowRuleSet({yaml: 'default'})
+  await runFollowRuleSet();
+}
+
+export async function runFollowRuleSet({ name = "default" } = {}) {
+  const ruleset = (await FollowRuleSets.findOne({ name })) ?? DIE("default ruleset not found");
+  return await updateFollowRuleSet({
+    name: ruleset.name,
+    enable: ruleset.enabled ?? DIE("Ruleset is not enabled"),
+    yaml: ruleset.yamlWhenEnabled ?? DIE("Enabled yaml is not found"),
+    runAction: true,
+  });
+}
+export type updateFollowRuleSet = typeof updateFollowRuleSet;
+export async function updateFollowRuleSet({
+  name,
+  yaml: code,
+  enable,
+  runAction = false,
+}: {
+  name: string;
+  /** update yaml if provided */
+  yaml?: string;
+  /** update enable if provided */
+  enable?: boolean | undefined;
+  /** run action if set to true */
+  runAction?: boolean;
+}) {
+  "use server";
+  return await (async function () {
+    if (enable === false) {
+      await FollowRuleSets.updateOne({ name }, { $set: { enabled: false, yamlWhenEnabled: "" } });
+      DIE("ruleset is disabled, no need to run");
+    }
+
+    // must parse while run, because the date in code is dynamic generated
+    const rules = zFollowUpRules.parse(yaml.parse(code || DIE("yaml is empty")));
+    // save if parse succ
+    // await FollowRuleSets.updateOne({ name }, { $set: { yaml: code, rules } });
+    const parseResult = await pMap(
+      rules,
+      async (rule) => {
+        const matched = await analyzePullsStatusPipeline()
+          .match(rule.$match)
+          .aggregate()
+          .map(({ updated_at, created_at, on_registry_at, ...pull }) => {
+            const updated = prettyMs(+new Date() - +new Date(updated_at), { compact: true }) + " ago";
+            return {
+              updated, //: updated === created ? "never" : updated,
+              ...pull,
+              lastwords: pull.lastwords?.replace(/\s+/g, " ").replace(/\*\*\*.*/g, "..."),
+            } as PullStatus;
+          })
+          .toArray()
+          .then(TaskOK)
+          .catch(TaskError);
+        const actions = await (async function () {
+          return await pMap(
+            Object.entries(rule.action),
+            async ([name, _action]) => {
+              if (name === "add-comment") {
+                const action = zAddCommentAction.parse(_action);
+                const matchedData = TaskDataOrNull(matched) ?? DIE("NO-PAYLOAD-AVAILABLE");
+                return await pMap(
+                  matchedData,
+                  async (payload) => {
+                    const loadedAction = {
+                      action: "add-comment",
+                      url: payload.url,
+                      by: action.by,
+                      body: action.body.replace(
+                        /{{\$(\w+)}}/,
+                        (_, key: string) =>
+                          (payload as any)[key] ||
+                          DIE("Missing key: " + key + " in payload: " + JSON.stringify(payload)),
+                      ),
+                    };
+
+                    if (runAction) {
+                      const existedComments =
+                        (await $pipeline(CNRepos)
+                          .unwind("$crPulls.data")
+                          .match({ "crPulls.data.pull.html_url": loadedAction.url })
+                          .with<{ "crPulls.data": CRPull }>()
+                          .replaceRoot({ newRoot: "$crPulls.data.comments.data" })
+                          .as<GithubIssueComment[]>()
+                          .aggregate()
+                          .next()) ??
+                        DIE("comments is not fetched before, plz check " + loadedAction.url + " in CNRepos");
+
+                      const existedComment = existedComments.find((e) => e.body === loadedAction.body);
+                      if (!existedComment) {
+                        const { comments, comment } = await createIssueComment(
+                          loadedAction.url,
+                          loadedAction.body,
+                          loadedAction.by,
+                        );
+                        const updateResult = await CNRepos.updateOne(
+                          $filaten({ crPulls: { data: $elemMatch({ pull: { html_url: loadedAction.url } }) } }),
+                          { $set: { "crPulls.data.$.comments": comments } },
+                        );
+                        if (!updateResult.matchedCount) DIE("created issue not matched");
+                        await notifySlackLinks("A New issue comment are created from rule " + rule.name, [
+                          comment.html_url,
+                        ]);
+                      }
+                    }
+
+                    return loadedAction;
+                  },
+                  { stopOnError: false, concurrency: 1 },
+                );
+              }
+            },
+            { concurrency: 1 },
+          );
+        })()
+          .then(TaskOK)
+          .catch(TaskError);
+
+        return { name: rule.name, matched, actions };
+      },
+      { concurrency: 1 },
+    );
+    if (enable) {
+      await FollowRuleSets.updateOne({ name }, { $set: { enabled: true, yamlWhenEnabled: code, yaml: code } });
+    } else {
+      await FollowRuleSets.updateOne({ name }, { $set: { yaml: code } });
+    }
+    return parseResult;
+  })()
+    .then(TaskOK)
+    .catch(TaskError);
+}