comfy-pr 0.2.7

package/src/WorkerInstances.ts

@@ -0,0 +1,89 @@
+import { getMAC } from "@ctrl/mac-address";
+import { defer } from "lodash-es";
+import md5 from "md5";
+import type { WithId } from "mongodb";
+import { db } from "./db";
+import { fetchCurrentGeoInfo } from "./fetchCurrentGeoInfo";
+import { createInstanceId } from "./utils/createInstanceId";
+export type GeoInfo = Awaited<ReturnType<typeof fetchCurrentGeoInfo>>;
+export type WorkerInstance = {
+  /** id: rand */
+  id: string;
+  up: Date;
+  active: Date;
+  geo: GeoInfo;
+  workerId: string;
+  task?: string;
+};
+
+const k = "COMFY_PR_WorkerInstanceKey";
+type g = typeof globalThis & { [k]: any };
+function getWorkerInstanceId() {
+  // ensure only one instance
+  if (!(global as any as g)[k])
+    defer(async function () {
+      await Promise.all([postWorkerHeartBeatLoop(), watchWorkerInstancesLoop()]);
+    });
+  const instanceId = ((global as any as g)[k] ??= createInstanceId());
+  return instanceId;
+}
+export const WorkerInstances = db.collection<WorkerInstance>("WorkerInstances");
+await WorkerInstances.createIndex({ id: 1 }, { unique: true });
+await WorkerInstances.createIndex({ ip: 1 });
+export const _geoPromise = fetchCurrentGeoInfo(); // in background
+
+if (import.meta.main) {
+  console.log(await getWorkerInstance());
+}
+
+async function postWorkerHeartBeatLoop() {
+  // 30s heartbeat
+  while (true) {
+    await new Promise((r) => setTimeout(r, 30e3));
+    await getWorkerInstance();
+  }
+}
+
+async function watchWorkerInstancesLoop() {
+  const me = await getWorkerInstance();
+  console.log("[INIT] Worker instance " + me.id + " is up.");
+  for await (const event of WorkerInstances.watch([], {
+    fullDocument: "whenAvailable",
+  })) {
+    const { fullDocument: updated } = event as typeof event & {
+      fullDocument?: WithId<WorkerInstance>;
+    };
+    if (updated && updated.id !== me.id) {
+      console.log("Another worker is updated", updated);
+      if (+updated.up > +me.up && updated.task === me.task) {
+        console.log("[EXIT] I'm outdated, new instance is: " + updated.id);
+        process.exit(0);
+      }
+    }
+  }
+}
+
+export async function getWorkerInstance(task?: string) {
+  const id = getWorkerInstanceId();
+  if (task) {
+    console.log("Working on task: ", task);
+  }
+  return (await WorkerInstances.findOneAndUpdate(
+    { id },
+    {
+      $set: {
+        id,
+        active: new Date(),
+        workerId: getWorkerId(),
+        geo: await _geoPromise,
+        ...(task && { task }),
+      },
+      $setOnInsert: { up: new Date() },
+    },
+    { upsert: true, returnDocument: "after" },
+  ))!;
+}
+function getWorkerId() {
+  const hostname = process.env.HOSTNAME || process.env.COMPUTERNAME;
+  return md5(`SALT=v9yJQouMC22do66t ${hostname} ${getMAC()}`).slice(0, 8);
+}

package/src/analyzePullsStatus.ts

@@ -0,0 +1,115 @@
+import { $pipeline } from "@/packages/mongodb-pipeline-ts/$pipeline";
+import { peekYaml } from "peek-log";
+import prettyMs from "pretty-ms";
+import type { z } from "zod";
+import { CNRepos, type CRPull } from "./CNRepos";
+import type { GithubIssueComment } from "./GithubIssueComments";
+import { db } from "./db";
+import type { Task } from "./utils/Task";
+import type { zPullStatus } from "./zod/zPullsStatus";
+// import { $pipeline } from "./db/$pipeline";
+// in case of dump production in local environment:
+// bun --env-file .env.production.local src/dump.ts > dump.csv
+export const DashboardDetails = db.collection<any>("DashboardDetails");
+if (import.meta.main) {
+  const r = peekYaml(await analyzePullsStatus());
+  // await mkdir(".cache").catch(() => null);
+  // await writeFile(".cache/dump.yaml", YAML.stringify(r));
+  // await writeFile(".cache/dump.csv", csvFormat(r));
+  // console.log("done");
+  // generate zod schema
+  // await writeFile("src/zPullsStatus.ts", jsonToZod(await analyzePullsStatus({ limit: 1 }), "zPullsStatus", true));
+}
+
+export type PullStatus = z.infer<typeof zPullStatus>;
+export type PullsStatus = PullStatus[] &
+  {
+    lastwords: string;
+    repository: string;
+    author_email: string;
+    ownername: string;
+    on_registry: boolean;
+    state: "OPEN" | "MERGED" | "CLOSED";
+    url: string;
+    head: string;
+    comments: number;
+    updated: string;
+  }[];
+export async function analyzePullsStatus({ skip = 0, limit = 0 } = {}) {
+  "use server";
+  return await analyzePullsStatusPipeline()
+    .skip(skip)
+    .limit(limit || 2 ** 31 - 1)
+    .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, "..."),
+      };
+    })
+    .toArray();
+}
+export function analyzePullsStatusPipeline() {
+  return (
+    $pipeline(CNRepos)
+      .unwind("$crPulls.data")
+      .match({ "crPulls.data.comments.data": { $exists: true } })
+      .set({ "crPulls.data.pull.repo": "$repository" })
+      .set({ "crPulls.data.pull.on_registry": "$on_registry" })
+      .set({ "crPulls.data.pull.type": "$crPulls.data.type" })
+      .set({ "crPulls.data.pull.comments": "$crPulls.data.comments.data" })
+      .set({ "crPulls.data.pull": "$crPulls.data.pull" })
+      .replaceRoot({ newRoot: "$crPulls.data.pull" })
+      .as<
+        CRPull & {
+          repo: string;
+          on_registry: Task<boolean>;
+          type: string;
+          comments: GithubIssueComment[];
+        }
+      >()
+      .project({
+        created_at: { $toDate: "$created_at" },
+        updated_at: { $toDate: "$updated_at" },
+        repository: 1,
+        on_registry: "$on_registry.data",
+        on_registry_at: "$on_registry.mtime",
+        state: { $toUpper: `$prState` },
+        url: "$html_url",
+        author_email: "$base.user.email",
+        ownername: "$base.user.login",
+        head: { $concat: ["$user.login", ":", "$type"] },
+        comments: { $size: "$comments" },
+        lastwords: { $arrayElemAt: ["$comments", -1] },
+      })
+      .set({ lastwords: { $concat: ["$lastwords.user.login", ": ", "$lastwords.body"] } })
+      .set({ lastwords: { $ifNull: ["$lastwords", ""] } })
+      // .set({ state: { $nin: ["CLOSED"] } })
+      .set({
+        CLOSED: { $eq: ["$state", "CLOSED"] },
+        MERGED: { $eq: ["$state", "MERGED"] },
+        OPEN: { $eq: ["$state", "OPEN"] },
+      })
+      .sort({ ownername: 1 })
+      .sort({ OPEN: -1, MERGED: -1, CLOSED: -1, updated_at: 1 })
+      .unset(["CLOSED", "MERGED", "OPEN"])
+      .as<{
+        updated_at: Date;
+        created_at: Date;
+        repository: string;
+        author_email: string;
+        ownername: string;
+        on_registry: boolean;
+        on_registry_at: Date;
+        state: "OPEN" | "MERGED" | "CLOSED";
+        url: string;
+        head: string;
+        comments: number;
+        lastwords: string;
+      }>()
+    // .stage({ ...(!!skip && { $skip: skip }) })
+    // .stage({ ...(!!limit && { $limit: limit }) })
+  );
+}

package/src/analyzeTotals.test.ts

@@ -0,0 +1,5 @@
+import { analyzeTotals } from "./analyzeTotals";
+
+it("analyze totals", async () => {
+  expect(await analyzeTotals()).toBeTruthy();
+});

package/src/analyzeTotals.ts

@@ -0,0 +1,114 @@
+"use server";
+import { $pipeline } from "@/packages/mongodb-pipeline-ts/$pipeline";
+import promiseAllProperties from "promise-all-properties";
+import YAML from "yaml";
+import { CMNodes } from "./CMNodes";
+import { CNRepos } from "./CNRepos";
+import { CRNodes } from "./CRNodes";
+import { $filaten } from "./db";
+import { tLog } from "./utils/tLog";
+
+if (import.meta.main) {
+  await tLog("analyzeTotals", async () => {
+    console.log(YAML.stringify(await analyzeTotals()));
+    return [];
+  });
+}
+/**
+ * @warning this function is heavy
+ */
+export async function analyzeTotals() {
+  "use server";
+  const totals = await promiseAllProperties({
+    Now: new Date().toISOString(),
+    "Total Nodes": promiseAllProperties({
+      "on ComfyUI Manager": CMNodes.estimatedDocumentCount(),
+      "on Registry": CRNodes.estimatedDocumentCount(),
+    }),
+    "Total Repos": $pipeline(CNRepos)
+      .group({
+        _id: null,
+        "on Comfy Manager List": { $sum: { $cond: [{ $eq: [{ $type: "$cm" }, "missing"] }, 0, 1] } },
+        "on Registry": { $sum: { $cond: [{ $eq: [{ $type: "$cr" }, "missing"] }, 0, 1] } },
+        Archived: { $sum: { $cond: ["$info.data.archived", 1, 0] } },
+        All: { $sum: 1 },
+        // Candidates: { $sum: { $cond: ["$candidate.data", 1, 0] } },
+        "Got ERROR on creating PR": { $sum: { $cond: [{ $eq: ["$createdPulls.state", "error"] }, 1, 0] } },
+      })
+      .project({ _id: 0 })
+      .aggregate()
+      // .map((e: any) => e.pairs)
+      .next(),
+    "Total Authors": $pipeline(CNRepos)
+      .match($filaten({ info: { data: { owner: { login: { $exists: true } } } } }))
+      .group({
+        _id: "$info.data.owner.login",
+        // author: "$info.data.owner.email",
+        "on Comfy Manager List": { $sum: { $cond: [{ $eq: [{ $type: "$cm" }, "missing"] }, 0, 1] } },
+        "on Registry": { $sum: { $cond: [{ $eq: [{ $type: "$cr" }, "missing"] }, 0, 1] } },
+        Archived: { $sum: { $cond: ["$info.data.archived", 1, 0] } },
+        All: { $sum: 1 },
+      })
+      .project({ _id: 0 })
+      .aggregate()
+      // .map((e: any) => e.pairs)
+      .next(),
+    "Total PRs Made": $pipeline(CNRepos)
+      .unwind("$crPulls.data")
+      .group({ _id: "$crPulls.data.type", total: { $sum: 1 } })
+      .sort({ _id: 1 })
+      .set({ id_total: [["$_id", "$total"]] })
+      .group({ _id: null, pairs: { $mergeObjects: { $arrayToObject: "$id_total" } } })
+      .aggregate()
+      .map((e: any) => e.pairs)
+      .next(),
+    "Total Open": $pipeline(CNRepos)
+      .unwind("$crPulls.data")
+      .match({ "crPulls.data.pull.prState": "open" })
+      .group({ _id: "$crPulls.data.type", total: { $sum: 1 } })
+      .sort({ _id: 1 })
+      .set({ id_total: [["$_id", "$total"]] })
+      .group({ _id: null, pairs: { $mergeObjects: { $arrayToObject: "$id_total" } } })
+      .aggregate()
+      .map((e: any) => e.pairs)
+      .next(),
+    "Total Merged (on Registry)": $pipeline(CNRepos)
+      .unwind("$crPulls.data")
+      .match({ cr: { $exists: true }, "crPulls.data.pull.prState": "merged" })
+      .group({ _id: "$crPulls.data.type", total: { $sum: 1 } })
+      .sort({ _id: 1 })
+      .set({ id_total: [["$_id", "$total"]] })
+      .group({ _id: null, pairs: { $mergeObjects: { $arrayToObject: "$id_total" } } })
+      .aggregate()
+      .map((e: any) => e.pairs)
+      .next(),
+    "Total Merged (not on Registry)": $pipeline(CNRepos)
+      .unwind("$crPulls.data")
+      .match({ cr: { $exists: false }, "crPulls.data.pull.prState": "merged" })
+      .group({ _id: "$crPulls.data.type", total: { $sum: 1 } })
+      .sort({ _id: 1 })
+      .set({ id_total: [["$_id", "$total"]] })
+      .group({ _id: null, pairs: { $mergeObjects: { $arrayToObject: "$id_total" } } })
+      .aggregate()
+      .map((e: any) => e.pairs)
+      .next(),
+    "Total Closed": $pipeline(CNRepos)
+      .unwind("$crPulls.data")
+      .match({ "crPulls.data.pull.prState": "closed" })
+      .group({ _id: "$crPulls.data.type", total: { $sum: 1 } })
+      .sort({ _id: 1 })
+      .set({ id_total: [["$_id", "$total"]] })
+      .group({ _id: null, pairs: { $mergeObjects: { $arrayToObject: "$id_total" } } })
+      .aggregate()
+      .map((e: any) => e.pairs)
+      .next(),
+
+    // // Follow Rules
+    // "Follow Up Rules": (async function () {
+    //   await pMap($pipeline(FollowRuleSets).aggregate(), async (ruleset) => {
+
+    //   });
+    // })(),
+  });
+  return totals;
+}

package/src/checkComfyActivated.ts

@@ -0,0 +1,39 @@
+import DIE from "@snomiao/die";
+import { $ as bunSh } from "bun";
+import { os } from "zx";
+import { getActivateCMD } from "./cli/getActivateCMD";
+
+export async function checkComfyActivated() {
+  console.log("Checking ComfyUI Activated...");
+
+  if (!(await bunSh`comfy --help`.quiet().catch(() => null))) {
+    const activate = getActivateCMD();
+    // apt-get install -y python3 python3-venv
+    const installPython =
+      os.platform() === "win32"
+        ? "python3 --version || winget install python3 || choco install -y python3"
+        : "apt-get install -y python3 python3-venv";
+
+    await bunSh`
+${installPython}
+python -m venv .venv
+${activate}
+pip install comfy-cli
+comfy-cli --help
+`.catch(console.error);
+
+    DIE(
+      `
+Cound not found comfy-cli.
+Please install comfy-cli before run "bunx comfy-pr" here.
+
+$ >>>>>>>>>>>>>>>>>>>>>>>>>>
+${installPython}
+python -m venv .venv
+${activate}
+pip install comfy-cli
+comfy-cli --help
+`.trim(),
+    );
+  }
+}

package/src/cli.ts

@@ -0,0 +1,40 @@
+#!bun
+import DIE from "@snomiao/die";
+import { readFile } from "fs/promises";
+import { argv } from "zx";
+import { checkComfyActivated } from "./checkComfyActivated";
+import { createComfyRegistryPullRequests } from "./createComfyRegistryPullRequests";
+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

@@ -0,0 +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,
+  }));
+}

package/src/createComfyRegistryPRsFromCandidates.ts

@@ -0,0 +1,55 @@
+import { $pipeline } from "@/packages/mongodb-pipeline-ts/$pipeline";
+import pMap from "p-map";
+import { match } from "ts-pattern";
+import { CNRepos } from "./CNRepos";
+import { createComfyRegistryPullRequests } from "./createComfyRegistryPullRequests";
+import { $filaten, $stale } from "./db";
+import { parseUrlRepoOwner, stringifyOwnerRepo } from "./parseOwnerRepo";
+import { notifySlackLinks } from "./slack/notifySlackLinks";
+import { $OK, TaskError, TaskOK } from "./utils/Task";
+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

@@ -0,0 +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]);
+}

package/src/createGithubForkForRepo.ts

@@ -0,0 +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;
+}

package/src/createGithubPullRequest.ts

@@ -0,0 +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;
+}

package/src/createIssueComment.ts

@@ -0,0 +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;
+}