comfy-pr 0.2.19 → 0.2.24

package/src/cli.ts

@@ -1,40 +1,40 @@
-#!bun
-import DIE from "@snomiao/die";
-import { readFile } from "fs/promises";
-import { argv, $ as zx } from "zx";
-import { checkComfyActivated } from "./checkComfyActivated";
-import { createComfyRegistryPullRequests } from "./createComfyRegistryPullRequests";
-zx.verbose = true;
-
-if (argv.help) {
-  console.log(
-    `
-  bunx comfy-pr --repolist repos.txt       one repo per-line
-  bunx comfy-pr [...GITHUB_REPO_URLS]      github repos
-  bunx cross-env REPO=https://github.com/OWNER/REPO bunx comfy-pr
-    `.trim(),
-  );
-}
-
-{
-  await checkComfyActivated();
-
-  const envRepos =
-    process.env.REPO?.split("\n")
-      .map((e) => e.trim())
-      .filter(Boolean) || [];
-  const argvRepos = argv._.filter((a) => !a.endsWith(import.meta.filename));
-  const listRepos =
-    (argv.repolist &&
-      (await readFile(argv.repolist, "utf8").catch(() => ""))
-        .split("\n")
-        .map((e) => e.trim())
-        .filter(Boolean)) ||
-    [];
-  const repos = (listRepos.length && listRepos) ||
-    (argvRepos.length && argvRepos) ||
-    (envRepos.length && envRepos) || [DIE("Missing PR target, please set env.REPO")];
-  for await (const upstreamUrl of repos) {
-    await createComfyRegistryPullRequests(upstreamUrl);
-  }
-}
+#!bun
+import DIE from "@snomiao/die";
+import { readFile } from "fs/promises";
+import { argv, $ as zx } from "zx";
+import { checkComfyActivated } from "./checkComfyActivated";
+import { createComfyRegistryPullRequests } from "./createComfyRegistryPullRequests";
+zx.verbose = true;
+
+if (argv.help) {
+  console.log(
+    `
+  bunx comfy-pr --repolist repos.txt       one repo per-line
+  bunx comfy-pr [...GITHUB_REPO_URLS]      github repos
+  bunx cross-env REPO=https://github.com/OWNER/REPO bunx comfy-pr
+    `.trim(),
+  );
+}
+
+{
+  await checkComfyActivated();
+
+  const envRepos =
+    process.env.REPO?.split("\n")
+      .map((e) => e.trim())
+      .filter(Boolean) || [];
+  const argvRepos = argv._.filter((a) => !a.endsWith(import.meta.filename));
+  const listRepos =
+    (argv.repolist &&
+      (await readFile(argv.repolist, "utf8").catch(() => ""))
+        .split("\n")
+        .map((e) => e.trim())
+        .filter(Boolean)) ||
+    [];
+  const repos = (listRepos.length && listRepos) ||
+    (argvRepos.length && argvRepos) ||
+    (envRepos.length && envRepos) || [DIE("Missing PR target, please set env.REPO")];
+  for await (const upstreamUrl of repos) {
+    await createComfyRegistryPullRequests(upstreamUrl);
+  }
+}

package/src/clone_modify_push_Branches.ts

@@ -1,21 +1,21 @@
-import { makePublishcrBranch } from "./makePublishBranch";
-import { makePyprojectBranch } from "./makeTomlBranch";
-
-export async function clone_modify_push_Branches(
-  upstreamUrl: string,
-  forkUrl: string,
-) {
-  return (
-    await Promise.all([
-      makePyprojectBranch(upstreamUrl, forkUrl),
-      makePublishcrBranch(upstreamUrl, forkUrl),
-    ])
-  ).map(({ body, branch, title, type }) => ({
-    body,
-    branch,
-    title,
-    type,
-    srcUrl: forkUrl,
-    dstUrl: upstreamUrl,
-  }));
-}
+import { makePublishcrBranch } from "./makePublishBranch";
+import { makePyprojectBranch } from "./makeTomlBranch";
+
+export async function clone_modify_push_Branches(
+  upstreamUrl: string,
+  forkUrl: string,
+) {
+  return (
+    await Promise.all([
+      makePyprojectBranch(upstreamUrl, forkUrl),
+      makePublishcrBranch(upstreamUrl, forkUrl),
+    ])
+  ).map(({ body, branch, title, type }) => ({
+    body,
+    branch,
+    title,
+    type,
+    srcUrl: forkUrl,
+    dstUrl: upstreamUrl,
+  }));
+}

package/src/createComfyRegistryPRsFromCandidates.ts

@@ -1,55 +1,55 @@
-import { $pipeline } from "@/packages/mongodb-pipeline-ts/$pipeline";
-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 { createComfyRegistryPullRequests } from "./createComfyRegistryPullRequests";
-import { $filaten, $stale } from "./db";
-import { parseUrlRepoOwner, stringifyOwnerRepo } from "./parseOwnerRepo";
-import { notifySlackLinks } from "./slack/notifySlackLinks";
-import { tLog } from "./utils/tLog";
-if (import.meta.main) {
-  await tLog("createComfyRegistryPRsFromCandidates", createComfyRegistryPRsFromCandidates);
-  console.log("all done");
-}
-export async function createComfyRegistryPRsFromCandidates() {
-  await CNRepos.createIndex($filaten({ candidate: { data: 1 } }));
-  await CNRepos.createIndex(
-    $filaten({
-      candidate: { data: 1 },
-      createdPulls: { state: 1, mtime: 1 },
-    }),
-  );
-  return await pMap(
-    $pipeline(CNRepos)
-      .match(
-        $filaten({
-          candidate: { data: { $eq: true } },
-          createdPulls: { state: { $ne: "ok" }, mtime: $stale("5m") },
-        }),
-      )
-      .aggregate(),
-    async (repo) => {
-      const { repository } = repo;
-      console.log("Making PRs for " + repository);
-      const createdPulls = await createComfyRegistryPullRequests(repository).then(TaskOK).catch(TaskError);
-      match(createdPulls).with($OK, async ({ data }) => {
-        const links = data.map((e) => ({
-          href: e.html_url,
-          name: stringifyOwnerRepo(parseUrlRepoOwner(e.html_url.replace(/\/pull\/.*$/, ""))) + " #" + e.title,
-        }));
-        await notifySlackLinks("PR just Created, @HaoHao check plz", links);
-        await pMap(data, async (pull) => {
-          const { html_url } = pull;
-          // also update to crPulls
-          await CNRepos.updateOne($filaten({ repository, crPulls: { data: { pull: { html_url } } } }), {
-            $set: { "crPulls.data.$.pull": pull },
-          });
-        });
-      });
-
-      return await CNRepos.updateOne({ repository }, { $set: { createdPulls } });
-    },
-    { concurrency: 2, stopOnError: false },
-  );
-}
+import { $pipeline } from "@/packages/mongodb-pipeline-ts/$pipeline";
+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 { createComfyRegistryPullRequests } from "./createComfyRegistryPullRequests";
+import { $filaten, $stale } from "./db";
+import { parseUrlRepoOwner, stringifyOwnerRepo } from "./parseOwnerRepo";
+import { notifySlackLinks } from "./slack/notifySlackLinks";
+import { tLog } from "./utils/tLog";
+if (import.meta.main) {
+  await tLog("createComfyRegistryPRsFromCandidates", createComfyRegistryPRsFromCandidates);
+  console.log("all done");
+}
+export async function createComfyRegistryPRsFromCandidates() {
+  await CNRepos.createIndex($filaten({ candidate: { data: 1 } }));
+  await CNRepos.createIndex(
+    $filaten({
+      candidate: { data: 1 },
+      createdPulls: { state: 1, mtime: 1 },
+    }),
+  );
+  return await pMap(
+    $pipeline(CNRepos)
+      .match(
+        $filaten({
+          candidate: { data: { $eq: true } },
+          createdPulls: { state: { $ne: "ok" }, mtime: $stale("5m") },
+        }),
+      )
+      .aggregate(),
+    async (repo) => {
+      const { repository } = repo;
+      console.log("Making PRs for " + repository);
+      const createdPulls = await createComfyRegistryPullRequests(repository).then(TaskOK).catch(TaskError);
+      match(createdPulls).with($OK, async ({ data }) => {
+        const links = data.map((e) => ({
+          href: e.html_url,
+          name: stringifyOwnerRepo(parseUrlRepoOwner(e.html_url.replace(/\/pull\/.*$/, ""))) + " #" + e.title,
+        }));
+        await notifySlackLinks("PR just Created, @HaoHao check plz", links);
+        await pMap(data, async (pull) => {
+          const { html_url } = pull;
+          // also update to crPulls
+          await CNRepos.updateOne($filaten({ repository, crPulls: { data: { pull: { html_url } } } }), {
+            $set: { "crPulls.data.$.pull": pull },
+          });
+        });
+      });
+
+      return await CNRepos.updateOne({ repository }, { $set: { createdPulls } });
+    },
+    { concurrency: 2, stopOnError: false },
+  );
+}

package/src/createComfyRegistryPullRequests.ts

@@ -1,22 +1,22 @@
-import pMap from "p-map";
-import yaml from "yaml";
-// import { chalk } from "zx";
-import { clone_modify_push_Branches } from "./clone_modify_push_Branches";
-import { createGithubForkForRepo } from "./createGithubForkForRepo";
-import { createGithubPullRequest } from "./createGithubPullRequest";
-import type { GithubPull } from "./gh/GithubPull";
-import { parsePulls } from "./parsePullsState";
-
-export async function createComfyRegistryPullRequests(upstreamRepoUrl: string) {
-  const forkedRepo = await createGithubForkForRepo(upstreamRepoUrl);
-  const PR_REQUESTS = await clone_modify_push_Branches(upstreamRepoUrl, forkedRepo.html_url);
-  // branch is ready in fork now
-  // create prs for each branch
-  console.log("Going to create PRs for the following branches:");
-  // console.log(chalk.green(yaml.stringify({ PR_REQUESTS })));
-  console.log(yaml.stringify({ PR_REQUESTS }));
-  // prs
-  const prs = await pMap(PR_REQUESTS, async ({ type, ...prInfo }) => await createGithubPullRequest({ ...prInfo }));
-  console.log("ALL PRs DONE");
-  return (prs as GithubPull[]).map((e) => parsePulls([e])[0]);
-}
+import pMap from "p-map";
+import yaml from "yaml";
+// import { chalk } from "zx";
+import { clone_modify_push_Branches } from "./clone_modify_push_Branches";
+import { createGithubForkForRepo } from "./createGithubForkForRepo";
+import { createGithubPullRequest } from "./createGithubPullRequest";
+import type { GithubPull } from "./gh/GithubPull";
+import { parsePulls } from "./parsePullsState";
+
+export async function createComfyRegistryPullRequests(upstreamRepoUrl: string) {
+  const forkedRepo = await createGithubForkForRepo(upstreamRepoUrl);
+  const PR_REQUESTS = await clone_modify_push_Branches(upstreamRepoUrl, forkedRepo.html_url);
+  // branch is ready in fork now
+  // create prs for each branch
+  console.log("Going to create PRs for the following branches:");
+  // console.log(chalk.green(yaml.stringify({ PR_REQUESTS })));
+  console.log(yaml.stringify({ PR_REQUESTS }));
+  // prs
+  const prs = await pMap(PR_REQUESTS, async ({ type, ...prInfo }) => await createGithubPullRequest({ ...prInfo }));
+  console.log("ALL PRs DONE");
+  return (prs as GithubPull[]).map((e) => parsePulls([e])[0]);
+}

package/src/createGithubForkForRepo.ts

@@ -1,37 +1,37 @@
-import DIE from "@snomiao/die";
-import md5 from "md5";
-import minimist from "minimist";
-import { FORK_OWNER } from "./FORK_OWNER";
-import { FORK_PREFIX } from "./FORK_PREFIX";
-import { createGithubFork } from "./gh/createGithubFork";
-import { ghUser } from "./ghUser";
-import { parseUrlRepoOwner } from "./parseOwnerRepo";
-
-/**
- * this function creates a fork of the upstream repo,
- * fork to the FORK_OWNER, and add a prefix to the repo name
- * - the prefix is optional, if not provided, the repo name will be the same as the upstream repo
- * - the prefix is useful to distinguish the forked repo from the other repo in the same owner
- * SALT is used to generate a unique repo name, so that the forked repo will not conflict with other forks
- *
- * @author snomiao <snomiao@gmail.com>
- * @param upstreamRepoUrl
- * @returns forked repo info
- */
-export async function createGithubForkForRepo(upstreamRepoUrl: string) {
-  // debug
-  // console.log(`* Change env.SALT=${salt} will fork into a different repo`);
-  // console.log("PR_SRC: ", forkSSHUrl);
-  // console.log("PR_DST: ", upstreamUrl);
-  // console.log(forkSSHUrl);
-  const upstream = parseUrlRepoOwner(upstreamRepoUrl);
-  const argv = minimist(process.argv.slice(2));
-  const salt = argv.salt || process.env.SALT || "m3KMgZ2AeZGWYh7W";
-  const repo_hash = md5(`${salt}-${ghUser.name}-${upstream.owner}/${upstream.repo}`).slice(0, 8);
-  const forkRepoName = (FORK_PREFIX && `${FORK_PREFIX}${upstream.repo}-${repo_hash}`) || upstream.repo;
-  const forkDst = `${FORK_OWNER}/${forkRepoName}`;
-  const forkUrl = `https://github.com/${forkDst}`;
-  const forked = await createGithubFork(upstreamRepoUrl, forkUrl);
-  if (forked.html_url !== forkUrl) DIE("forked url not expected");
-  return forked;
-}
+import DIE from "@snomiao/die";
+import md5 from "md5";
+import minimist from "minimist";
+import { FORK_OWNER } from "./FORK_OWNER";
+import { FORK_PREFIX } from "./FORK_PREFIX";
+import { createGithubFork } from "./gh/createGithubFork";
+import { ghUser } from "./ghUser";
+import { parseUrlRepoOwner } from "./parseOwnerRepo";
+
+/**
+ * this function creates a fork of the upstream repo,
+ * fork to the FORK_OWNER, and add a prefix to the repo name
+ * - the prefix is optional, if not provided, the repo name will be the same as the upstream repo
+ * - the prefix is useful to distinguish the forked repo from the other repo in the same owner
+ * SALT is used to generate a unique repo name, so that the forked repo will not conflict with other forks
+ *
+ * @author snomiao <snomiao@gmail.com>
+ * @param upstreamRepoUrl
+ * @returns forked repo info
+ */
+export async function createGithubForkForRepo(upstreamRepoUrl: string) {
+  // debug
+  // console.log(`* Change env.SALT=${salt} will fork into a different repo`);
+  // console.log("PR_SRC: ", forkSSHUrl);
+  // console.log("PR_DST: ", upstreamUrl);
+  // console.log(forkSSHUrl);
+  const upstream = parseUrlRepoOwner(upstreamRepoUrl);
+  const argv = minimist(process.argv.slice(2));
+  const salt = argv.salt || process.env.SALT || "m3KMgZ2AeZGWYh7W";
+  const repo_hash = md5(`${salt}-${ghUser.name}-${upstream.owner}/${upstream.repo}`).slice(0, 8);
+  const forkRepoName = (FORK_PREFIX && `${FORK_PREFIX}${upstream.repo}-${repo_hash}`) || upstream.repo;
+  const forkDst = `${FORK_OWNER}/${forkRepoName}`;
+  const forkUrl = `https://github.com/${forkDst}`;
+  const forked = await createGithubFork(upstreamRepoUrl, forkUrl);
+  if (forked.html_url !== forkUrl) DIE("forked url not expected");
+  return forked;
+}

package/src/createGithubPullRequest.ts

@@ -1,94 +1,94 @@
-import DIE from "@snomiao/die";
-import yaml from "yaml";
-import { gh } from "./gh";
-import type { GithubPull } from "./gh/GithubPull";
-import { parseUrlRepoOwner } from "./parseOwnerRepo";
-
-export async function createGithubPullRequest({
-  title,
-  body,
-  branch,
-  srcUrl,
-  dstUrl,
-}: {
-  title: string;
-  body: string;
-  branch: string;
-  srcUrl: string;
-  dstUrl: string;
-}) {
-  const dst = parseUrlRepoOwner(dstUrl);
-  const src = parseUrlRepoOwner(srcUrl);
-  const repo = (await gh.repos.get({ ...dst })).data;
-
-  // TODO: seems has bugs on head_repo
-  const existedList = (
-    await gh.pulls.list({
-      // source repo
-      state: "all",
-      head_repo: src.owner + "/" + src.repo,
-      head: src.owner + ":" + branch,
-      // pr will merge into
-      owner: dst.owner,
-      repo: dst.repo,
-      base: repo.default_branch,
-    })
-  ).data;
-  if (existedList.length) {
-    const msg = {
-      PR_Existed: existedList.map((e) => ({ url: e.html_url, title: e.title })),
-    };
-    console.log(yaml.stringify(msg));
-    return existedList[0];
-  }
-  if (!process.env.GH_TOKEN_COMFY_PR) {
-    DIE("Missing env.GH_TOKEN_COMFY_PR");
-  }
-  const pr_result = await gh.pulls
-    .create({
-      // pr info
-      title,
-      body,
-      // source repo
-      head_repo: src.owner + "/" + src.repo,
-      head: src.owner + ":" + branch,
-      // pr will merge into
-      owner: dst.owner,
-      repo: dst.repo,
-      base: repo.default_branch,
-      maintainer_can_modify: true,
-      // draft: true,
-    })
-    .then((e) => e.data)
-    .catch(async (e) => {
-      if (e.message.match("A pull request already exists for")) {
-        console.log("PR Existed ", e);
-        // WARN: will search all prs
-        const existedList = (
-          await gh.pulls.list({
-            // source repo
-            state: "open",
-            head_repo: src.owner + "/" + src.repo,
-            // head: src.owner + ":" + branch,
-            // pr will merge into
-            owner: dst.owner,
-            repo: dst.repo,
-            base: repo.default_branch,
-          })
-        ).data;
-        if (existedList.length) {
-          const msg = {
-            PR_Existed: existedList.map((e) => ({
-              url: e.html_url,
-              title: e.title,
-            })),
-          };
-          console.log(yaml.stringify(msg));
-          return existedList[0];
-        }
-      }
-      throw e;
-    });
-  console.log("PR OK", pr_result.html_url);
-  return pr_result as GithubPull;
-}
+import DIE from "@snomiao/die";
+import yaml from "yaml";
+import { gh } from "./gh";
+import type { GithubPull } from "./gh/GithubPull";
+import { parseUrlRepoOwner } from "./parseOwnerRepo";
+
+export async function createGithubPullRequest({
+  title,
+  body,
+  branch,
+  srcUrl,
+  dstUrl,
+}: {
+  title: string;
+  body: string;
+  branch: string;
+  srcUrl: string;
+  dstUrl: string;
+}) {
+  const dst = parseUrlRepoOwner(dstUrl);
+  const src = parseUrlRepoOwner(srcUrl);
+  const repo = (await gh.repos.get({ ...dst })).data;
+
+  // TODO: seems has bugs on head_repo
+  const existedList = (
+    await gh.pulls.list({
+      // source repo
+      state: "all",
+      head_repo: src.owner + "/" + src.repo,
+      head: src.owner + ":" + branch,
+      // pr will merge into
+      owner: dst.owner,
+      repo: dst.repo,
+      base: repo.default_branch,
+    })
+  ).data;
+  if (existedList.length) {
+    const msg = {
+      PR_Existed: existedList.map((e) => ({ url: e.html_url, title: e.title })),
+    };
+    console.log(yaml.stringify(msg));
+    return existedList[0];
+  }
+  if (!process.env.GH_TOKEN_COMFY_PR) {
+    DIE("Missing env.GH_TOKEN_COMFY_PR");
+  }
+  const pr_result = await gh.pulls
+    .create({
+      // pr info
+      title,
+      body,
+      // source repo
+      head_repo: src.owner + "/" + src.repo,
+      head: src.owner + ":" + branch,
+      // pr will merge into
+      owner: dst.owner,
+      repo: dst.repo,
+      base: repo.default_branch,
+      maintainer_can_modify: true,
+      // draft: true,
+    })
+    .then((e) => e.data)
+    .catch(async (e) => {
+      if (e.message.match("A pull request already exists for")) {
+        console.log("PR Existed ", e);
+        // WARN: will search all prs
+        const existedList = (
+          await gh.pulls.list({
+            // source repo
+            state: "open",
+            head_repo: src.owner + "/" + src.repo,
+            // head: src.owner + ":" + branch,
+            // pr will merge into
+            owner: dst.owner,
+            repo: dst.repo,
+            base: repo.default_branch,
+          })
+        ).data;
+        if (existedList.length) {
+          const msg = {
+            PR_Existed: existedList.map((e) => ({
+              url: e.html_url,
+              title: e.title,
+            })),
+          };
+          console.log(yaml.stringify(msg));
+          return existedList[0];
+        }
+      }
+      throw e;
+    });
+  console.log("PR OK", pr_result.html_url);
+  return pr_result as GithubPull;
+}

package/src/createIssueComment.ts

@@ -1,29 +1,29 @@
-import DIE from "@snomiao/die";
-import { gh } from "./gh";
-import { ghUser } from "./ghUser";
-import { parseIssueUrl } from "./parseIssueUrl";
-
-if (import.meta.main) {
-  const url = "https://github.com/snomiao/ComfyNode-Registry-test/pull/1";
-  const body = "Hello World @snomiao";
-  const result = await createIssueComment(url, body, ghUser.login);
-  console.log(result.comment.html_url);
-  console.log(result.comments.map((e) => e.html_url));
-}
-
-export async function createIssueComment(issueUrl: string, body: string, by: string) {
-  const comments = (
-    await gh.issues.listComments({
-      ...parseIssueUrl(issueUrl),
-    })
-  ).data;
-  const result = await (async function () {
-    const commentExisted = comments.find((e) => e.body === body);
-    if (commentExisted) return { comment: commentExisted, comments };
-    if (by !== ghUser.login) DIE("Fails to creating issue: user not match");
-    const comment = (await gh.issues.createComment({ ...parseIssueUrl(issueUrl), body })).data;
-    console.log("comment created: " + comment.html_url);
-    return { comment, comments: [...comments, comment] };
-  })();
-  return result;
-}
+import DIE from "@snomiao/die";
+import { gh } from "./gh";
+import { ghUser } from "./ghUser";
+import { parseIssueUrl } from "./parseIssueUrl";
+
+if (import.meta.main) {
+  const url = "https://github.com/snomiao/ComfyNode-Registry-test/pull/1";
+  const body = "Hello World @snomiao";
+  const result = await createIssueComment(url, body, ghUser.login);
+  console.log(result.comment.html_url);
+  console.log(result.comments.map((e) => e.html_url));
+}
+
+export async function createIssueComment(issueUrl: string, body: string, by: string) {
+  const comments = (
+    await gh.issues.listComments({
+      ...parseIssueUrl(issueUrl),
+    })
+  ).data;
+  const result = await (async function () {
+    const commentExisted = comments.find((e) => e.body === body);
+    if (commentExisted) return { comment: commentExisted, comments };
+    if (by !== ghUser.login) DIE("Fails to creating issue: user not match");
+    const comment = (await gh.issues.createComment({ ...parseIssueUrl(issueUrl), body })).data;
+    console.log("comment created: " + comment.html_url);
+    return { comment, comments: [...comments, comment] };
+  })();
+  return result;
+}

package/src/fetchCMNodes.ts

@@ -1,22 +1,22 @@
-import { fetchJson } from "./utils/fetchJson";
-
-if (import.meta.main) {
-  console.log(await fetchCMNodes());
-}
-export async function fetchCMNodes() {
-  const customNodeListSource =
-    process.env.CUSTOM_LIST_SOURCE ||
-    "https://raw.githubusercontent.com/ltdrdata/ComfyUI-Manager/main/custom-node-list.json";
-  const nodeList = (await fetchJson(customNodeListSource)) as {
-    custom_nodes: {
-      author: "Dr.Lt.Data" | string;
-      title: "ComfyUI-Manager" | string;
-      id: "manager" | string;
-      reference: "https://github.com/ltdrdata/ComfyUI-Manager" | string;
-      files: ["https://github.com/ltdrdata/ComfyUI-Manager"] | string[];
-      install_type: "git-clone" | string;
-      description: "ComfyUI-Manager itself is also a custom node." | string;
-    }[];
-  };
-  return nodeList.custom_nodes;
-}
+import { fetchJson } from "./utils/fetchJson";
+
+if (import.meta.main) {
+  console.log(await fetchCMNodes());
+}
+export async function fetchCMNodes() {
+  const customNodeListSource =
+    process.env.CUSTOM_LIST_SOURCE ||
+    "https://raw.githubusercontent.com/ltdrdata/ComfyUI-Manager/main/custom-node-list.json";
+  const nodeList = (await fetchJson(customNodeListSource)) as {
+    custom_nodes: {
+      author: "Dr.Lt.Data" | string;
+      title: "ComfyUI-Manager" | string;
+      id: "manager" | string;
+      reference: "https://github.com/ltdrdata/ComfyUI-Manager" | string;
+      files: ["https://github.com/ltdrdata/ComfyUI-Manager"] | string[];
+      install_type: "git-clone" | string;
+      description: "ComfyUI-Manager itself is also a custom node." | string;
+    }[];
+  };
+  return nodeList.custom_nodes;
+}