comfy-pr 0.2.24 → 0.2.25

package/src/checkComfyActivated.ts

@@ -1,39 +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(),
-    );
-  }
-}
+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

@@ -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,40 @@
-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, it's likely you already forked this repo in your account before, and now trying to fork it again with different salt. To recovery you could delete that repo forked before by manual. (the repo forked before is listed in FORK OK: .....)",
+    );
+  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;
+}