comfy-pr 0.2.24 → 0.2.26

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

@@ -1,60 +1,47 @@
-import pMap from "p-map";
-import { match } from "ts-pattern";
-import { fetchRelatedPullWithComments } from "./fetchRelatedPullWithComments";
-import type { GithubPullParsed } from "./parsePullsState";
-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;
-        };
-      }
-  )[]
-> {
-  const pyproject = await readTemplateTitle("add-toml.md");
-  const publishcr = await readTemplateTitle("add-action.md");
-  const relatedPulls = await pMap(pulls, async (pull) =>
-    match(pull)
-      .with({ title: pyproject }, (pull) => ({
-        type: "pyproject" as const,
-        pull,
-      }))
-      .with({ title: publishcr }, (pull) => ({
-        type: "publishcr" as const,
-        pull,
-      }))
-      .otherwise(() => null),
-  );
-  return relatedPulls.flatMap((e) => (e ? [e] : []));
-}
+import pMap from "p-map";
+import { match } from "ts-pattern";
+import { fetchRelatedPullWithComments } from "./fetchRelatedPullWithComments";
+import type { GithubPullParsed } from "./parsePullsState";
+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" | "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,
+      }))
+      .otherwise(() => null),
+  );
+  return relatedPulls.flatMap((e) => (e ? [e] : []));
+}

package/src/muteInstances.ts

@@ -1,16 +1,16 @@
-#!/usr/bin/env bun
-import { readFile, writeFile } from "fs/promises";
-import { globby } from "globby";
-import pMap from "p-map";
-if (import.meta.main) {
-  const files = await globby("node_modules/**/*instance*.js");
-  await pMap(files, async (file) => {
-    const x = await readFile(file, "utf8");
-    const y = x.replace(/console.warn/, ";");
-    if (x !== y) {
-      await writeFile(file, y);
-      console.log("muted: " + file);
-    }
-  });
-  console.log("done");
-}
+#!/usr/bin/env bun
+import { readFile, writeFile } from "fs/promises";
+import { globby } from "globby";
+import pMap from "p-map";
+if (import.meta.main) {
+  const files = await globby("node_modules/**/*instance*.js");
+  await pMap(files, async (file) => {
+    const x = await readFile(file, "utf8");
+    const y = x.replace(/console.warn/, ";");
+    if (x !== y) {
+      await writeFile(file, y);
+      console.log("muted: " + file);
+    }
+  });
+  console.log("done");
+}

package/src/parseIssueUrl.ts

@@ -1,6 +1,6 @@
-export function parseIssueUrl(issueUrl: string) {
-  const [owner, repo, strNumber] = issueUrl
-    .match(/^https:\/\/github\.com\/([\w-]+)\/([\w-]+)\/(?:pull|issues)\/(\d+)$/)!
-    .slice(1);
-  return { owner, repo, issue_number: Number(strNumber) };
-}
+export function parseIssueUrl(issueUrl: string) {
+  const [owner, repo, strNumber] = issueUrl
+    .match(/^https:\/\/github\.com\/([\w-]+)\/([\w-]+)\/(?:pull|issues)\/(\d+)$/)!
+    .slice(1);
+  return { owner, repo, issue_number: Number(strNumber) };
+}

package/src/parseOwnerRepo.ts

@@ -1,33 +1,33 @@
-import { basename, dirname } from "path";
-
-/**
- * Parse owner and repo obj
- * @param gitUrl git@github.ocm:owner/repo or https://github.ocm/owner/repo
- */
-export function parseUrlRepoOwner(gitUrl: string) {
-  return {
-    owner: basename(dirname(gitUrl.replace(/:/, "/"))),
-    repo: basename(gitUrl.replace(/:/, "/")).replace(/\.git$/, ""),
-  };
-}
-export function stringifyOwnerRepo({ owner, repo }: ReturnType<typeof parseUrlRepoOwner>) {
-  return owner + "/" + repo;
-}
-export function stringifyGithubRepoUrl({ owner, repo }: ReturnType<typeof parseUrlRepoOwner>) {
-  return "https://github.com/" + owner + "/" + repo;
-}
-export async function stringifyGithubOrigin({ owner, repo }: ReturnType<typeof parseUrlRepoOwner>) {
-  const PR_TOKEN = process.env.GH_TOKEN_COMFY_PR;
-  if (PR_TOKEN) {
-    // fails: maybe permission issue
-    // const USERNAME = (
-    //   await new Octokit({
-    //     auth: PR_TOKEN,
-    //   }).rest.users.getAuthenticated()
-    // ).data.login;
-    // return `https://${USERNAME}:${PR_TOKEN}@github.com/${owner}/${repo}`;
-
-    return `git@github.com:${owner}/${repo}`;
-  }
-  return `git@github.com:${owner}/${repo}`;
-}
+import { basename, dirname } from "path";
+
+/**
+ * Parse owner and repo obj
+ * @param gitUrl git@github.ocm:owner/repo or https://github.ocm/owner/repo
+ */
+export function parseUrlRepoOwner(gitUrl: string) {
+  return {
+    owner: basename(dirname(gitUrl.replace(/:/, "/"))),
+    repo: basename(gitUrl.replace(/:/, "/")).replace(/\.git$/, ""),
+  };
+}
+export function stringifyOwnerRepo({ owner, repo }: ReturnType<typeof parseUrlRepoOwner>) {
+  return owner + "/" + repo;
+}
+export function stringifyGithubRepoUrl({ owner, repo }: ReturnType<typeof parseUrlRepoOwner>) {
+  return "https://github.com/" + owner + "/" + repo;
+}
+export async function stringifyGithubOrigin({ owner, repo }: ReturnType<typeof parseUrlRepoOwner>) {
+  const PR_TOKEN = process.env.GH_TOKEN_COMFY_PR;
+  if (PR_TOKEN) {
+    // fails: maybe permission issue
+    // const USERNAME = (
+    //   await new Octokit({
+    //     auth: PR_TOKEN,
+    //   }).rest.users.getAuthenticated()
+    // ).data.login;
+    // return `https://${USERNAME}:${PR_TOKEN}@github.com/${owner}/${repo}`;
+
+    return `git@github.com:${owner}/${repo}`;
+  }
+  return `git@github.com:${owner}/${repo}`;
+}

package/src/parsePullUrl.ts

@@ -1,6 +1,6 @@
-export function parsePullUrl(issueUrl: string) {
-  const [owner, repo, strNumber] = issueUrl
-    .match(/^https:\/\/github\.com\/([\w-]+)\/([\w-]+)\/(?:pull)\/(\d+)$/)!
-    .slice(1);
-  return { owner, repo, pull_number: Number(strNumber) };
-}
+export function parsePullUrl(issueUrl: string) {
+  const [owner, repo, strNumber] = issueUrl
+    .match(/^https:\/\/github\.com\/([\w-]+)\/([\w-]+)\/(?:pull)\/(\d+)$/)!
+    .slice(1);
+  return { owner, repo, pull_number: Number(strNumber) };
+}

package/src/parsePullsState.ts

@@ -1,6 +1,6 @@
-import type { GithubPull } from "./gh/GithubPull";
-import { parsePull } from "./gh/parsePull";
-export type GithubPullParsed = ReturnType<typeof parsePulls>[number];
-export function parsePulls(data: GithubPull[]) {
-  return data.map((e) => parsePull(e));
-}
+import type { GithubPull } from "./gh/GithubPull";
+import { parsePull } from "./gh/parsePull";
+export type GithubPullParsed = ReturnType<typeof parsePulls>[number];
+export function parsePulls(data: GithubPull[]) {
+  return data.map((e) => parsePull(e));
+}

package/src/parseTitleBodyOfMarkdown.ts

@@ -1,8 +1,8 @@
-import DIE from "@snomiao/die";
-
-export function parseTitleBodyOfMarkdown(tmpl: string) {
-  tmpl.startsWith("# ") || DIE("Unrecognized template format:" + tmpl);
-  const title = tmpl.split("\n")[0].slice(1).trim();
-  const body = tmpl.split("\n").slice(1).join("\n").trim();
-  return { title, body };
-}
+import DIE from "@snomiao/die";
+
+export function parseTitleBodyOfMarkdown(tmpl: string) {
+  tmpl.startsWith("# ") || DIE("Unrecognized template format:" + tmpl);
+  const title = tmpl.split("\n")[0].slice(1).trim();
+  const body = tmpl.split("\n").slice(1).join("\n").trim();
+  return { title, body };
+}

package/src/postSlackMessage.ts

@@ -1,21 +1,21 @@
-import DIE from "@snomiao/die";
-import { slack } from "./slack";
-
-export async function postSlackMessage(text: string) {
-  const channel = process.env.SLACK_BOT_CHANNEL || DIE(new Error("missing env.SLACK_BOT_CHANNEL"));
-  // this api will auto retry if failed
-  const response = await slack.chat.postMessage({
-    channel,
-    text,
-    blocks: [
-      {
-        type: "section",
-        text: {
-          type: "mrkdwn",
-          text: text,
-        },
-      },
-    ],
-  });
-  return { channel, ts: response.ts, text };
-}
+import DIE from "@snomiao/die";
+import { slack } from "./slack";
+
+export async function postSlackMessage(text: string) {
+  const channel = process.env.SLACK_BOT_CHANNEL || DIE(new Error("missing env.SLACK_BOT_CHANNEL"));
+  // this api will auto retry if failed
+  const response = await slack.chat.postMessage({
+    channel,
+    text,
+    blocks: [
+      {
+        type: "section",
+        text: {
+          type: "mrkdwn",
+          text: text,
+        },
+      },
+    ],
+  });
+  return { channel, ts: response.ts, text };
+}

package/src/preload.ts

@@ -1,30 +1,30 @@
-await Bun.plugin({
-  name: "YAML",
-  async setup(build) {
-    const { load } = await import("js-yaml");
-
-    // when a .yaml file is imported...
-    build.onLoad({ filter: /\.(yaml|yml)$/ }, async (args) => {
-      // read and parse the file
-      const text = await Bun.file(args.path).text();
-      const exports = load(text) as Record<string, any>;
-
-      // and returns it as a module
-      return {
-        exports,
-        loader: "object", // special loader for JS objects
-      };
-    });
-  },
-});
-
-Bun.plugin({
-  name: "preload-plugin",
-  setup(builder) {
-    builder.onLoad({ filter: /\.ts$/ }, async (args) => {
-      const text = await Bun.file(args.path).text();
-      // console.log("text", text);
-      return { contents: text, loader: args.loader };
-    });
-  },
-});
+await Bun.plugin({
+  name: "YAML",
+  async setup(build) {
+    const { load } = await import("js-yaml");
+
+    // when a .yaml file is imported...
+    build.onLoad({ filter: /\.(yaml|yml)$/ }, async (args) => {
+      // read and parse the file
+      const text = await Bun.file(args.path).text();
+      const exports = load(text) as Record<string, any>;
+
+      // and returns it as a module
+      return {
+        exports,
+        loader: "object", // special loader for JS objects
+      };
+    });
+  },
+});
+
+Bun.plugin({
+  name: "preload-plugin",
+  setup(builder) {
+    builder.onLoad({ filter: /\.ts$/ }, async (args) => {
+      const text = await Bun.file(args.path).text();
+      // console.log("text", text);
+      return { contents: text, loader: args.loader };
+    });
+  },
+});

package/src/pullStatusFollowSchema.ts

@@ -1,12 +1,12 @@
-import { z } from "zod";
-
-export const zPullStatusFollow = z.array(
-  z.object({
-    updated: z.string(),
-    state: z.string(),
-    url: z.string(),
-    head: z.string(),
-    comments: z.number(),
-    lastwords: z.string(),
-  }),
-);
+import { z } from "zod";
+
+export const zPullStatusFollow = z.array(
+  z.object({
+    updated: z.string(),
+    state: z.string(),
+    url: z.string(),
+    head: z.string(),
+    comments: z.number(),
+    lastcomment: z.string(),
+  }),
+);