comfy-pr 0.2.24 → 0.2.26

package/src/createGithubPullRequest.ts

@@ -1,94 +1,157 @@
-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, { catchArgs } from "@snomiao/die";
+import "git-diff";
+import { Octokit } from "octokit";
+import { pickAll } from "rambda";
+import sflow from "sflow";
+import { isRepoBypassed } from "./bypassRepos";
+import { gh } from "./gh";
+import type { GithubPull } from "./gh/GithubPull";
+import { parseUrlRepoOwner } from "./parseOwnerRepo";
+if (import.meta.main) {
+  const srcUrl = "https://github.com/ComfyNodePRs/PR-ComfyUI-DareMerge-7bcbf6a9";
+  const dstUrl = "https://github.com/54rt1n/ComfyUI-DareMerge";
+  const src = parseUrlRepoOwner(srcUrl);
+  const dst = parseUrlRepoOwner(dstUrl);
+  const branch = "licence-update";
+  const repo = (await gh.repos.get({ ...dst })).data;
+  const head_repo = `${src.owner}/${src.repo}`;
+  // const head = `${src.owner}:${branch}`;
+  const head = `${src.owner}:licence-update`;
+  console.log("headrepo " + head_repo);
+  console.log("head " + head);
+  await sflow(
+    (
+      await gh.pulls.list({
+        // source repo
+        state: "all",
+        // head_repo: head_repo,
+
+        head: head,
+        // pr will merge into
+        owner: dst.owner,
+        repo: dst.repo,
+        base: repo.default_branch,
+      })
+    ).data,
+  )
+    // .filter(e => head === e.head.label )
+    .map((e) => ({
+      url: e.html_url,
+      hEAD: head.trim() === e.head.label.trim(),
+      heaD: head,
+      head: e.head.label,
+      head_repo: e.head.repo.full_name,
+    }))
+    .toLog();
+  console.log("all done");
+}
+export async function createGithubPullRequest({
+  title,
+  body,
+  branch,
+  srcUrl,
+  dstUrl,
+  updateIfNotMatched = true,
+}: {
+  title: string;
+  body: string;
+  branch: string;
+  srcUrl: string; // forked branch
+  dstUrl: string; // upstream
+  updateIfNotMatched?: boolean;
+}) {
+  if (isRepoBypassed(dstUrl)) DIE("dst repo is requested to be bypassed");
+
+  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 > 1)
+    DIE(
+      new Error(`expect only 1 pr, but got ${existedList.length}`, {
+        cause: { existed: existedList.map((e) => ({ url: e.html_url, title: e.title })) },
+      }),
+    );
+
+  const pr_result =
+    existedList[0] ??
+    (await ghPR()
+      .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)
+
+      // handle existed error
+      .catch(async (e) => {
+        if (!e.message.match("A pull request already exists for")) throw e;
+        console.error("PR Existed\n", 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; // .filter(existed => existed.title === title);
+
+        if (existedList.length !== 1)
+          DIE(
+            new Error("expect only 1 pr, but got " + existedList.length, {
+              cause: { existed: existedList.map((e) => ({ url: e.html_url, title: e.title })) },
+            }),
+          );
+
+        return existedList[0];
+      }));
+
+  console.log("PR OK", pr_result.html_url);
+  const mismatch = pr_result.title !== title || pr_result.body !== body;
+  if (mismatch) {
+    if (!updateIfNotMatched)
+      DIE(
+        new Error("pr content mismatch", {
+          cause: { mismatch, expected: { title, body }, actual: pickAll(["title", "body"], pr_result) },
+        }),
+      );
+    const { owner, repo } = parseUrlRepoOwner(dstUrl); // upstream repo
+    const updated = (await catchArgs(ghPR().pulls.update)({ pull_number: pr_result.number, body, title, owner, repo }))
+      .data!;
+    const updatedPRStillMismatch = updated.title !== title || updated.body !== body;
+    if (updatedPRStillMismatch) DIE(new Error("updatedPRStillMismatch", { cause: arguments }));
+    console.warn(`PR content updated ${owner}/${repo} / \n<< ${pr_result.title}\n>> ${updated.title}`);
+  }
+  return pr_result as GithubPull;
+}
+
+function ghPR() {
+  return new Octokit({ auth: process.env.GH_TOKEN_COMFY_PR || DIE(new Error("Missing env.GH_TOKEN_COMFY_PR")) }).rest;
+}

package/src/createIssueComment.ts

@@ -1,29 +1,34 @@
-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));
+  const url = "https://github.com/snomiao/ComfyNode-Registry-test/pull/28";
+  const body = "Hello World @robinjhuang";
+  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("+ IssueComment " + 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;
+}

package/src/fetchComfyRegistryNodes.ts

@@ -1,11 +1,11 @@
-import type { mockPublishedNodes } from "../mocks/mockPublishedNodes";
-import DIE from "@snomiao/die";
-import { fetchJson } from "./utils/fetchJson";
-
-export async function fetchCRNodes() {
-  const r = (await fetchJson<typeof mockPublishedNodes>(
-    "https://api.comfy.org/nodes?page=1&limit=99999999"
-  )) as typeof mockPublishedNodes;
-  r.totalPages === 1 || DIE("FAIL TO FETCH ALL NODES");
-  return r.nodes;
-}
+import type { mockPublishedNodes } from "../mocks/mockPublishedNodes";
+import DIE from "@snomiao/die";
+import { fetchJson } from "./utils/fetchJson";
+
+export async function fetchCRNodes() {
+  const r = (await fetchJson<typeof mockPublishedNodes>(
+    "https://api.comfy.org/nodes?page=1&limit=99999999"
+  )) as typeof mockPublishedNodes;
+  r.totalPages === 1 || DIE("FAIL TO FETCH ALL NODES");
+  return r.nodes;
+}

package/src/fetchCurrentGeoInfo.ts

@@ -1,6 +1,6 @@
-import { fetchJson } from "./utils/fetchJson";
-export async function fetchCurrentGeoInfo() {
-  const { query, city, iat, lon, countryCode, region, regionName } = (await fetchJson("http://ip-api.com/json")) as any;
-  const geo = { ip: query, city, iat, lon, countryCode, region, regionName };
-  return geo;
-}
+import { fetchJson } from "./utils/fetchJson";
+export async function fetchCurrentGeoInfo() {
+  const { query, city, iat, lon, countryCode, region, regionName } = (await fetchJson("http://ip-api.com/json")) as any;
+  const geo = { ip: query, city, iat, lon, countryCode, region, regionName };
+  return geo;
+}

package/src/fetchRelatedPullWithComments.ts

@@ -1,15 +1,15 @@
-import pMap from "p-map";
-import { fetchIssueComments } from "./gh/fetchIssueComments";
-import { matchRelatedPulls } from "./matchRelatedPulls";
-import type { GithubPullParsed } from "./parsePullsState";
-import { summaryLastPullComment } from "./summaryLastPullComment";
-/** @deprecated */
-export async function fetchRelatedPullWithComments(repository: string, pulls: GithubPullParsed[]) {
-  const relatedPulls = await matchRelatedPulls(pulls);
-  const relatedPullsWithComment = await pMap(relatedPulls, async (data) => {
-    const comments = await fetchIssueComments(repository, data.pull);
-    const lastText = summaryLastPullComment(comments);
-    return { ...data, comments, lastText };
-  });
-  return relatedPullsWithComment;
-}
+import pMap from "p-map";
+import { fetchIssueComments } from "./gh/fetchIssueComments";
+import { matchRelatedPulls } from "./matchRelatedPulls";
+import type { GithubPullParsed } from "./parsePullsState";
+import { summaryLastPullComment } from "./summaryLastPullComment";
+/** @deprecated */
+export async function fetchRelatedPullWithComments(repository: string, pulls: GithubPullParsed[]) {
+  const relatedPulls = await matchRelatedPulls(pulls);
+  const relatedPullsWithComment = await pMap(relatedPulls, async (data) => {
+    const comments = await fetchIssueComments(repository, data.pull);
+    const lastText = summaryLastPullComment(comments);
+    return { ...data, comments, lastText };
+  });
+  return relatedPullsWithComment;
+}

package/src/fetchRepoDescriptionMap.ts

@@ -1,15 +1,15 @@
-import { fromPairs } from "rambda";
-import { fetchCMNodes } from "./fetchCMNodes";
-
-
-export async function fetchRepoDescriptionMap() {
-  const nodeList = await fetchCMNodes();
-  const repoDescriptionMap = fromPairs(
-    nodeList.map((e) => [e.reference, e.description])
-  );
-  repoDescriptionMap["https://github.com/snomiao/ComfyNode-Registry-test"] =
-    "ComfyNode-Registry-test-description";
-
-  console.log("Fetched " + nodeList.length + " CustomNode descriptions");
-  return repoDescriptionMap;
-}
+import { fromPairs } from "rambda";
+import { fetchCMNodes } from "./fetchCMNodes";
+
+
+export async function fetchRepoDescriptionMap() {
+  const nodeList = await fetchCMNodes();
+  const repoDescriptionMap = fromPairs(
+    nodeList.map((e) => [e.reference, e.description])
+  );
+  repoDescriptionMap["https://github.com/snomiao/ComfyNode-Registry-test"] =
+    "ComfyNode-Registry-test-description";
+
+  console.log("Fetched " + nodeList.length + " CustomNode descriptions");
+  return repoDescriptionMap;
+}

package/src/followRuleSchema.ts

@@ -1,76 +1,79 @@
-import { $before, $fresh, $stale } from "@/packages/mongodb-pipeline-ts/$fresh";
-import { tryCatch } from "rambda";
-import { z } from "zod";
-
-const znot_include = z.object({ "not-include": z.string() }).transform((x) => ({ $nin: x["not-include"] }));
-const mString = z.string().transform((x) =>
-  tryCatch<string, string | RegExp>(
-    (x) => new RegExp(x) as RegExp,
-    (x) => x as string | RegExp,
-  )(x),
-);
-const zbefore = z
-  .object({ $before: z.coerce.date().or(z.string()).or(z.number()) })
-  .transform((x) => $before(x.$before));
-const zfresh = z.object({ $fresh: z.coerce.date().or(z.string()).or(z.number()) }).transform((x) => $fresh(x.$fresh));
-const mstale = z.object({ $stale: z.coerce.date().or(z.string()).or(z.number()) }).transform((x) => $stale(x.$stale));
-const mDate = z.date().or(zbefore).or(zfresh).or(mstale);
-const mAny = z.number().or(znot_include).or(mString).or(zbefore).or(zfresh);
-const mNumber = z
-  .number()
-  .or(z.object({ $gt: z.number() }))
-  .or(z.object({ $lt: z.number() }))
-  .or(z.object({ $eq: z.number() }))
-  .or(z.object({ $ne: z.number() }))
-  .or(z.object({ $gte: z.number() }))
-  .or(z.object({ $lte: z.number() }));
-export const zAddCommentAction = z
-  .object({
-    by: z.string(),
-    body: z.string(),
-  })
-  .strict();
-const zFollowUpRule = z.object({
-  name: z.string(),
-  $match: z
-    .object({
-      actived_at: mDate,
-      email: mString,
-      comments: mNumber,
-      created_at: mDate,
-      comments_author: mString,
-      head: mString,
-      lastwords: mString,
-      on_registry: z.boolean(),
-      nickName: mString,
-      ownername: mString,
-      state: z.enum(["OPEN", "CLOSED", "MERGED"]),
-      updated_at: mDate,
-      url: mString,
-    })
-    .strict()
-    .partial(),
-  action: z
-    .object({
-      "add-comment": zAddCommentAction,
-      "send-email": z
-        .object({
-          provider: z.string(),
-          from: z.string(),
-          to: z.string(),
-          subject: z.string(),
-          body: z.string(),
-        })
-        .strict(), // WARN: not implementd
-      "update-issue": z
-        .object({
-          tags: mAny,
-        })
-        .strict(),
-      // close: z.any(),
-    })
-    .strict()
-    .partial(),
-});
-// zPullsStatus
-export const zFollowUpRules = zFollowUpRule.array();
+import { $before, $fresh, $stale } from "@/packages/mongodb-pipeline-ts/$fresh";
+import { tryCatch } from "rambda";
+import { z } from "zod";
+
+const znot_include = z.object({ "not-include": z.string() }).transform((x) => ({ $nin: x["not-include"] }));
+const mString = z.string().transform((x) =>
+  tryCatch<string, string | RegExp>(
+    (x) => new RegExp(x) as RegExp,
+    (x) => x as string | RegExp,
+  )(x),
+);
+const zbefore = z
+  .object({ $before: z.coerce.date().or(z.string()).or(z.number()) })
+  .transform((x) => $before(x.$before));
+const zfresh = z.object({ $fresh: z.coerce.date().or(z.string()).or(z.number()) }).transform((x) => $fresh(x.$fresh));
+const mstale = z.object({ $stale: z.coerce.date().or(z.string()).or(z.number()) }).transform((x) => $stale(x.$stale));
+const mDate = z.date().or(zbefore).or(zfresh).or(mstale);
+const mAny = z.number().or(znot_include).or(mString).or(zbefore).or(zfresh);
+const mNumber = z
+  .number()
+  .or(z.object({ $gt: z.number() }))
+  .or(z.object({ $lt: z.number() }))
+  .or(z.object({ $eq: z.number() }))
+  .or(z.object({ $ne: z.number() }))
+  .or(z.object({ $gte: z.number() }))
+  .or(z.object({ $lte: z.number() }));
+export const zAddCommentAction = z
+  .object({
+    by: z.string(),
+    body: z.string(),
+  })
+  .strict();
+export const zSendEmailAction = z
+  .object({
+    provider: z.enum(["google"]),
+    name: z.string(),
+    from: z.string(),
+    to: z.string(),
+    subject: z.string(),
+    body: z.string(),
+  })
+  .strict();
+const zFollowUpRule = z.object({
+  name: z.string(),
+  $match: z
+    .object({
+      actived_at: mDate,
+      email: mString,
+      comments: mNumber,
+      created_at: mDate,
+      comments_author: mString,
+      head: mString,
+      lastcomment: mString,
+      on_registry: z.boolean(),
+      nickName: mString,
+      ownername: mString,
+      state: z.enum(["OPEN", "CLOSED", "MERGED"]),
+      emailState: z.enum(["", "waiting", "sending", "sent", "error"]),
+      updated_at: mDate,
+      url: mString,
+    })
+    .strict()
+    .partial(),
+  action: z
+    .object({
+      "add-comment": zAddCommentAction,
+      "send-email": zSendEmailAction, // WARN: not implementd
+      "update-issue": z
+        .object({
+          tags: mAny,
+        })
+        .strict(),
+      // close: z.any(),
+    })
+    .strict()
+    .partial(),
+});
+// zPullsStatus
+export const zFollowUpRules = zFollowUpRule.array();