comfy-pr 0.2.26 → 1.0.1

package/src/sendEmailAction.ts

@@ -3,11 +3,11 @@ import { $elemMatch } from "@/packages/mongodb-pipeline-ts/$elemMatch";
 import { TaskDataOrNull, type Task } from "@/packages/mongodb-pipeline-ts/Task";
 import DIE from "@snomiao/die";
 import pMap from "p-map";
-import { snoflow } from "snoflow";
+import { sflow } from "sflow";
 import type { z } from "zod";
 import type { PullStatusShown } from "./analyzePullsStatus";
 import { CNRepos } from "./CNRepos";
-import { $filaten } from "./db";
+import { $flatten } from "./db";
 import { enqueueEmailTask } from "./EmailTasks";
 import { zSendEmailAction } from "./followRuleSchema";
 import { yaml } from "./utils/yaml";
@@ -27,14 +27,15 @@ export async function sendEmailAction({
     TaskDataOrNull(matched) ?? DIE("NO-PAYLOAD-AVAILABLE"),
     async (payload) => {
       if (action.provider !== "google") DIE("Currently we only support gmail sender");
-      const loadedAction = await snoflow([action])
+      const loadedAction = await sflow([action])
         .map((e) => yaml.stringify(e))
         .map((e) =>
           // replace {{var}} s
-          e.replace(
-            /{{\$([_A-Za-z0-9]+)}}/g,
-            (_, key: string) =>
-              (payload as any)[key] || DIE("Missing key: " + key + " in payload: " + JSON.stringify(payload)),
+          e.replace(/{{\$([_A-Za-z0-9]+)}}/g, (_, key: string) =>
+            String(
+              (payload as Record<string, unknown>)[key] ??
+                DIE("Missing key: " + key + " in payload: " + JSON.stringify(payload)),
+            ),
           ),
         )
         .map((e) => yaml.parse(e))
@@ -45,9 +46,12 @@ export async function sendEmailAction({
       if (runAction) {
         const task = await enqueueEmailTask(loadedAction);
         console.log(rule.name + " email enqueued :" + yaml.stringify(loadedAction));
-        await CNRepos.updateOne($filaten({ crPulls: { data: $elemMatch({ pull: { html_url: payload.url } }) } }), {
-          $set: { "crPulls.data.$.emailTask_id": task._id },
-        });
+        await CNRepos.updateOne(
+          $flatten({ crPulls: { data: $elemMatch({ pull: { html_url: payload.url } }) } }),
+          {
+            $set: { "crPulls.data.$.emailTask_id": task._id },
+          },
+        );
       }
       return loadedAction;
     },

package/src/sendGmail.ts

@@ -91,9 +91,9 @@ export async function sendGmail({
   msg.setSender({ name: name, addr: from });
   msg.setRecipient(to);
   msg.setSubject(subject);
-  text && msg.addMessage({ contentType: "text/plain", data: text });
-  html && msg.addMessage({ contentType: "text/html", data: html });
-  text || html || DIE("Missing msg body");
+  if (text) msg.addMessage({ contentType: "text/plain", data: text });
+  if (html) msg.addMessage({ contentType: "text/html", data: html });
+  if (!text && !html) DIE("Missing msg body");
 
   const result = await new GoogleApis().gmail("v1").users.messages.send({
     auth,

package/src/updateAuthorsForGithub.ts

@@ -2,53 +2,71 @@ import { $OK, TaskDataOrNull, TaskError, TaskOK } from "@/packages/mongodb-pipel
 import DIE from "@snomiao/die";
 import console from "console";
 import { peekYaml } from "peek-log";
-import { snoflow } from "snoflow";
+import { sflow } from "sflow";
 import { Authors, GithubUsers } from "./Authors";
 import { $stale } from "./db";
-import { gh } from "./gh";
+import { gh } from "@/lib/github";
 
 if (import.meta.main) {
   await updateAuthorsForGithub();
 }
 export async function updateAuthorsForGithub() {
-  await snoflow(Authors.find({ githubMtime: $stale("7d") }))
+  await sflow(Authors.find({ githubMtime: $stale("7d") }))
     .map((e) => e.githubId)
     .filter()
-    .pMap(2, async (username) => {
-      const cached = await GithubUsers.findOne({ username, mtime: $stale("1d"), ...$OK });
-      if (cached) return cached;
-      console.log("Fetching github user " + username);
-      const result = await gh.users
-        .getByUsername({ username })
-        .then((e) => e.data)
-        .then(TaskOK)
-        .catch(TaskError);
-      return (
-        (await GithubUsers.findOneAndUpdate(
-          { username },
-          { $set: result },
-          { returnDocument: "after", upsert: true },
-        )) ?? DIE(`fail to udpate gh users`)
-      );
-    })
+    .pMap(
+      async (username) => {
+        const cached = await GithubUsers.findOne({ username, mtime: $stale("1d"), ...$OK });
+        if (cached) return cached;
+        console.log("Fetching github user " + username);
+        const result = await gh.users
+          .getByUsername({ username })
+          .then((e) => e.data)
+          .then(TaskOK)
+          .catch(TaskError);
+        return (
+          (await GithubUsers.findOneAndUpdate(
+            { username },
+            { $set: result },
+            { returnDocument: "after", upsert: true },
+          )) ?? DIE(`fail to udpate gh users`)
+        );
+      },
+      { concurrency: 2 },
+    )
     .map((e) => TaskDataOrNull(e))
     .filter()
-    .map(({ email, avatar_url, blog, updated_at, location, company, hireable, bio, login }) =>
-      Authors.findOneAndUpdate(
-        { githubId: login },
-        {
-          $set: { githubMtime: new Date(), ...(email && { email }), ...(null != hireable && { hireable }) },
-          $addToSet: {
-            ...(bio && { bios: bio }),
-            avatars: avatar_url,
-            ...(location && { locations: location }),
-            ...(blog && { blogs: blog }),
-            ...(company && { companies: company }),
+    .map(
+      ({
+        email,
+        avatar_url,
+        blog,
+        updated_at: _updated_at,
+        location,
+        company,
+        hireable,
+        bio,
+        login,
+      }) =>
+        Authors.findOneAndUpdate(
+          { githubId: login },
+          {
+            $set: {
+              githubMtime: new Date(),
+              ...(email && { email }),
+              ...(null != hireable && { hireable }),
+            },
+            $addToSet: {
+              ...(bio && { bios: bio }),
+              avatars: avatar_url,
+              ...(location && { locations: location }),
+              ...(blog && { blogs: blog }),
+              ...(company && { companies: company }),
+            },
           },
-        },
-        { upsert: true, returnDocument: "after" },
-      ),
+          { upsert: true, returnDocument: "after" },
+        ),
     )
-    .peek(peekYaml)
+    .forEach(peekYaml)
     .done();
 }

package/src/updateAuthorsFromCNRepo.ts

@@ -1,14 +1,14 @@
 import { $pipeline } from "@/packages/mongodb-pipeline-ts/$pipeline";
-import { snoflow } from "snoflow";
+import { sflow } from "sflow";
 import { Authors } from "./Authors";
 import { CNRepos } from "./CNRepos";
-import { $filaten } from "./db";
+import { $flatten } from "./db";
 
 /** Update authors for gh users, collecting emails/username/hireable */
 export async function updateAuthorsFromCNRepo() {
-  return await snoflow(
+  return await sflow(
     $pipeline(CNRepos)
-      .match($filaten({ info: { data: { owner: { login: { $exists: true } } } } }))
+      .match($flatten({ info: { data: { owner: { login: { $exists: true } } } } }))
       .group({
         _id: "$info.data.owner.login",
         // author: "$info.data.owner.login",
@@ -25,6 +25,13 @@ export async function updateAuthorsFromCNRepo() {
       .project({ _id: 0 })
       .aggregate(),
   )
-    .map(({ githubId, ...$set }) => Authors.updateOne({ githubId }, { $set }, { upsert: true }))
+    .map((doc) => {
+      const { githubId, ...$set } = doc as Record<string, unknown>;
+      return Authors.updateOne(
+        { githubId: githubId as string | undefined },
+        { $set: $set as Record<string, unknown> } as Parameters<typeof Authors.updateOne>[1],
+        { upsert: true },
+      );
+    })
     .done();
 }

package/src/updateCMNodesDuplicationWarnings.ts

@@ -1,19 +1,21 @@
-import { unary } from "lodash-es";
 import pMap from "p-map";
-import { dissoc, filter, groupBy, map, prop, toPairs } from "rambda";
+import { filter, groupBy, map, prop, toPairs } from "rambda";
 import YAML from "yaml";
 import { CMNodes, type CMNode } from "./CMNodes";
-import { notifySlack } from "./slack/notifySlack";
+import { notifySlack } from "@/lib/slack/notifySlack";
 
 export async function updateCMNodesDuplicationWarnings(nodes: CMNode[]) {
   console.log("CMNodes checking duplicates");
+  const idGroups = groupBy((e) => e.id, nodes);
+  const titleGroups = groupBy((e) => e.title, nodes);
+  const referenceGroups = groupBy((e) => e.reference, nodes);
   // prettier-ignore
   const dups = {
-    ID: filter((e: typeof nodes) => e.length > 1, groupBy((e) => e.id, nodes)),
-    TITLE: filter((e: typeof nodes) => e.length > 1, groupBy((e) => e.title, nodes)),
-    REFERENCE: filter((e: typeof nodes) => e.length > 1, groupBy((e) => e.reference, nodes)),
+    ID: filter((e?: CMNode[]) => (e?.length??0) > 1, idGroups),
+    TITLE: filter((e?: CMNode[]) => (e?.length??0) > 1, titleGroups),
+    REFERENCE: filter((e?: CMNode[]) => (e?.length??0) > 1, referenceGroups),
   };
-  const dupsSummary = JSON.stringify(map((x) => map((x) => x.length, x), dups));
+  const dupsSummary = JSON.stringify(map((x) => map((x) => x?.length ?? 0, x), dups));
   await notifySlack(
     `[WARN] CMNodes duplicates: ${dupsSummary}\nSolve them in https://github.com/ltdrdata/ComfyUI-Manager/blob/main/custom-node-list.json`,
   );
@@ -24,8 +26,11 @@ export async function updateCMNodesDuplicationWarnings(nodes: CMNode[]) {
       await pMap(
         toPairs(nodes),
         async ([key, nodesRaw]) => {
-          const nodes = nodesRaw.map(unary(dissoc("hash")));
-          const hashes = nodesRaw.map(prop("hash"));
+          const nodes = nodesRaw?.map((nodeRaw) => {
+            const { hash: _hash, ...node } = { ...nodeRaw };
+            return node;
+          });
+          const hashes = nodesRaw?.map(prop("hash"));
           // check sent
           const someDuplicateSent = await CMNodes.findOne({
             hash: { $in: hashes },

package/src/updateCMRepos.ts

@@ -8,7 +8,7 @@ if (import.meta.main) {
 }
 export async function updateCMRepos() {
   await CMNodes.createIndex({ repo_id: 1 });
-  return await pMap(CMNodes.find({ repo_id: { $exists: false } }), async (cm, i) => {
+  return await pMap(CMNodes.find({ repo_id: { $exists: false } }), async (cm, _i) => {
     const { reference: repository, _id } = cm;
     return await CNRepos.updateOne(
       { repository },

package/src/updateCNRepos.ts

@@ -1,7 +1,7 @@
 import { updateCMNodes } from "./CMNodes";
 import { getWorkerInstance } from "./WorkerInstances";
 import { createComfyRegistryPRsFromCandidates } from "./createComfyRegistryPRsFromCandidates";
-import { notifySlack } from "./slack/notifySlack";
+import { notifySlack } from "@/lib/slack/notifySlack";
 import { updateCMRepos } from "./updateCMRepos";
 import { updateCNReposCRPullsComments } from "./updateCNReposCRPullsComments";
 import { updateCNReposInfo } from "./updateCNReposInfo";
@@ -34,24 +34,24 @@ export async function updateCNRepos() {
       return [await notifySlack(msg, { unique: true, silent: true })];
     }),
     // stage 1: get repos
-    await tLog("Update Nodes from ComfyUI Manager", updateCMNodes),
-    await tLog("Update Repos from ComfyUI Manager", updateCMRepos),
-    await tLog("Update Nodes from ComfyRegistry", updateCRNodes),
-    await tLog("Update Repos from ComfyRegistry", updateCRRepos),
+    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
-    await tLog("Update CNRepos for Repo Infos", updateCNReposInfo),
-    await tLog("Update CNRepos for Github Pulls", updateCNReposPulls),
-    await tLog("Update Pulls Dashboard", updateCNRepoPullsDashboard),
+    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
-    await tLog("Update CNRepos for Related Pulls", updateCNReposRelatedPulls),
-    await tLog("Update Outdated Pulls Templates", updateOutdatedPullsTemplates),
+    tLog("Update CNRepos for Related Pulls", updateCNReposRelatedPulls),
+    tLog("Update Outdated Pulls Templates", updateOutdatedPullsTemplates),
     // stage 4: update related comments
-    await tLog("Update CNRepos for Related Comments", updateCNReposCRPullsComments),
+    tLog("Update CNRepos for Related Comments", updateCNReposCRPullsComments),
     // stage 5: mark and create PRs
-    await tLog("Update CNRepos PR Candidates", updateCNReposPRCandidate),
-    await tLog("Create ComfyRegistry PRs", createComfyRegistryPRsFromCandidates),
+    tLog("Update CNRepos PR Candidates", updateCNReposPRCandidate),
+    tLog("Create ComfyRegistry PRs", createComfyRegistryPRsFromCandidates),
     // final
-    await tLog("Update Comfy Totals", updateComfyTotals),
+    tLog("Update Comfy Totals", updateComfyTotals),
   ]);
 
   console.log("All repo updated");

package/src/updateCNReposCRPullsComments.ts

@@ -3,11 +3,11 @@ 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 { $flatten } from "@/packages/mongodb-pipeline-ts/$flatten";
 import { $pipeline } from "@/packages/mongodb-pipeline-ts/$pipeline";
 import { TaskError, TaskOK } from "../packages/mongodb-pipeline-ts/Task";
 import { getWorkerInstance } from "./WorkerInstances";
-import { fetchIssueComments } from "./gh/fetchIssueComments";
+import { fetchIssueComments } from "@/lib/github/fetchIssueComments";
 
 if (import.meta.main) {
   await getWorkerInstance("updateCNReposCRPullsComments");
@@ -19,8 +19,10 @@ 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" } }))
+      .match(
+        $flatten({ crPulls: { mtime: $fresh("7d"), data: { comments: { mtime: $stale("1d") } } } }),
+      )
+      .set($flatten({ "crPulls.data": { repository: "$repository" } }))
       .replaceRoot({ newRoot: "$crPulls.data" })
       .aggregate(),
     async (data) => {
@@ -29,7 +31,7 @@ export async function updateCNReposCRPullsComments() {
       const comments = await fetchIssueComments(repository, pull).then(TaskOK).catch(TaskError);
       return [
         await CNRepos.findOneAndUpdate(
-          $filaten({ repository, crPulls: { data: { pull: { html_url } } } }),
+          $flatten({ repository, crPulls: { data: { pull: { html_url } } } }),
           { $set: { "crPulls.data.$.comments": comments } },
           { upsert: true, returnDocument: "after" },
         ),

package/src/updateCNReposInfo.ts

@@ -4,10 +4,11 @@ import { match } from "ts-pattern";
 import { $OK, TaskError, TaskOK } from "../packages/mongodb-pipeline-ts/Task";
 import { CNRepos } from "./CNRepos";
 import { getWorkerInstance } from "./WorkerInstances";
-import { $filaten, $stale } from "./db";
-import { gh } from "./gh";
-import { parseUrlRepoOwner } from "./parseOwnerRepo";
+import { $flatten, $stale } from "./db";
+import { gh } from "@/lib/github";
+import { parseGithubRepoUrl } from "./parseOwnerRepo";
 import { tLog } from "./utils/tLog";
+import { pickRepoInfo } from "./pickRepoInfo";
 
 if (import.meta.main) {
   await getWorkerInstance("updateCNReposInfo");
@@ -15,44 +16,52 @@ if (import.meta.main) {
 }
 
 export async function updateCNReposInfo() {
-  await CNRepos.createIndex($filaten({ info: { mtime: 1 } }));
-  return await sflow(
-    CNRepos.find($filaten({ info: { mtime: $stale("1d") } }))
-  ).pMap(
-    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 };
+  await CNRepos.createIndex($flatten({ info: { mtime: 1 } }));
+  return await sflow(CNRepos.find($flatten({ info: { mtime: $stale("1d") } })))
+    .filter((repo) => {
+      // Skip repos with invalid repository values
+      if (!repo.repository || typeof repo.repository !== "string") {
+        console.log("[WARN] Skipping repo with invalid repository field:", repo);
+        return false;
+      }
+      return true;
+    })
+    .pMap(
+      async (repo) => {
+        const { repository } = repo;
+        console.log("[INFO] Fetching meta info from " + repository);
+        const _info = await gh.repos
+          .get({ ...parseGithubRepoUrl(repository) })
+          .then(({ data }) => pickRepoInfo(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.data.use_squash_pr_title_as_default)
-          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 },
+            // console.log(info.data.use_squash_pr_title_as_default)
+            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 }));
+              { upsert: true },
+            );
+            return { info, url };
+          })
+          .otherwise((info) => ({ info, url: repository }));
 
-      return await CNRepos.updateOne({ repository: url }, { $set: { info } }, { upsert: true });
-    },
-    { concurrency: 2 },
-  ).toArray();
+        return await CNRepos.updateOne({ repository: url }, { $set: { info } }, { upsert: true });
+      },
+      { concurrency: 2 },
+    )
+    .toArray();
 }

package/src/updateCNReposPRCandidate.ts

@@ -4,7 +4,7 @@ import { peekYaml } from "peek-log";
 import { match } from "ts-pattern";
 import { $OK, TaskOK } from "../packages/mongodb-pipeline-ts/Task";
 import { CNRepos } from "./CNRepos";
-import { $filaten, $fresh, $stale } from "./db";
+import { $flatten, $fresh, $stale } from "./db";
 import { updateCNReposPulls } from "./updateCNReposPulls";
 import { updateCNReposRelatedPulls } from "./updateCNReposRelatedPulls";
 import { tLog } from "./utils/tLog";
@@ -31,7 +31,7 @@ if (import.meta.main) {
   peekYaml(
     await $pipeline(CNRepos)
       .match(
-        $filaten({
+        $flatten({
           crPulls: { mtime: $stale("7d") },
           // info: { mtime: $fresh("7d"), data: { private: false, archived: false } },
           // createdPulls: { mtime: $stale("7d"), data: { $exists: false } },
@@ -55,7 +55,7 @@ export async function updateCNReposPRCandidate() {
   return await pMap(
     $pipeline(CNRepos)
       .match(
-        $filaten({
+        $flatten({
           crPulls: { mtime: $fresh("1d"), ...$OK },
           // info: { mtime: $fresh("7d"), ...$OK, data: { private: false, archived: false } },
           info: { mtime: $fresh("7d"), ...$OK },

package/src/updateCNReposPulls.ts

@@ -3,8 +3,8 @@ import sflow from "sflow";
 import { match } from "ts-pattern";
 import { $OK, TaskError, TaskOK } from "../packages/mongodb-pipeline-ts/Task";
 import { CNRepos } from "./CNRepos";
-import { $filaten, $stale } from "./db";
-import { fetchGithubPulls } from "./gh/fetchGithubPulls";
+import { $flatten, $stale } from "./db";
+import { fetchGithubPulls } from "@/lib/github/fetchGithubPulls";
 import { tLog } from "./utils/tLog";
 if (import.meta.main) {
   console.log(await tLog("Update CNRepos for Github Pulls", updateCNReposPulls));
@@ -13,15 +13,19 @@ export async function updateCNReposPulls() {
   await CNRepos.createIndex("pulls.mtime");
   return await sflow(
     $pipeline(CNRepos)
-      .match($filaten({ pulls: { mtime: $stale("1d") } }))
+      .match($flatten({ pulls: { mtime: $stale("1d") } }))
       .project({ repository: 1 })
       .aggregate(),
   )
     .pMap(
       async ({ repository }) => {
-        const pulls = await fetchGithubPulls(repository).then(TaskOK).catch(TaskError);
+        const pulls = await fetchGithubPulls(repository as string)
+          .then(TaskOK)
+          .catch(TaskError);
         match(pulls)
-          .with($OK, ({ data }) => console.debug(`[DEBUG] fetched ${data.length} Pulls from ${repository}`))
+          .with($OK, ({ data }) =>
+            console.debug(`[DEBUG] fetched ${data.length} Pulls from ${repository}`),
+          )
           .otherwise(() => {});
         return await CNRepos.updateOne({ repository }, { $set: { pulls } });
       },

package/src/updateCNReposPullsDashboard.ts

@@ -2,24 +2,26 @@ import DIE from "@snomiao/die";
 import { match } from "ts-pattern";
 import { $OK } from "../packages/mongodb-pipeline-ts/Task";
 import { CNRepos } from "./CNRepos";
-import { $filaten, $fresh } from "./db";
-import { gh } from "./gh";
+import { $flatten, $fresh } from "./db";
+import { gh } from "@/lib/github";
 import { ghUser } from "./ghUser";
-import { parseUrlRepoOwner, stringifyOwnerRepo } from "./parseOwnerRepo";
+import { parseGithubRepoUrl, stringifyOwnerRepo } from "./parseOwnerRepo";
 
 export async function updateCNRepoPullsDashboard() {
-  if (ghUser.login !== "snomiao") return [];
+  if ((await 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"));
+  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 repos = await CNRepos.find($flatten({ 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 repoName = stringifyOwnerRepo(parseGithubRepoUrl(repo.repository));
       const body = crPulls
         .filter((e) => e.pull.prState !== "closed")
         .map((e) => {
@@ -31,7 +33,7 @@ export async function updateCNRepoPullsDashboard() {
           };
         })
         .map(({ href, name }) => `- [${name}](${href})`)
-        .toSorted()
+        .sort()
         .join("\n");
       return body;
     })
@@ -41,7 +43,7 @@ export async function updateCNRepoPullsDashboard() {
 
   return [
     await gh.issues.update({
-      ...parseUrlRepoOwner(dashBoardRepo),
+      ...parseGithubRepoUrl(dashBoardRepo),
       issue_number: dashBoardIssueNumber,
       body,
     }),

package/src/updateCNReposRelatedPulls.ts

@@ -3,7 +3,7 @@ import pMap from "p-map";
 import { match } from "ts-pattern";
 import { $OK, TaskError, TaskOK } from "../packages/mongodb-pipeline-ts/Task";
 import { CNRepos } from "./CNRepos";
-import { $filaten, $stale } from "./db";
+import { $flatten, $stale } from "./db";
 import { matchRelatedPulls } from "./matchRelatedPulls";
 import { tLog } from "./utils/tLog";
 if (import.meta.main) {
@@ -12,8 +12,8 @@ if (import.meta.main) {
 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) => {
+    CNRepos.find($flatten({ pulls: { state: "ok" }, crPulls: { mtime: $stale("1d") } })),
+    async (repo, _i) => {
       const { repository } = repo;
       const pulls = match(repo.pulls)
         .with($OK, (e) => e.data)

package/src/updateCRNodes.ts

@@ -4,9 +4,10 @@ import { filter, groupBy, values } from "rambda";
 import YAML from "yaml";
 import { TaskOK } from "../packages/mongodb-pipeline-ts/Task";
 import { CNRepos } from "./CNRepos";
+import { UNCLAIMED_ADMIN_PUBLISHER_ID } from "./constants";
 import { CRNodes } from "./CRNodes";
 import { fetchCRNodes } from "./fetchComfyRegistryNodes";
-import { notifySlack } from "./slack/notifySlack";
+import { notifySlack } from "@/lib/slack/notifySlack";
 import { tLog } from "./utils/tLog";
 
 if (import.meta.main) {
@@ -14,7 +15,11 @@ if (import.meta.main) {
   console.log("CRNodes updated");
 
   peekYaml(
-    await $pipeline(CNRepos).project({ repository: 1, on_registry: 1 }).sample({ size: 8 }).aggregate().toArray(),
+    await $pipeline(CNRepos)
+      .project({ repository: 1, on_registry: 1 })
+      .sample({ size: 8 })
+      .aggregate()
+      .toArray(),
   );
 }
 export async function updateCRNodes() {
@@ -22,17 +27,31 @@ export async function updateCRNodes() {
 
   // check src duplicated
   const group = groupBy((e) => e.repository, nodes);
-  const duplicates = filter((e) => e.length > 1, group);
+  const duplicates = filter((e) => (e?.length ?? 0) > 1, group);
   if (values(duplicates).length) {
     const msg =
-      "[WARN] Same repo but different ids found in comfyregistry:\n" + "```\n" + YAML.stringify(duplicates) + "\n```";
+      "[WARN] Same repo but different ids found in comfyregistry:\n" +
+      "```\n" +
+      YAML.stringify(duplicates) +
+      "\n```";
     await notifySlack(msg, { unique: true });
   }
 
+  const CRNodesRepo = nodes.map(({ repository }) => repository).filter(Boolean);
+  const CRNodesRepoExcludeUnclaimed = nodes
+    .filter((e) => e.publisher.id !== UNCLAIMED_ADMIN_PUBLISHER_ID)
+    .map(({ repository }) => repository)
+    .filter(Boolean);
   return [
     await $pipeline(CNRepos)
       .project({ repository: 1 })
-      .set({ on_registry: TaskOK({ $in: ["$repository", nodes.map(({ repository }) => repository).filter(Boolean)] }) })
+      .match({
+        repository: { $exists: true, $ne: null as unknown as string, $type: "string" },
+      })
+      .set({
+        on_registry_all: TaskOK({ $in: ["$repository", CRNodesRepo] }),
+        on_registry: TaskOK({ $in: ["$repository", CRNodesRepoExcludeUnclaimed] }),
+      })
       .merge({ into: "CNRepos", on: "repository", whenMatched: "merge", whenNotMatched: "insert" })
       .aggregate()
       .next(),