comfy-pr 0.2.26 → 1.0.1

package/src/ghUser.ts

@@ -1,9 +1,33 @@
 import type { Task } from "@/packages/mongodb-pipeline-ts/Task";
-import { gh } from "./gh";
+import DIE from "@snomiao/die";
+import { gh } from "@/lib/github";
 import type { AwaitedReturnType } from "./types/AwaitedReturnType";
 
-export const ghUser = (await gh.users.getAuthenticated()).data;
+const g = globalThis as typeof globalThis & {
+  ghUserCache: AwaitedReturnType<typeof gh.users.getAuthenticated>["data"] | null;
+};
+export const ghUser = async () =>
+  (g.ghUserCache ??= (
+    await gh.users.getAuthenticated().catch((error) => {
+      throw new Error(
+        `FAIL TO GET AUTHENTICATED USER INFO, CHECK ${process.env.GH_TOKEN ? "[?]" : "[ ]"}GH_TOKEN and ${process.env.GH_TOKEN_COMFY_PR ? "[?]" : "[ ]"}GH_TOKEN_COMFY_PR`,
+        { cause: error },
+      );
+    })
+  ).data);
+
+// console.log(`GH_TOKEN User: ${(await ghUser()).login} <${(await ghUser()).email}>`);
 
-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"]>;
+
+export const GIT_USEREMAIL = async () =>
+  process.env.GIT_USEREMAIL ||
+  ((await ghUser()).email && (await ghUser()).email) ||
+  DIE("Missing env.GIT_USEREMAIL");
+export const GIT_USERNAME = async () =>
+  process.env.GIT_USERNAME ||
+  ((await ghUser()).email && (await ghUser()).name) ||
+  DIE("Missing env.GIT_USERNAME");
+
+// read env/parameters
+console.log(`GIT COMMIT USER: ${await GIT_USERNAME()} <${await GIT_USEREMAIL()}>`);

package/src/index.ts

@@ -2,25 +2,34 @@ import "dotenv/config";
 import { checkComfyActivated } from "./checkComfyActivated";
 import { updateEmailTasks } from "./EmailTasks";
 import { initializeFollowRules } from "./initializeFollowRules";
-import { updateTomlLicenseTasks } from "./makeUpdateTomlLicenseBranch";
+import { createLogger } from "./logger";
 import { updateAuthors } from "./updateAuthors";
 import { updateCNRepos } from "./updateCNRepos";
 import { runFollowRuleSet } from "./updateFollowRuleSet";
 import { updateSlackMessages } from "./updateSlackMessages";
+import { getWorkerInstance } from "./WorkerInstances";
 import { tLog } from "./utils/tLog";
 
+const logger = createLogger("main");
+
 if (import.meta.main) {
+  // Register task name immediately so watchWorkerInstancesLoop captures me.task correctly.
+  // Without this, me.task is undefined and any other process calling getWorkerInstance()
+  // without a task name would incorrectly evict this process.
+  await getWorkerInstance("ComfyPR Bot Running");
   await Promise.all([
     // try send msgs that didn't send in last run
     updateSlackMessages(),
-    checkComfyActivated(), // needed if make pr
+    checkComfyActivated(), // needed if making pr
     updateCNRepos(),
     updateAuthors(),
     updateEmailTasks(),
-    updateTomlLicenseTasks(),
+
+    // 2025-03-14 temporary disable due to the standard has updated:
+    // updateTomlLicenseTasks(),
   ]);
   await initializeFollowRules();
   await tLog("runFollowRuleSet", runFollowRuleSet);
-  console.log("All done");
+  logger.info("All done");
   process.exit(0);
 }

package/src/initializeFollowRules.ts

@@ -1,20 +1,27 @@
 import DIE from "@snomiao/die";
 import { readFile } from "fs/promises";
 import { FollowRuleSets } from "./FollowRules";
+import { createLogger } from "./logger";
+
+const logger = createLogger("initializeFollowRules");
 
 if (import.meta.main) {
-  const followRules = await initializeFollowRules();
-  const ruleset = (await FollowRuleSets.findOne({ name: "default" })) ?? DIE("default ruleset not found");
+  const _followRules = await initializeFollowRules();
+  const ruleset =
+    (await FollowRuleSets.findOne({ name: "default" })) ?? DIE("default ruleset not found");
   if (!ruleset?.enabled) DIE("default ruleset not enabled");
 
-  console.log("initialized follow rules");
+  logger.info("initialized follow rules");
 }
 /**
  *
  * @author: snomiao <snomiao@gmail.com>
  */
 export async function initializeFollowRules() {
-  return await updateFollowRules("default", await readFile("./templates/follow-rules.yaml", "utf8"));
+  return await updateFollowRules(
+    "default",
+    await readFile("./templates/follow-rules.yaml", "utf8"),
+  );
 }
 
 export async function updateFollowRules(name: string, rawRuleYaml: string) {

package/src/logger.spec.ts

@@ -0,0 +1,95 @@
+import { describe, expect, it } from "bun:test";
+import winston from "winston";
+import { createLogger, logger } from "./logger";
+
+describe("Logger", () => {
+  describe("logger instance", () => {
+    it("should be a winston logger instance", () => {
+      expect(logger).toBeInstanceOf(winston.Logger);
+    });
+
+    it("should have default log level from environment or 'info'", () => {
+      const expectedLevel = process.env.LOG_LEVEL || "info";
+      expect(logger.level).toBe(expectedLevel);
+    });
+
+    it("should have console transport", () => {
+      expect(logger.transports.length).toBeGreaterThan(0);
+      expect(logger.transports[0]).toBeInstanceOf(winston.transports.Console);
+    });
+  });
+
+  describe("createLogger", () => {
+    it("should create a child logger with module context", () => {
+      const moduleLogger = createLogger("test-module");
+      expect(moduleLogger).toBeInstanceOf(winston.Logger);
+    });
+
+    it("should include module name in metadata", () => {
+      const moduleLogger = createLogger("test-module");
+      expect(moduleLogger).toBeInstanceOf(winston.Logger);
+      // Child loggers in Winston add metadata
+      expect(moduleLogger.defaultMeta).toBeDefined();
+    });
+  });
+
+  describe("log levels", () => {
+    it("should have info method", () => {
+      expect(logger.info).toBeDefined();
+      expect(typeof logger.info).toBe("function");
+    });
+
+    it("should have error method", () => {
+      expect(logger.error).toBeDefined();
+      expect(typeof logger.error).toBe("function");
+    });
+
+    it("should have warning method", () => {
+      expect(logger.warn).toBeDefined();
+      expect(typeof logger.warn).toBe("function");
+    });
+
+    it("should have debug method", () => {
+      expect(logger.debug).toBeDefined();
+      expect(typeof logger.debug).toBe("function");
+    });
+
+    it("should respect log level settings", () => {
+      const originalLevel = logger.level;
+      logger.level = "error";
+      expect(logger.level).toBe("error");
+      logger.level = originalLevel;
+    });
+  });
+
+  describe("metadata handling", () => {
+    it("should accept metadata objects", () => {
+      const metadata = { userId: 123, action: "test" };
+      // This should not throw
+      expect(() => logger.info("test with metadata", metadata)).not.toThrow();
+    });
+
+    it("should handle complex objects as metadata", () => {
+      const complexData = {
+        nested: {
+          value: "test",
+          array: [1, 2, 3],
+        },
+      };
+      // This should not throw
+      expect(() => logger.info("complex metadata", complexData)).not.toThrow();
+    });
+  });
+
+  describe("logger configuration", () => {
+    it("should have timestamp format configured", () => {
+      const formats = logger.format;
+      expect(formats).toBeDefined();
+    });
+
+    it("should have error stack handling", () => {
+      const formats = logger.format;
+      expect(formats).toBeDefined();
+    });
+  });
+});

package/src/logger.ts

@@ -0,0 +1,46 @@
+import winston from "winston";
+
+const { combine, timestamp, printf, colorize, errors } = winston.format;
+
+// Custom format for console output
+const consoleFormat = printf(({ level, message, timestamp, ...metadata }) => {
+  let msg = `${timestamp} [${level}]: ${message}`;
+
+  // Add metadata if present
+  if (Object.keys(metadata).length > 0) {
+    // Remove error stack from metadata display if it exists
+    const { stack, ...cleanMetadata } = metadata;
+    if (Object.keys(cleanMetadata).length > 0) {
+      msg += ` ${JSON.stringify(cleanMetadata)}`;
+    }
+    // Add stack trace on new line if present
+    if (stack) {
+      msg += `\n${stack}`;
+    }
+  }
+
+  return msg;
+});
+
+// Create the logger instance
+export const logger = winston.createLogger({
+  level: process.env.LOG_LEVEL || "info",
+  format: combine(errors({ stack: true }), timestamp({ format: "YYYY-MM-DD HH:mm:ss.SSS" })),
+  transports: [
+    // Console transport for development
+    new winston.transports.Console({
+      format: combine(colorize({ all: true }), consoleFormat),
+    }),
+  ],
+});
+
+// Create child loggers for different modules
+export const createLogger = (module: string) => {
+  return logger.child({ module });
+};
+
+// Convenience exports for common log levels
+export const logInfo = logger.info.bind(logger);
+export const logError = logger.error.bind(logger);
+export const logWarn = logger.warn.bind(logger);
+export const logDebug = logger.debug.bind(logger);

package/src/makeGpl3LicenseBranch.ts

@@ -0,0 +1,66 @@
+import { readFile, writeFile } from "fs/promises";
+import { $ } from "./cli/echoBunShell";
+import { getBranchWorkingDir } from "./getBranchWorkingDir";
+import { gh } from "@/lib/github";
+import { GIT_USEREMAIL, GIT_USERNAME } from "./ghUser";
+import {
+  parseGithubRepoUrl,
+  stringifyGithubOrigin,
+  stringifyGithubRepoUrl,
+} from "./parseOwnerRepo";
+import { parseTitleBodyOfMarkdown } from "./parseTitleBodyOfMarkdown";
+
+export async function makeGpl3LicenseBranch(upstreamUrl: string, forkUrl: Readonly<string>) {
+  const type = "gpl3-license" as const;
+
+  const upstreamRepo = parseGithubRepoUrl(upstreamUrl);
+
+  // Check if the repo already has a license — skip if it does
+  const existingLicense = await gh.licenses
+    .getForRepo({ owner: upstreamRepo.owner, repo: upstreamRepo.repo })
+    .catch(() => null);
+  if (existingLicense) {
+    console.log("Skip: license already exists for " + upstreamUrl);
+    return null;
+  }
+
+  const origin = await stringifyGithubOrigin(parseGithubRepoUrl(forkUrl));
+  const branch = "gpl3-license";
+  const tmpl = await readFile("./templates/add-gpl3-license.md", "utf8");
+  const { title, body } = parseTitleBodyOfMarkdown(tmpl);
+  const repo = parseGithubRepoUrl(origin);
+
+  if (await gh.repos.getBranch({ ...repo, branch }).catch(() => null)) {
+    // prevent unrelated history
+    console.log("Skip changes as branch existed: " + branch);
+    return { type, title, body, branch };
+  }
+
+  // Fetch canonical GPL-3.0 text from GitHub API
+  const licenseData = await gh.licenses.get({ license: "gpl-3.0" });
+  const licenseText = licenseData.data.body;
+
+  const cwd = await getBranchWorkingDir(upstreamUrl, forkUrl, branch);
+
+  // Clone the repo
+  await $`git clone --single-branch ${upstreamUrl} ${cwd}`;
+
+  // Write LICENSE file via Node.js to avoid shell escaping issues with license text
+  await writeFile(`${cwd}/LICENSE`, licenseText, "utf8");
+
+  // commit & push changes
+  await $`
+cd ${cwd}
+
+git config user.name ${GIT_USERNAME} && \
+git config user.email ${GIT_USEREMAIL} && \
+git checkout -b ${branch} && \
+git add LICENSE && \
+git commit -m "chore(${branch}): ${title}" && \
+git push -f "${origin}" ${branch}:${branch}
+`;
+
+  const branchUrl = `${stringifyGithubRepoUrl(repo)}/tree/${branch}`;
+  console.log(`Branch Push OK: ${branchUrl}`);
+  return { type, title, body, branch };
+}

package/src/makePublishBranch.ts

@@ -1,11 +1,14 @@
 import { readFile } from "fs/promises";
 import { dirname } from "path";
-import { GIT_USEREMAIL } from "./GIT_USEREMAIL";
-import { GIT_USERNAME } from "./GIT_USERNAME";
 import { $ } from "./cli/echoBunShell";
 import { getBranchWorkingDir } from "./getBranchWorkingDir";
-import { gh } from "./gh";
-import { parseUrlRepoOwner, stringifyGithubOrigin, stringifyGithubRepoUrl } from "./parseOwnerRepo";
+import { gh } from "@/lib/github";
+import { GIT_USEREMAIL, GIT_USERNAME } from "./ghUser";
+import {
+  parseGithubRepoUrl,
+  stringifyGithubOrigin,
+  stringifyGithubRepoUrl,
+} from "./parseOwnerRepo";
 import { parseTitleBodyOfMarkdown } from "./parseTitleBodyOfMarkdown";
 
 /**
@@ -19,38 +22,41 @@ import { parseTitleBodyOfMarkdown } from "./parseTitleBodyOfMarkdown";
 export async function makePublishcrBranch(upstreamUrl: string, forkUrl: Readonly<string>) {
   const type = "publishcr" as const;
 
-  const origin = await stringifyGithubOrigin(parseUrlRepoOwner(forkUrl));
+  const origin = await stringifyGithubOrigin(parseGithubRepoUrl(forkUrl));
   const branch = "publish";
   const tmpl = await readFile("./templates/add-action.md", "utf8");
   const { title, body } = parseTitleBodyOfMarkdown(tmpl);
-  const repo = parseUrlRepoOwner(origin);
+  const repo = parseGithubRepoUrl(origin);
 
   if (await gh.repos.getBranch({ ...repo, branch }).catch(() => null)) {
+    // prevent unrelated history
     console.log("Skip changes as branch existed: " + branch);
     return { type, title, body, branch };
   }
 
   const cwd = await getBranchWorkingDir(upstreamUrl, forkUrl, branch);
-
-  const file = `${cwd}/.github/workflows/publish.yml`;
+  const upsreamOwner = parseGithubRepoUrl(upstreamUrl).owner;
+  const file = `.github/workflows/publish.yml`;
   const publishYmlPath = "./templates/publish.yaml";
-
+  const publishYmlTemplate = await readFile(publishYmlPath, "utf8");
+  const repalcedContent = publishYmlTemplate.replace("NODE_AUTHOR_OWNER", upsreamOwner);
+  if (publishYmlTemplate === repalcedContent) throw new Error("fail to replace NODE_AUTHOR_OWNER");
   // commit & push changes
   await $`
-git clone ${upstreamUrl} ${cwd}
-
-mkdir -p ${dirname(file)}
-cat ${publishYmlPath} > ${file}
+git clone --single-branch ${upstreamUrl} ${cwd}
 
 cd ${cwd}
 
+mkdir -p ${dirname(file)}
+echo "${repalcedContent}" > ${file}
+
 git config user.name ${GIT_USERNAME} && \
 git config user.email ${GIT_USEREMAIL} && \
 git checkout -b ${branch} && \
 git add . && \ 
 git commit -am "chore(${branch}): ${title}" && \
-git push "${origin}" ${branch}:${branch}
-    `;
+git push -f "${origin}" ${branch}:${branch}
+`;
 
   const branchUrl = `${stringifyGithubRepoUrl(repo)}/tree/${branch}`;
   console.log(`Branch Push OK: ${branchUrl}`);

package/src/makeTomlBranch.ts

@@ -1,31 +1,51 @@
-import { readFile } from "fs/promises";
-import { GIT_USEREMAIL } from "./GIT_USEREMAIL";
-import { GIT_USERNAME } from "./GIT_USERNAME";
+import DIE from "@snomiao/die";
+import { readFile, writeFile } from "fs/promises";
+import toml from "toml";
 import { $ } from "./cli/echoBunShell";
+import { fetchRepoDescriptionMap } from "./fetchRepoDescriptionMap";
 import { getBranchWorkingDir } from "./getBranchWorkingDir";
-import { gh } from "./gh";
-import { parseUrlRepoOwner, stringifyGithubOrigin } from "./parseOwnerRepo";
+import { gh } from "@/lib/github";
+import { GIT_USEREMAIL, GIT_USERNAME } from "./ghUser";
+import { parseGithubRepoUrl, stringifyGithubOrigin } from "./parseOwnerRepo";
 import { parseTitleBodyOfMarkdown } from "./parseTitleBodyOfMarkdown";
-import { tomlFillDescription } from "./tomlFillDescription";
 
 export async function makePyprojectBranch(upstreamUrl: string, forkUrl: string) {
   const type = "pyproject" as const;
-  const origin = await stringifyGithubOrigin(parseUrlRepoOwner(forkUrl));
+  const origin = await stringifyGithubOrigin(parseGithubRepoUrl(forkUrl));
   const branch = "pyproject";
   const tmpl = await readFile("./templates/add-toml.md", "utf8");
   const { title, body } = parseTitleBodyOfMarkdown(tmpl);
-  const repo = parseUrlRepoOwner(forkUrl);
+  const repo = parseGithubRepoUrl(forkUrl);
 
-  if (await gh.repos.getBranch({ ...repo, branch }).catch(() => null)) {
-    console.log("Skip changes as branch existed: " + branch);
-    return { type, title, body, branch };
+  const existingBranch = await gh.repos.getBranch({ ...repo, branch }).catch(() => null);
+  if (existingBranch) {
+    console.log("Branch exists, checking if outdated: " + branch);
+
+    // Get upstream HEAD commit
+    const upstreamRepo = parseGithubRepoUrl(upstreamUrl);
+    const upstreamRepoInfo = await gh.repos.get(upstreamRepo);
+    const defaultBranch = upstreamRepoInfo.data.default_branch;
+    const upstreamHead = await gh.repos.getBranch({ ...upstreamRepo, branch: defaultBranch });
+
+    // Get the base commit of the existing branch
+    const branchBaseCommit = existingBranch.data.commit.sha;
+    const upstreamHeadCommit = upstreamHead.data.commit.sha;
+
+    // Check if branch is outdated (base commit differs from upstream HEAD)
+    if (branchBaseCommit === upstreamHeadCommit) {
+      console.log("Branch is up to date, skipping: " + branch);
+      return { type, title, body, branch };
+    }
+
+    console.log("Branch is outdated, recreating and force-pushing: " + branch);
+    // Continue with the branch creation logic below (will force-push)
   }
-  const src = parseUrlRepoOwner(upstreamUrl);
+  const src = parseGithubRepoUrl(upstreamUrl);
   const cwd = await getBranchWorkingDir(upstreamUrl, forkUrl, branch);
 
   // commit changes
   await $`
-git clone ${upstreamUrl} ${cwd}
+git clone --single-branch ${upstreamUrl} ${cwd}
 
 cd ${cwd}
 echo N | comfy node init
@@ -45,9 +65,23 @@ git config user.email ${GIT_USEREMAIL} && \
 git checkout -b ${branch} && \
 git add . && \
 git commit -am ${`chore(${branch}): ${title}`} && \
-git push "${origin}" ${branch}:${branch}
+git push ${existingBranch ? "--force" : ""} "${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 };
 }
+
+async function tomlFillDescription(referenceUrl: string, pyprojectToml: string) {
+  const repoDescriptionMap = await fetchRepoDescriptionMap();
+  const matchedDescription =
+    repoDescriptionMap[referenceUrl]?.toString() ||
+    DIE("Warn: missing description for " + referenceUrl);
+  const replaced = (await readFile(pyprojectToml, "utf8")).replace(
+    `description = ""`,
+    `description = ${JSON.stringify(matchedDescription)}`,
+  );
+  // check validity
+  toml.parse(replaced);
+  await writeFile(pyprojectToml, replaced);
+}

package/src/makeUpdateTomlLicenseBranch.ts

@@ -6,25 +6,23 @@ 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 { CNRepos } from "./CNRepos";
+import { createGithubForkForRepoEx } from "./createGithubForkForRepo";
 import { createGithubPullRequest } from "./createGithubPullRequest";
-import { $filaten, $stale, db } from "./db";
+import { $flatten, $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 { gh } from "@/lib/github";
+import type { GithubPull } from "@/lib/github/GithubPull";
+import { GIT_USEREMAIL, GIT_USERNAME } from "./ghUser";
+import { parseGithubRepoUrl, stringifyGithubOrigin } from "./parseOwnerRepo";
 import { parseTitleBodyOfMarkdown } from "./parseTitleBodyOfMarkdown";
 
 type LicenseUpdateTask = {
   repository: string;
   tomlUpdated?: boolean;
-  prTask: Task<any>;
+  prTask: Task<unknown>;
   updatedAt?: Date;
 };
 
@@ -32,18 +30,12 @@ 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 = {
+  const _testMapping = {
     [`license = "MIT"`]: `license = { text = "MIT" }`,
     [`license = "LICENSE.txt"`]: `license = { file = "LICENSE.txt" }`,
   };
 
-  const repoExamples = {
+  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",
@@ -68,17 +60,26 @@ export async function updateTomlLicenseTasks() {
   await $pipeline(CNRepos)
     .match({ cr: { $exists: true } })
     .project({ _id: 0, repository: 1 })
+    .match({
+      repository: { $exists: true, $ne: null as unknown as string, $type: "string" },
+    })
     .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 },
-  });
+  await LicenseTasks.updateMany(
+    $flatten({ prTask: { error: /was submitted too quickly/, mtime: $stale("5m") } }),
+    {
+      $unset: { prTask: 1 },
+    },
+  );
+  await LicenseTasks.updateMany(
+    $flatten({ prTask: { error: /Missing env.GH_TOKEN_COMFY_PR/, mtime: $stale("1h") } }),
+    {
+      $unset: { prTask: 1 },
+    },
+  );
   console.log((await LicenseTasks.estimatedDocumentCount()) + " license tasks");
 
   // update tasks
@@ -109,13 +110,14 @@ 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");
+  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 { html_url: forkUrl } = await createGithubForkForRepoEx(upstreamUrl);
   const branchInfo = await makeUpdateTomlLicenseBranch(upstreamUrl, forkUrl);
   // console.log(forkUrl); // note: this forkUrl may not be final forked url
   console.log({ branchInfo });
@@ -126,7 +128,7 @@ async function createTomlLicensePR(upstreamUrl: string): Promise<GithubPull> {
         srcUrl: forkUrl,
         dstUrl: upstreamUrl,
       }))
-      .map(async ({ type, ...prInfo }) => await createGithubPullRequest({ ...prInfo }))
+      .map(async ({ type: _type, ...prInfo }) => await createGithubPullRequest({ ...prInfo }))
       .forEach((e) => e || DIE("missing pr result"))
       .toOne()) ?? DIE("never")
   );
@@ -139,15 +141,15 @@ export async function makeUpdateTomlLicenseBranch(upstreamUrl: string, forkUrl:
   const { title, body } = parseTitleBodyOfMarkdown(tmpl);
 
   // check forked repo if target branch existed
-  const origin = await stringifyGithubOrigin(parseUrlRepoOwner(forkUrl));
-  const repo = parseUrlRepoOwner(forkUrl);
+  const origin = await stringifyGithubOrigin(parseGithubRepoUrl(forkUrl));
+  const repo = parseGithubRepoUrl(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}
+git clone --single-branch ${upstreamUrl} ${cwd}
 `;
 
   //   // also pull from existed forked branch
@@ -188,7 +190,8 @@ git push "${origin}" ${branch}:${branch}
 
 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"));
+    (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];
@@ -196,7 +199,9 @@ export async function pyprojectTomlUpdateLicenses(tomlFile: string, upstreamRepo
   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 (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
 
@@ -216,7 +221,7 @@ export async function pyprojectTomlUpdateLicenses(tomlFile: string, upstreamRepo
 
   // - [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 resp = await gh.repos.get({ ...parseGithubRepoUrl(upstreamRepoUrl) });
     const license = resp.data.license;
     if (!license) return null;
     return `license = { text = "${license?.name}" }`;
@@ -228,18 +233,9 @@ export async function pyprojectTomlUpdateLicenses(tomlFile: string, upstreamRepo
     );
 
   const replaced = raw.replace(licenseLine, () => updated);
-  if (replaced === raw) DIE(new Error("licenseLine not matched", { cause: { raw, 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);
-}