comfy-pr 0.2.25 → 0.2.26

package/src/createGithubPullRequest.ts

@@ -1,22 +1,67 @@
-import DIE from "@snomiao/die";
-import yaml from "yaml";
+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;
-  dstUrl: 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;
@@ -26,69 +71,87 @@ export async function createGithubPullRequest({
     await gh.pulls.list({
       // source repo
       state: "all",
-      head_repo: src.owner + "/" + src.repo,
-      head: src.owner + ":" + branch,
+      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);
+  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,
+            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;
-    });
+        ).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

@@ -4,8 +4,13 @@ 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 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));
@@ -22,7 +27,7 @@ export async function createIssueComment(issueUrl: string, body: string, by: str
     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);
+    console.log("+ IssueComment " + comment.html_url);
     return { comment, comments: [...comments, comment] };
   })();
   return result;

package/src/followRuleSchema.ts

@@ -50,11 +50,12 @@ const zFollowUpRule = z.object({
       created_at: mDate,
       comments_author: mString,
       head: mString,
-      lastwords: 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,
     })

package/src/ghUser.ts

@@ -1,6 +1,9 @@
+import type { Task } from "@/packages/mongodb-pipeline-ts/Task";
 import { gh } from "./gh";
+import type { AwaitedReturnType } from "./types/AwaitedReturnType";
 
 export const ghUser = (await gh.users.getAuthenticated()).data;
 
 console.log("Fetch Current Github User...");
 console.log(`Current Github User: ${ghUser.login} <${ghUser.email}>`);
+export type GHUser = Task<AwaitedReturnType<typeof gh.users.getByUsername>["data"]>;

package/src/index.ts

@@ -2,6 +2,7 @@ import "dotenv/config";
 import { checkComfyActivated } from "./checkComfyActivated";
 import { updateEmailTasks } from "./EmailTasks";
 import { initializeFollowRules } from "./initializeFollowRules";
+import { updateTomlLicenseTasks } from "./makeUpdateTomlLicenseBranch";
 import { updateAuthors } from "./updateAuthors";
 import { updateCNRepos } from "./updateCNRepos";
 import { runFollowRuleSet } from "./updateFollowRuleSet";
@@ -16,6 +17,7 @@ if (import.meta.main) {
     updateCNRepos(),
     updateAuthors(),
     updateEmailTasks(),
+    updateTomlLicenseTasks(),
   ]);
   await initializeFollowRules();
   await tLog("runFollowRuleSet", runFollowRuleSet);

package/src/makeUpdateTomlLicenseBranch.ts

@@ -0,0 +1,245 @@
+import { $pipeline } from "@/packages/mongodb-pipeline-ts/$pipeline";
+import { TaskError, TaskErrorOrNull, TaskOK, type Task } from "@/packages/mongodb-pipeline-ts/Task";
+import DIE from "@snomiao/die";
+import { sleep } from "bun";
+import { readFile } from "fs/promises";
+import type { WithId } from "mongodb";
+import { basename, dirname } from "path";
+import sflow, { nil } from "sflow";
+import { CNRepos } from "./CNRepos";
+import { GIT_USEREMAIL } from "./GIT_USEREMAIL";
+import { GIT_USERNAME } from "./GIT_USERNAME";
+import { isRepoBypassed } from "./bypassRepos";
+import { $ } from "./cli/echoBunShell";
+import { createGithubForkForRepo } from "./createGithubForkForRepo";
+import { createGithubPullRequest } from "./createGithubPullRequest";
+import { $filaten, $stale, db } from "./db";
+import { getBranchWorkingDir } from "./getBranchWorkingDir";
+import { gh } from "./gh";
+import type { GithubPull } from "./gh/GithubPull";
+import { parseUrlRepoOwner, stringifyGithubOrigin } from "./parseOwnerRepo";
+import { parsePullUrl } from "./parsePullUrl";
+import { parseTitleBodyOfMarkdown } from "./parseTitleBodyOfMarkdown";
+
+type LicenseUpdateTask = {
+  repository: string;
+  tomlUpdated?: boolean;
+  prTask: Task<any>;
+  updatedAt?: Date;
+};
+
+const LicenseTasks = db.collection<LicenseUpdateTask>("LicenseTasks");
+await LicenseTasks.createIndex({ repository: 1 }, { unique: true });
+
+if (import.meta.main) {
+  // - [Add pyproject.toml for Custom Node Registry by haohaocreates · Pull Request #1 · loopyd/ComfyUI-FD-Tagger]( https://github.com/loopyd/ComfyUI-FD-Tagger/pull/1 )
+  // await LicenseTasks.deleteMany({});
+  //   await _pullTemplate();
+  //   const testUpstreamRepo = "https://github.com/haohaocreates/ComfyUI-HH-Image-Selector";
+  // await _testMakeUpdateTomlLicenseBranch();
+  // await _listReposWithNoLicense();
+  const testMapping = {
+    [`license = "MIT"`]: `license = { text = "MIT" }`,
+    [`license = "LICENSE.txt"`]: `license = { file = "LICENSE.txt" }`,
+  };
+
+  const repoExamples = {
+    "https://github.com/MuziekMagie/ComfyUI-Matchering": "license already updated",
+    // - [ComfyUI_FizzNodes/LICENCE.txt at main · FizzleDorf/ComfyUI_FizzNodes]( https://github.com/FizzleDorf/ComfyUI_FizzNodes/blob/main/LICENCE.txt )
+    "https://github.com/FizzleDorf/ComfyUI_FizzNodes": "licenCe",
+  };
+
+  await updateTomlLicenseTasks();
+  console.log("ALL DONE");
+}
+
+async function _listReposWithNoLicense() {
+  console.log(
+    await $pipeline(CNRepos)
+      .match({ cr: { $exists: true }, "info.data": { $exists: true }, "info.data.license": null })
+      .project({ _id: 0, repository: 1, gh_license: "$info.data.license" })
+      .aggregate()
+      .next(),
+  );
+}
+
+export async function updateTomlLicenseTasks() {
+  // collect tasks
+  await $pipeline(CNRepos)
+    .match({ cr: { $exists: true } })
+    .project({ _id: 0, repository: 1 })
+    .merge({ into: LicenseTasks.collectionName, on: "repository" })
+    .aggregate()
+    .next();
+
+  // reset retry-able errors with a cd interval
+  await LicenseTasks.updateMany($filaten({ prTask: { error: /was submitted too quickly/, mtime: $stale("5m") } }), {
+    $unset: { prTask: 1 },
+  });
+  await LicenseTasks.updateMany($filaten({ prTask: { error: /Missing env.GH_TOKEN_COMFY_PR/, mtime: $stale("1h") } }), {
+    $unset: { prTask: 1 },
+  });
+  console.log((await LicenseTasks.estimatedDocumentCount()) + " license tasks");
+
+  // update tasks
+  await sflow(
+    $pipeline(LicenseTasks)
+      .match({ tomlUpdated: { $ne: true }, updatedAt: $stale("5m") })
+      .as<WithId<LicenseUpdateTask>>()
+      .aggregate(),
+  )
+    .filter(({ repository }) => !isRepoBypassed(repository))
+    .pMap(
+      async ({ _id, repository }) => {
+        const prTask = await createTomlLicensePR(repository).then(TaskOK).catch(TaskError);
+        const tomlUpdated = !!TaskErrorOrNull(prTask)?.match("not matched outdated case");
+        return await LicenseTasks.findOneAndUpdate(
+          { _id },
+          { $set: { tomlUpdated, prTask, updatedAt: new Date() } },
+          { returnDocument: "after" },
+        );
+      },
+      { concurrency: 3 },
+    )
+    .forEach(() => sleep(2e3))
+    .toLog();
+}
+
+async function _testMakeUpdateTomlLicenseBranch() {
+  const testUpstreamRepo = "https://github.com/snomiao/comfy-malicious-node-test";
+
+  const prTask = await createTomlLicensePR(testUpstreamRepo).then(TaskOK).catch(TaskError);
+  if (TaskErrorOrNull(prTask)?.match("Not matched outdated case")) console.log("not matched outdated case");
+  console.log(prTask);
+  console.log("prs_updateTomlLicense PRs DONE");
+}
+
+async function createTomlLicensePR(upstreamUrl: string): Promise<GithubPull> {
+  const { html_url: forkUrl } = await createGithubForkForRepo(upstreamUrl);
+  const branchInfo = await makeUpdateTomlLicenseBranch(upstreamUrl, forkUrl);
+  // console.log(forkUrl); // note: this forkUrl may not be final forked url
+  console.log({ branchInfo });
+  return (
+    (await sflow([branchInfo])
+      .map(({ upstreamUrl, forkUrl, ...e }) => ({
+        ...e,
+        srcUrl: forkUrl,
+        dstUrl: upstreamUrl,
+      }))
+      .map(async ({ type, ...prInfo }) => await createGithubPullRequest({ ...prInfo }))
+      .forEach((e) => e || DIE("missing pr result"))
+      .toOne()) ?? DIE("never")
+  );
+}
+
+export async function makeUpdateTomlLicenseBranch(upstreamUrl: string, forkUrl: string) {
+  const type = "licence-update" as const;
+  const branch = "licence-update";
+  const tmpl = await readFile("./templates/update-toml-license.md", "utf8");
+  const { title, body } = parseTitleBodyOfMarkdown(tmpl);
+
+  // check forked repo if target branch existed
+  const origin = await stringifyGithubOrigin(parseUrlRepoOwner(forkUrl));
+  const repo = parseUrlRepoOwner(forkUrl);
+  const existedBranch = await gh.repos.getBranch({ ...repo, branch }).catch(() => null);
+
+  const cwd = await getBranchWorkingDir(upstreamUrl, forkUrl, branch);
+  // commit changes
+  await $`
+rm -rf ${cwd}
+git clone ${upstreamUrl} ${cwd}
+`;
+
+  //   // also pull from existed forked branch
+  //   if (existedBranch)
+  //     await $`
+  // cd ${cwd}
+  // git pull ${forkUrl} ${branch}
+  // `;
+
+  const pyprojectToml = cwd + "/pyproject.toml";
+  const { updated, license } = await pyprojectTomlUpdateLicenses(pyprojectToml, upstreamUrl);
+  if (!updated) throw new Error("License field not matched outdated case, skip pr");
+
+  if (existedBranch) {
+    console.log("[debug] skip update already forked branch " + branch);
+    return { type, title, body, branch, upstreamUrl, forkUrl, license };
+  }
+
+  // prepare local branch
+  await $`
+cd ${cwd}
+git config user.name ${GIT_USERNAME} && \
+git config user.email ${GIT_USEREMAIL} && \
+git checkout -b ${branch} && \
+git add . && \
+git commit -am ${`chore(${branch}): ${title}`}
+`;
+
+  await $`
+cd ${cwd}
+git push "${origin}" ${branch}:${branch}
+`;
+  const branchUrl = `https://github.com/${repo.owner}/${repo.repo}/tree/${branch}`;
+  console.log(`Branch Push OK: ${branchUrl}`);
+
+  return { type, title, body, branch, upstreamUrl, forkUrl, license };
+}
+
+export async function pyprojectTomlUpdateLicenses(tomlFile: string, upstreamRepoUrl: string) {
+  const raw =
+    (await Bun.file(tomlFile).text().catch(nil)) || DIE(new Error("pyproject.toml file not existed or got empty file"));
+  const m = raw.match(/^license\s*=(.*)/im);
+
+  const licenseLine = m?.[0];
+  const license = m?.[1]?.trim();
+  const outdatedDesiredLicense = license?.match(/^"([^"\n\r]+)"$/i)?.[1];
+  const isOutdated = !!outdatedDesiredLicense;
+  // const isOutdated = !!raw.match(outdated);
+  license && (await LicenseTasks.updateOne({ repository: upstreamRepoUrl }, { $set: { license: license } }));
+  if (!licenseLine) throw new Error("no license line was found, please check toml file");
+  if (!isOutdated) return { updated: false }; // not outdated
+
+  let updated: string | null = "";
+
+  // try load local license file first
+  updated ||= await (async function () {
+    const desiredLicenseIsFile = !!outdatedDesiredLicense.match(/LICEN[SC]E/);
+    if (!desiredLicenseIsFile) return null;
+    const licenses = await Array.fromAsync(new Bun.Glob(dirname(tomlFile) + "/LICEN[CS]E*").scan()); // note: LICENCE will be mismatch in this case
+    if (licenses.length > 1) DIE(new Error("Multiple license found: " + JSON.stringify(licenses)));
+
+    const licenseFilename = licenses[0];
+    if (!licenseFilename) return null;
+    return `license = { file = "${basename(licenseFilename)}" }`;
+  })();
+
+  // - [Writing your pyproject.toml - Python Packaging User Guide]( https://packaging.python.org/en/latest/guides/writing-pyproject-toml/#license )
+  updated ||= await (async function () {
+    const resp = await gh.repos.get({ ...parseUrlRepoOwner(upstreamRepoUrl) });
+    const license = resp.data.license;
+    if (!license) return null;
+    return `license = { text = "${license?.name}" }`;
+  })();
+
+  if (!updated)
+    DIE(
+      `Fail to get repo license from repo please contact author to create a license file\nMISSING_LICENSE_REPO: ${upstreamRepoUrl}`,
+    );
+
+  const replaced = raw.replace(licenseLine, () => updated);
+  if (replaced === raw) DIE(new Error("licenseLine not matched", { cause: { raw, licenseLine, updated } }));
+  await LicenseTasks.updateOne({ repository: upstreamRepoUrl }, { $set: { updateLine: updated } });
+  await Bun.write(tomlFile, replaced);
+  return { updated: true, license: replaced.match(/^license\s*=(.*)/i)?.[1]?.trim() };
+}
+
+/** use when template updated */
+async function _pullTemplate() {
+  const referenceTemplate = "https://github.com/haohaocreates/ComfyUI-HH-Image-Selector/pull/3";
+  const template = await sflow(gh.pulls.get(parsePullUrl(referenceTemplate)))
+    .map((e) => e.data.body!)
+    .text();
+  await Bun.write("./templates/update-toml-license.md", template);
+  console.log(template);
+}

package/src/matchRelatedPulls.ts

@@ -7,49 +7,36 @@ import { readTemplateTitle } from "./readTemplateTitle";
 export type RelatedPullsWithComments = Awaited<ReturnType<typeof fetchRelatedPullWithComments>>;
 export type RelatedPull = Awaited<ReturnType<typeof matchRelatedPulls>>[number];
 export async function matchRelatedPulls(pulls: GithubPullParsed[]): Promise<
-  (
-    | {
-        type: "pyproject";
-        pull: {
-          title: string;
-          number: number;
-          url: string;
-          html_url: string;
-          user: { login: string; html_url: string };
-          body: string | null;
-          prState: "closed" | "open" | "merged";
-          updatedAt: Date;
-          createdAt: Date;
-          updated_at: Date;
-          created_at: Date;
-        };
-      }
-    | {
-        type: "publishcr";
-        pull: {
-          title: string;
-          number: number;
-          url: string;
-          html_url: string;
-          user: { login: string; html_url: string };
-          body: string | null;
-          prState: "closed" | "open" | "merged";
-          updatedAt: Date;
-          createdAt: Date;
-          updated_at: Date;
-          created_at: Date;
-        };
-      }
-  )[]
+  {
+    type: "pyproject" | "publishcr" | "licence-update";
+    pull: {
+      title: string;
+      number: number;
+      url: string;
+      html_url: string;
+      user: { login: string; html_url: string };
+      body: string | null;
+      prState: "closed" | "open" | "merged";
+      updatedAt: Date;
+      createdAt: Date;
+      updated_at: Date;
+      created_at: Date;
+    };
+  }[]
 > {
   const pyproject = await readTemplateTitle("add-toml.md");
   const publishcr = await readTemplateTitle("add-action.md");
+  const licenseUpdate = await readTemplateTitle("update-toml-license.md");
   const relatedPulls = await pMap(pulls, async (pull) =>
     match(pull)
       .with({ title: pyproject }, (pull) => ({
         type: "pyproject" as const,
         pull,
       }))
+      .with({ title: licenseUpdate }, (pull) => ({
+        type: "licence-update" as const,
+        pull,
+      }))
       .with({ title: publishcr }, (pull) => ({
         type: "publishcr" as const,
         pull,

package/src/pullStatusFollowSchema.ts

@@ -7,6 +7,6 @@ export const zPullStatusFollow = z.array(
     url: z.string(),
     head: z.string(),
     comments: z.number(),
-    lastwords: z.string(),
+    lastcomment: z.string(),
   }),
 );

package/src/sendEmailAction.ts

@@ -32,7 +32,7 @@ export async function sendEmailAction({
         .map((e) =>
           // replace {{var}} s
           e.replace(
-            /{{\$([_A-Za-z0-9]+)}}/,
+            /{{\$([_A-Za-z0-9]+)}}/g,
             (_, key: string) =>
               (payload as any)[key] || DIE("Missing key: " + key + " in payload: " + JSON.stringify(payload)),
           ),

package/src/sendGmail.ts

@@ -1,6 +1,8 @@
 import DIE from "@snomiao/die";
-import type { Credentials, OAuth2Client } from "google-auth-library";
+// import type { Credentials } from "google-auth-library";
+import type { Credentials } from "google-auth-library";
 import { GoogleApis } from "googleapis";
+import type { OAuth2Client } from "googleapis-common";
 import { createMimeMessage } from "mail-mime-builder";
 import markdownIt from "markdown-it";
 import {
@@ -8,12 +10,11 @@ import {
   getGCloudOAuth2Client,
   handleGCloudOAuth2Callback,
 } from "./gcloud/GCloudOAuth2Credentials";
-
 if (import.meta.main) {
   // send test email
   const name = "snomiao";
   const from = "snomiao@gmail.com";
-  const to = "snomiao@gmail.com";
+  const to = ".snomiao@gmail.com";
   const subject = "Hello! snomiao";
   const markdown = `
 # hello from sno

package/src/updateCNReposInfo.ts

@@ -1,5 +1,5 @@
-import pMap from "p-map";
 import { dissoc } from "rambda";
+import sflow from "sflow";
 import { match } from "ts-pattern";
 import { $OK, TaskError, TaskOK } from "../packages/mongodb-pipeline-ts/Task";
 import { CNRepos } from "./CNRepos";
@@ -16,8 +16,9 @@ if (import.meta.main) {
 
 export async function updateCNReposInfo() {
   await CNRepos.createIndex($filaten({ info: { mtime: 1 } }));
-  return await pMap(
-    CNRepos.find($filaten({ info: { mtime: $stale("1d") } })),
+  return await sflow(
+    CNRepos.find($filaten({ info: { mtime: $stale("1d") } }))
+  ).pMap(
     async (repo) => {
       const { repository } = repo;
       console.log("[INFO] Fetching meta info from " + repository);
@@ -53,5 +54,5 @@ export async function updateCNReposInfo() {
       return await CNRepos.updateOne({ repository: url }, { $set: { info } }, { upsert: true });
     },
     { concurrency: 2 },
-  );
+  ).toArray();
 }