367d057 | website

git clone https://git.pyrossh.dev/website

木 Personal website of pyrossh. Built with astrojs, shiki, vite.

367d057 — pyrossh 2026-07-07T10:59:58+05:30

refactr

Generated files not shown: pnpm-lock.yaml

Files changed (27) hide show

astro.config.mjs +26 -5
ec.config.mjs +1 -0
package.json +8 -2
playwright.config.ts +2 -1
src/actions/index.ts +10 -3
src/components/RecursiveList.astro +0 -1
src/layouts/FileLayout.astro +2 -1
src/layouts/RepoLayout.astro +2 -1
src/pages/repos/[...repoId]/commits/[...hash]/index.astro +5 -2
src/pages/repos/[...repoId]/commits/index.astro +4 -1
src/pages/repos/[...repoId]/files/[...file]/blame/index.astro +5 -2
src/pages/repos/[...repoId]/files/[...file]/history/index.astro +5 -2
src/pages/repos/[...repoId]/files/[...file]/index.astro +20 -8
src/pages/repos/[...repoId]/files/index.astro +4 -1
src/pages/repos/[...repoId]/index.astro +8 -2
src/pages/repos/[...repoId]/issues/[...issueId]/index.astro +3 -5
src/pages/repos/[...repoId]/issues/index.astro +2 -1
src/utils/commit.ts +10 -96
src/utils/content.ts +2 -31
src/utils/files.ts +0 -10
src/utils/gitBug.ts +47 -94
src/utils/gitReader.ts +741 -0
src/utils/markdown.ts +17 -0
src/utils/repoContent.ts +8 -0
tests/repos.spec.ts +59 -0
worker-configuration.d.ts +1 -1
wrangler.toml +6 -4

astro.config.mjs CHANGED Viewed

@@ -16,13 +16,34 @@ export default defineConfig({
     enabled: false,
   },
   vite: {
+    plugins: [
-    plugins: [Icons({ compiler: "astro" })],
+      Icons({ compiler: "astro" }),
+      {
+        name: "externalize-spamscanner",
+        enforce: "pre",
+        resolveId(source) {
+          if (
+            [
+              "spamscanner",
+              "stopword",
+              "striptags",
+              "url-regex-safe",
+              "email-regex-safe",
+              "mailparser",
+              "superagent",
+              "re2",
+            ].includes(source)
+          ) {
+            return { id: source, external: true };
+          }
+        },
+      },
+    ],
+    optimizeDeps: {
+      exclude: ["re2", "@mapbox/node-pre-gyp", "superagent", "spamscanner"],
+    },
     ssr: {
       external: ["svgo"],
-      // isomorphic-git pulls in a couple of legacy CJS-only packages; force
-      // Vite to bundle them so their `module.exports` interop is resolved
-      // at build time instead of relying on runtime globals.
-      // noExternal: ["isomorphic-git", "pify", "crc-32", "async-lock"],
     },
   },
 });

ec.config.mjs CHANGED Viewed

@@ -3,6 +3,7 @@ import { defineEcConfig } from "astro-expressive-code";
 export default defineEcConfig({
   // themes: [],
   shiki: {
+    engine: "javascript",
     langAlias: {
       h: "c",
       ino: "c",

package.json CHANGED Viewed

@@ -19,10 +19,16 @@
     "astro-color-scheme": "^1.1.6",
     "astro-expressive-code": "^0.42.0",
     "diff": "^9.0.0",
-    "isomorphic-git": "^1.38.6",
+    "gray-matter": "^4.0.3",
     "marked": "^18.0.5",
     "pretty-bytes": "^7.1.0",
+    "rehype-expressive-code": "^0.44.0",
+    "rehype-stringify": "^10.0.1",
+    "remark-parse": "^11.0.0",
+    "remark-rehype": "^11.1.2",
+    "spamscanner": "^6.1.5",
-    "timeago.js": "^4.0.2"
+    "timeago.js": "^4.0.2",
+    "unified": "^11.0.5"
   },
   "devDependencies": {
     "@astrojs/check": "^0.9.9",

playwright.config.ts CHANGED Viewed

@@ -18,8 +18,9 @@ export default defineConfig({
     },
   ],
   webServer: {
-    command: "bun run dev",
+    command: "pnpm run build && pnpm wrangler dev --port 4321",
     url: "http://localhost:4321",
     reuseExistingServer: !process.env.CI,
+    timeout: 120000,
   },
 });

src/actions/index.ts CHANGED Viewed

@@ -1,3 +1,4 @@
+import { env } from "cloudflare:workers";
 import { defineAction } from "astro:actions";
 import { z } from "astro/zod";
 import { addGitBugIssueComment, createGitBugIssue, setGitBugIssueState } from "@/utils/gitBug";
@@ -16,7 +17,7 @@ export const server = {
       labels: z.string().trim().optional(),
     }),
     handler: async (input) => {
-      return await createGitBugIssue(input.repoId, {
+      return await createGitBugIssue(env.REPOS, input.repoId, {
         title: input.title,
         body: input.body,
         author: input.author,
@@ -36,7 +37,7 @@ export const server = {
       author: z.string().trim().optional(),
     }),
     handler: async (input) => {
-      return await addGitBugIssueComment(input.repoId, input.issueId, {
+      return await addGitBugIssueComment(env.REPOS, input.repoId, input.issueId, {
         body: input.body,
         author: input.author,
       });
@@ -51,7 +52,13 @@ export const server = {
       author: z.string().trim().optional(),
     }),
     handler: async (input) => {
-      return await setGitBugIssueState(input.repoId, input.issueId, input.state, input.author);
+      return await setGitBugIssueState(
+        env.REPOS,
+        input.repoId,
+        input.issueId,
+        input.state,
+        input.author,
+      );
     },
   }),
 };

src/components/RecursiveList.astro CHANGED Viewed

@@ -10,7 +10,6 @@ interface FileNode {
   isDirectory: boolean;
   size: number;
   ext: string;
-  absolutePath: string;
   children?: FileNode[];
 }

src/layouts/FileLayout.astro CHANGED Viewed

@@ -2,7 +2,8 @@
 import DynamicIcon from "@/components/DynamicIcon.astro";
 import RepoLayout from "@/layouts/RepoLayout.astro";
 import { resolveFileIcon, type FileNode } from "@/utils/files";
-import type { RepoEntry } from "@/utils/repos";
+import type { RuntimeRepo } from "@/utils/content";
+type RepoEntry = RuntimeRepo;
 type Props = {
   repo: RepoEntry;

src/layouts/RepoLayout.astro CHANGED Viewed

@@ -1,7 +1,8 @@
 ---
 import MdiInformationOutline from "~icons/mdi/information-outline";
 import Layout from "@/layouts/BaseLayout.astro";
-import type { RepoEntry } from "@/utils/repos";
+import type { RuntimeRepo } from "@/utils/content";
+type RepoEntry = RuntimeRepo;
 type Props = {
   repo: RepoEntry;

src/pages/repos/[...repoId]/commits/[...hash]/index.astro CHANGED Viewed

@@ -1,4 +1,5 @@
 ---
+import { env } from "cloudflare:workers";
 import RepoLayout from "@/layouts/RepoLayout.astro";
 import Commit from "@/components/Commit.astro";
 import { generateHTMLDiff, getCommits } from "@/utils/commit";
@@ -10,13 +11,15 @@ if (!repo) {
   return Astro.redirect("/404");
 }
-const commits = await getCommits(repo.data.absolutePath);
+const commits = await getCommits(env.REPOS, repo.id);
 const commit = commits.find((item) => item.hash === Astro.params.hash);
 if (!commit) {
   return Astro.redirect(`/repos/${repo.id}/commits`);
 }
-const diffHtml = await generateHTMLDiff(repo.data.absolutePath, commit.hash);
+const diffHtml = await generateHTMLDiff(env.REPOS, repo.id, commit.hash);
+Astro.response.headers.set("Cache-Control", "public, max-age=300, s-maxage=3600");
 ---
 <RepoLayout repo={repo}>

src/pages/repos/[...repoId]/commits/index.astro CHANGED Viewed

@@ -1,4 +1,5 @@
 ---
+import { env } from "cloudflare:workers";
 import RepoLayout from "@/layouts/RepoLayout.astro";
 import Commit from "@/components/Commit.astro";
 import { getCommits } from "@/utils/commit";
@@ -9,7 +10,9 @@ if (!repo) {
   return Astro.redirect("/404");
 }
-const commits = await getCommits(repo.data.absolutePath);
+const commits = await getCommits(env.REPOS, repo.id);
+Astro.response.headers.set("Cache-Control", "public, max-age=300, s-maxage=3600");
 ---
 <RepoLayout repo={repo}>

src/pages/repos/[...repoId]/files/[...file]/blame/index.astro CHANGED Viewed

@@ -1,4 +1,5 @@
 ---
+import { env } from "cloudflare:workers";
 import FileLayout from "@/layouts/FileLayout.astro";
 import { getFileHistory, getFiles } from "@/utils/commit";
 import { getRepo } from "@/utils/content";
@@ -8,13 +9,15 @@ if (!repo) {
   return Astro.redirect("/404");
 }
-const files = await getFiles(repo.data.absolutePath);
+const files = await getFiles(env.REPOS, repo.id);
 const file = files.find((item) => item.name === Astro.params.file);
 if (!file) {
   return Astro.redirect(`/repos/${repo.id}/files`);
 }
-const history = await getFileHistory(repo.data.absolutePath, file.absolutePath);
+const history = await getFileHistory(env.REPOS, repo.id, file.absolutePath);
+Astro.response.headers.set("Cache-Control", "public, max-age=300, s-maxage=3600");
 ---
 <FileLayout repo={repo} file={file}> WIP: Work in Progress... </FileLayout>

src/pages/repos/[...repoId]/files/[...file]/history/index.astro CHANGED Viewed

@@ -1,4 +1,5 @@
 ---
+import { env } from "cloudflare:workers";
 import FileLayout from "@/layouts/FileLayout.astro";
 import Commit from "@/components/Commit.astro";
 import { getFileHistory, getFiles } from "@/utils/commit";
@@ -9,13 +10,15 @@ if (!repo) {
   return Astro.redirect("/404");
 }
-const files = await getFiles(repo.data.absolutePath);
+const files = await getFiles(env.REPOS, repo.id);
 const file = files.find((item) => item.name === Astro.params.file);
 if (!file) {
   return Astro.redirect(`/repos/${repo.id}/files`);
 }
-const history = await getFileHistory(repo.data.absolutePath, file.absolutePath);
+const history = await getFileHistory(env.REPOS, repo.id, file.absolutePath);
+Astro.response.headers.set("Cache-Control", "public, max-age=300, s-maxage=3600");
 ---
 <FileLayout repo={repo} file={file}>

src/pages/repos/[...repoId]/files/[...file]/index.astro CHANGED Viewed

@@ -1,8 +1,8 @@
 ---
-import fs from "fs/promises";
+import { env } from "cloudflare:workers";
 import { Code } from "astro-expressive-code/components";
 import FileLayout from "@/layouts/FileLayout.astro";
-import { getFiles } from "@/utils/commit";
+import { getFiles, getFileContentData } from "@/utils/commit";
 import { getRepo } from "@/utils/content";
 const repo = getRepo(Astro.params.repoId);
@@ -10,13 +10,13 @@ if (!repo) {
   return Astro.redirect("/404");
 }
-const files = await getFiles(repo.data.absolutePath);
+const files = await getFiles(env.REPOS, repo.id);
 const file = files.find((item) => item.name === Astro.params.file);
 if (!file) {
   return Astro.redirect(`/repos/${repo.id}/files`);
 }
-const contentBuffer = await fs.readFile(file.absolutePath);
+const contentBuffer = await getFileContentData(env.REPOS, repo.id, file.absolutePath);
 const isBinary = ["apk", "dex", "ap_", "jar", "fnt"].includes(file.ext);
 const isLarge = file.size > 1024 * 512; // 512KB
 const isImage = [
@@ -31,6 +31,16 @@ const isImage = [
   "curve",
   "atlas",
 ].includes(file.ext);
+Astro.response.headers.set("Cache-Control", "public, max-age=300, s-maxage=3600");
+const toBase64 = (data: Uint8Array) => {
+  let binary = "";
+  for (let i = 0; i < data.length; i++) {
+    binary += String.fromCharCode(data[i]);
+  }
+  return btoa(binary);
+};
 ---
 <FileLayout repo={repo} file={file}>
@@ -38,18 +48,20 @@ const isImage = [
     {
       isBinary || isLarge ? (
         <p>The file is too large to be displayed ({file.size} bytes).</p>
-      ) : isImage ? (
+      ) : isImage && contentBuffer ? (
         <img
-          src={`data:image/${file.ext};base64,${contentBuffer.toString("base64")}`}
+          src={`data:image/${file.ext};base64,${toBase64(contentBuffer)}`}
           alt={file.path}
         />
-      ) : (
+      ) : contentBuffer ? (
         <Code
           code={
-            contentBuffer.toString("utf-8").trim() || "No content to display."
+            new TextDecoder("utf-8").decode(contentBuffer).trim() || "No content to display."
           }
           lang={file.ext || "txt"}
         />
+      ) : (
+        <p>Unable to load file content.</p>
       )
     }
   </div>

src/pages/repos/[...repoId]/files/index.astro CHANGED Viewed

@@ -1,4 +1,5 @@
 ---
+import { env } from "cloudflare:workers";
 import RepoLayout from "@/layouts/RepoLayout.astro";
 import RecursiveList from "@/components/RecursiveList.astro";
 import { getFiles } from "@/utils/commit";
@@ -10,8 +11,10 @@ if (!repo) {
   return Astro.redirect("/404");
 }
-const files = await getFiles(repo.data.absolutePath);
+const files = await getFiles(env.REPOS, repo.id);
 const sortedFiles = sortChildren(buildFileTree(files));
+Astro.response.headers.set("Cache-Control", "public, max-age=300, s-maxage=3600");
 ---
 <RepoLayout repo={repo}>

src/pages/repos/[...repoId]/index.astro CHANGED Viewed

@@ -1,13 +1,19 @@
 ---
+import { env } from "cloudflare:workers";
 import RepoLayout from "@/layouts/RepoLayout.astro";
+import { getRepo } from "@/utils/content";
-import { getRepo, getRepoReadmeHtml } from "@/utils/content";
+import { getRepoReadme } from "@/utils/repoContent";
+import { renderMarkdown } from "@/utils/markdown";
 const repo = getRepo(Astro.params.repoId);
 if (!repo) {
   return Astro.redirect("/404");
 }
-const readmeHtml = await getRepoReadmeHtml(repo);
+const readmeRaw = await getRepoReadme(env.REPOS, repo.id);
+const readmeHtml = readmeRaw ? await renderMarkdown(readmeRaw) : "";
+Astro.response.headers.set("Cache-Control", "public, max-age=300, s-maxage=3600");
 ---
 <RepoLayout repo={repo}>

src/pages/repos/[...repoId]/issues/[...issueId]/index.astro CHANGED Viewed

@@ -1,20 +1,18 @@
 ---
+import { env } from "cloudflare:workers";
 import { actions } from "astro:actions";
 import RepoLayout from "@/layouts/RepoLayout.astro";
 import Issue from "@/components/Issue.astro";
 import TimeAgo from "@/components/TimeAgo.astro";
 import { getRepo } from "@/utils/content";
-import {
-  getGitBugIssue,
-  getGitBugIssues,
-} from "@/utils/gitBug";
+import { getGitBugIssue } from "@/utils/gitBug";
 const repo = getRepo(Astro.params.repoId);
 if (!repo) {
   return Astro.redirect("/404");
 }
-const issue = await getGitBugIssue(repo.id, Astro.params.issueId ?? "");
+const issue = await getGitBugIssue(env.REPOS, repo.id, Astro.params.issueId ?? "");
 if (!issue) {
   return Astro.redirect(`/repos/${repo.id}/issues`);
 }

src/pages/repos/[...repoId]/issues/index.astro CHANGED Viewed

@@ -1,4 +1,5 @@
 ---
+import { env } from "cloudflare:workers";
 import { actions } from "astro:actions";
 import RepoLayout from "@/layouts/RepoLayout.astro";
 import Issue from "@/components/Issue.astro";
@@ -10,7 +11,7 @@ if (!repo) {
   return Astro.redirect("/404");
 }
-const { issues, isAvailable } = await getGitBugIssues(repo.id);
+const { issues, isAvailable } = await getGitBugIssues(env.REPOS, repo.id);
 const openIssues = issues.filter((issue) => issue.state === "open");
 const closedIssues = issues.filter((issue) => issue.state === "closed");
 ---

src/utils/commit.ts CHANGED Viewed

@@ -1,98 +1,12 @@
+import {
+  type Commit,
+  generateHTMLDiff,
+  getCommits,
-import { html, parse } from "diff2html";
+  getFileContentData,
+  getFileHistory,
+  getFiles,
-import fs from "fs/promises";
+} from "./gitReader";
-import path from "path";
-import { simpleGit } from "simple-git";
 import { type FileNode } from "./files";
-export interface Commit {
-  hash: string;
-  message: string;
-  body: string;
-  author_name: string;
-  author_email: string;
-  date: string;
-  branches: string[];
-  tags: string[];
-}
-export const collectCommits = (item: {
+export type { Commit, FileNode };
-  hash: any;
-  message: any;
-  body: any;
-  author_name: any;
-  author_email: any;
-  date: any;
-  refs: string;
-}) => ({
-  hash: item.hash,
-  message: item.message,
-  body: `${item.message}\n\n${item.body}`,
-  author_name: item.author_name,
-  author_email: item.author_email,
-  date: item.date,
-  branches: item.refs
-    .split(",")
-    .filter((ref: string) => !ref.includes("origin"))
-    .map((ref) => ref.trim()),
-  tags: item.refs
-    .split(",")
-    .filter((ref: string) => ref.includes("tag: "))
-    .map((ref) => ref.replace("tag: ", "")),
-});
-export const getCommits = async (repoPath: string): Promise<Commit[]> => {
-  const git = simpleGit(repoPath);
-  const commits = await git.log(["--branches", "--tags"]);
-  return commits.all.map(collectCommits);
-};
-export const getFiles = async (repoPath: string): Promise<FileNode[]> => {
-  const git = simpleGit(repoPath);
-  const paths = await git.raw(["ls-files"]);
-  const files = [];
-  for (const p of paths.split("\n").filter((p) => p.length > 0)) {
-    try {
-      const stat = await fs.stat(`${repoPath}/${p}`);
-      const ext = path.extname(p).replace(".", "");
-      const name = p.endsWith("index.html") ? p.replace("index.html", "index_html") : p;
-      files.push({
-        name,
-        ext,
-        size: stat.size,
-        isDirectory: stat.isDirectory(),
-        absolutePath: `${repoPath}/${p}`,
-      });
-    } catch (e) {
-      // Ignore files not found
-      console.log(e);
-    }
-  }
-  return files;
-};
-export const getFileHistory = async (repoPath: string, filePath: string): Promise<Commit[]> => {
-  const git = simpleGit(repoPath);
-  const stat = await fs.stat(`${filePath}`);
-  const isLarge = stat.size > 1024 * 512;
-  const history = isLarge ? { all: [] } : await git.log([filePath.replace(`${repoPath}/`, "")]);
-  return history.all.map(collectCommits);
-};
-export const generateHTMLDiff = async (repoPath: string, hash: string): Promise<string> => {
+export { generateHTMLDiff, getCommits, getFileContentData, getFileHistory, getFiles };
-  const git = simpleGit(repoPath);
-  let diff = "";
-  try {
-    diff = await git.diff([`${hash}^..${hash}`]);
-  } catch (e) {
-    diff = await git.diff([hash]);
-  }
-  if (diff.length > 1024 * 512) {
-    return "<p>Diff too large to display.</p>";
-  }
-  const diffJson = parse(diff);
-  const diffHtml = html(diffJson, {
-    drawFileList: true,
-    matching: "lines",
-  });
-  return diffHtml;
-};

src/utils/content.ts CHANGED Viewed

@@ -1,13 +1,8 @@
 import fs from "fs/promises";
 import path from "path";
 import matter from "gray-matter";
-import rehypeExpressiveCode from "rehype-expressive-code";
-import rehypeStringify from "rehype-stringify";
-import remarkParse from "remark-parse";
-import remarkRehype from "remark-rehype";
-import { unified } from "unified";
 import { REPOS } from "@/consts";
-import ecConfig from "../../ec.config.mjs";
+import { renderMarkdown } from "./markdown";
 export interface RuntimeRepo {
   id: string;
@@ -15,7 +10,6 @@ export interface RuntimeRepo {
     title: string;
     description: string;
     tags: string[];
-    absolutePath: string;
   };
 }
@@ -34,17 +28,6 @@ export interface RuntimePost {
 const contentDir = path.resolve("src/content");
-const renderMarkdown = async (markdown: string) => {
-  const file = await unified()
-    .use(remarkParse)
-    .use(remarkRehype)
-    .use(rehypeExpressiveCode, ecConfig)
-    .use(rehypeStringify)
-    .process(markdown);
-  return String(file);
-};
 const toDate = (value: unknown) => {
   if (value instanceof Date) {
     return value;
@@ -69,23 +52,11 @@ const readMarkdownFiles = async (dir: string): Promise<string[]> => {
 export const getRepos = (): RuntimeRepo[] =>
   REPOS.map((repo) => ({
     id: repo.title,
-    data: {
-      ...repo,
+    data: { ...repo },
-      absolutePath: `/Users/pyrossh/Code/pyrossh/${repo.title}`,
-    },
   }));
 export const getRepo = (repoId?: string) => getRepos().find((repo) => repo.id === repoId);
-export const getRepoReadmeHtml = async (repo: RuntimeRepo) => {
-  try {
-    const readme = await fs.readFile(path.join(repo.data.absolutePath, "README.md"), "utf-8");
-    return await renderMarkdown(readme);
-  } catch {
-    return "";
-  }
-};
 export const getPosts = async (): Promise<RuntimePost[]> => {
   const files = await readMarkdownFiles(contentDir);
   const posts = await Promise.all(

src/utils/files.ts CHANGED Viewed

@@ -1,4 +1,3 @@
-import fs from "fs/promises";
 import { extensions as folderExtensions } from "vscode-icons/src/iconsManifest/supportedFolders.ts";
 import { extensions as fileExtensions } from "vscode-icons/src/iconsManifest/supportedExtensions.ts";
@@ -68,15 +67,6 @@ export const buildFileTree = (files: any[]): FileNode[] => {
   return root;
 };
-export const checkFileExists = async (filePath: string) => {
-  try {
-    await fs.stat(filePath);
-    return true; // File exists
-  } catch (error) {
-    return false; // File does not exist or cannot be accessed
-  }
-};
 export const resolveFolderIcon = (foldername: string) => {
   for (const item of folderExtensions.supported) {
     if (item.extensions?.includes(foldername)) {

src/utils/gitBug.ts CHANGED Viewed

@@ -1,10 +1,3 @@
-import {
-  GetObjectCommand,
-  ListObjectsV2Command,
-  PutObjectCommand,
-  S3Client,
-} from "@aws-sdk/client-s3";
 export type GitBugIssueState = "open" | "closed";
 export interface GitBugIssue {
@@ -52,7 +45,6 @@ const issuesPrefix = (repoId: string) => `${safeRepoId(repoId)}/issues/`;
 const issueKey = (repoId: string, issueId: string) =>
   `${issuesPrefix(repoId)}${safeIssueId(issueId)}.json`;
 let spamScanner: SpamScanner | undefined;
-let s3Client: S3Client | undefined;
 const normalizeLabels = (labels?: string[]) =>
   labels?.map((label) => label.trim()).filter(Boolean) ?? [];
@@ -61,14 +53,19 @@ const safeHeaderValue = (value: string) => value.replaceAll(/[\r\n]+/g, " ").tri
 const getSpamScanner = async () => {
   if (!spamScanner) {
+    try {
-    const { default: SpamScanner } = await import("spamscanner");
+      const { default: SpamScanner } = await import("spamscanner");
-    spamScanner = new SpamScanner({
+      spamScanner = new SpamScanner({
-      enableAuthentication: false,
+        enableAuthentication: false,
-      enableNsfwDetection: true,
+        enableNsfwDetection: true,
-      enableReputation: true,
+        enableReputation: true,
-      enableToxicityDetection: true,
+        enableToxicityDetection: true,
-      timeout: 10_000,
+        timeout: 10_000,
-    });
+      });
+    } catch {
+      console.warn("Spam scanner not available (unsupported in Workers environment)");
+      return undefined;
+    }
   }
   return spamScanner;
@@ -103,6 +100,8 @@ const assertNotSpam = async (input: {
   labels?: string[];
 }) => {
   const scanner = await getSpamScanner();
+  if (!scanner) return;
   const result = await scanner.scan(makeSpamScanEmail(input));
   if (result.isSpam) {
@@ -110,54 +109,11 @@ const assertNotSpam = async (input: {
   }
 };
-const getR2Config = () => {
-  const bucket =
-    process.env.REPOS_R2_BUCKET ?? process.env.R2_BUCKET ?? process.env.AWS_BUCKET_NAME;
-  const endpoint =
-    process.env.R2_ENDPOINT ??
-    process.env.AWS_ENDPOINT_URL_S3 ??
-    (process.env.R2_ACCOUNT_ID
-      ? `https://${process.env.R2_ACCOUNT_ID}.r2.cloudflarestorage.com`
-      : undefined);
-  const accessKeyId = process.env.R2_ACCESS_KEY_ID ?? process.env.AWS_ACCESS_KEY_ID;
-  const secretAccessKey = process.env.R2_SECRET_ACCESS_KEY ?? process.env.AWS_SECRET_ACCESS_KEY;
-  if (!bucket || !endpoint || !accessKeyId || !secretAccessKey) {
-    throw new Error(
-      "Missing R2 configuration. Set REPOS_R2_BUCKET, R2_ENDPOINT or R2_ACCOUNT_ID, R2_ACCESS_KEY_ID, and R2_SECRET_ACCESS_KEY.",
-    );
-  }
-  return { bucket, endpoint, accessKeyId, secretAccessKey };
-};
-const getS3Client = () => {
-  if (!s3Client) {
-    const { endpoint, accessKeyId, secretAccessKey } = getR2Config();
-    s3Client = new S3Client({
-      region: "auto",
-      endpoint,
-      credentials: {
-        accessKeyId,
-        secretAccessKey,
-      },
-    });
-  }
-  return s3Client;
-};
-const getObjectJson = async <T>(key: string) => {
+const getObjectJson = async <T>(bucket: R2Bucket, key: string) => {
-  const { bucket } = getR2Config();
   try {
-    const object = await getS3Client().send(
+    const object = await bucket.get(key);
-      new GetObjectCommand({
+    if (object === null) return undefined;
-        Bucket: bucket,
-        Key: key,
-      }),
-    );
-    const body = await object.Body?.transformToString();
+    const body = await object.text();
     return body ? (JSON.parse(body) as T) : undefined;
   } catch (error) {
     if (error && typeof error === "object" && "name" in error && error.name === "NoSuchKey") {
@@ -168,44 +124,37 @@ const getObjectJson = async <T>(key: string) => {
   }
 };
-const putIssue = async (repoId: string, issue: GitBugIssue) => {
+const putIssue = async (bucket: R2Bucket, repoId: string, issue: GitBugIssue) => {
-  const { bucket } = getR2Config();
-  await getS3Client().send(
-    new PutObjectCommand({
-      Bucket: bucket,
-      Key: issueKey(repoId, issue.id),
-      Body: JSON.stringify(issue, null, 2),
+  await bucket.put(issueKey(repoId, issue.id), JSON.stringify(issue, null, 2), {
-      ContentType: "application/json; charset=utf-8",
+    httpMetadata: { contentType: "application/json; charset=utf-8" },
-    }),
+  });
-  );
   return issue;
 };
+export const getGitBugIssues = async (
+  bucket: R2Bucket,
+  repoId: string,
-export const getGitBugIssues = async (repoId: string): Promise<GitBugIssuesResult> => {
+): Promise<GitBugIssuesResult> => {
   try {
-    const { bucket } = getR2Config();
     const issues: GitBugIssue[] = [];
-    let continuationToken: string | undefined;
+    let cursor: string | undefined;
     do {
-      const page = await getS3Client().send(
+      const page = await bucket.list({
-        new ListObjectsV2Command({
-          Bucket: bucket,
-          Prefix: issuesPrefix(repoId),
+        prefix: issuesPrefix(repoId),
-          ContinuationToken: continuationToken,
+        cursor,
-        }),
+      });
-      );
       const pageIssues = await Promise.all(
-        (page.Contents ?? [])
+        page.objects
-          .filter((object) => object.Key?.endsWith(".json"))
+          .filter((object) => object.key.endsWith(".json"))
           .map(async (object) => {
-            return await getObjectJson<GitBugIssue>(object.Key ?? "");
+            return await getObjectJson<GitBugIssue>(bucket, object.key);
           }),
       );
       issues.push(...pageIssues.filter((issue): issue is GitBugIssue => Boolean(issue)));
-      continuationToken = page.IsTruncated ? page.NextContinuationToken : undefined;
+      cursor = page.truncated ? page.cursor : undefined;
-    } while (continuationToken);
+    } while (cursor);
     return {
       issues: issues.sort((a, b) => b.updatedAt.localeCompare(a.updatedAt)),
@@ -220,13 +169,15 @@ export const getGitBugIssues = async (repoId: string): Promise<GitBugIssuesResul
 };
 export const getGitBugIssue = async (
+  bucket: R2Bucket,
   repoId: string,
   issueId: string,
 ): Promise<GitBugIssue | undefined> => {
-  return await getObjectJson<GitBugIssue>(issueKey(repoId, issueId));
+  return await getObjectJson<GitBugIssue>(bucket, issueKey(repoId, issueId));
 };
 export const createGitBugIssue = async (
+  bucket: R2Bucket,
   repoId: string,
   input: {
     title: string;
@@ -256,10 +207,11 @@ export const createGitBugIssue = async (
     comments: [],
   };
-  return await putIssue(repoId, issue);
+  return await putIssue(bucket, repoId, issue);
 };
 export const addGitBugIssueComment = async (
+  bucket: R2Bucket,
   repoId: string,
   issueId: string,
   input: {
@@ -267,7 +219,7 @@ export const addGitBugIssueComment = async (
     author?: string;
   },
 ) => {
-  const issue = await getGitBugIssue(repoId, issueId);
+  const issue = await getGitBugIssue(bucket, repoId, issueId);
   if (!issue) {
     throw new Error("Issue not found.");
   }
@@ -280,7 +232,7 @@ export const addGitBugIssueComment = async (
   });
   const now = new Date().toISOString();
-  return await putIssue(repoId, {
+  return await putIssue(bucket, repoId, {
     ...issue,
     updatedAt: now,
     comments: [
@@ -296,17 +248,18 @@ export const addGitBugIssueComment = async (
 };
 export const setGitBugIssueState = async (
+  bucket: R2Bucket,
   repoId: string,
   issueId: string,
   state: GitBugIssueState,
   author?: string,
 ) => {
-  const issue = await getGitBugIssue(repoId, issueId);
+  const issue = await getGitBugIssue(bucket, repoId, issueId);
   if (!issue) {
     throw new Error("Issue not found.");
   }
-  return await putIssue(repoId, {
+  return await putIssue(bucket, repoId, {
     ...issue,
     author: author?.trim() || issue.author,
     state,

src/utils/gitReader.ts ADDED Viewed

@@ -0,0 +1,741 @@
+import { type FileNode } from "./files";
+export interface Commit {
+  hash: string;
+  message: string;
+  body: string;
+  author_name: string;
+  author_email: string;
+  date: string;
+  branches: string[];
+  tags: string[];
+}
+interface TreeEntry {
+  mode: string;
+  name: string;
+  oid: string;
+}
+interface ParsedIdx {
+  fanout: Uint32Array;
+  names: Uint8Array;
+  offsets: Uint32Array;
+  resolvedOffsets: Float64Array;
+  packKey: string;
+  packSize?: number;
+  nextOffsetByIndex: Float64Array;
+  offsetToNextOffset: Map<number, number>;
+}
+const hexToBytes = (hex: string): Uint8Array => {
+  const bytes = new Uint8Array(20);
+  for (let i = 0; i < 20; i++) {
+    bytes[i] = parseInt(hex.slice(i * 2, i * 2 + 2), 16);
+  }
+  return bytes;
+};
+const bytesToHex = (bytes: Uint8Array): string => {
+  return Array.from(bytes)
+    .map((b) => b.toString(16).padStart(2, "0"))
+    .join("");
+};
+const compareBytes = (a: Uint8Array, b: Uint8Array): number => {
+  for (let i = 0; i < a.length && i < b.length; i++) {
+    if (a[i] !== b[i]) return a[i] - b[i];
+  }
+  return a.length - b.length;
+};
+const inflate = async (data: Uint8Array): Promise<Uint8Array> => {
+  const ds = new DecompressionStream("deflate");
+  const writer = ds.writable.getWriter();
+  writer.write(data);
+  writer.close();
+  const reader = ds.readable.getReader();
+  const chunks: Uint8Array[] = [];
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    if (value) chunks.push(value);
+  }
+  const total = chunks.reduce((a, c) => a + c.length, 0);
+  const result = new Uint8Array(total);
+  let offset = 0;
+  for (const chunk of chunks) {
+    result.set(chunk, offset);
+    offset += chunk.length;
+  }
+  return result;
+};
+const readText = async (bucket: R2Bucket, key: string): Promise<string | null> => {
+  const obj = await bucket.get(key);
+  if (obj === null) return null;
+  return await obj.text();
+};
+const readBytes = async (bucket: R2Bucket, key: string): Promise<Uint8Array | null> => {
+  const obj = await bucket.get(key);
+  if (obj === null) return null;
+  return await obj.bytes();
+};
+const readRange = async (
+  bucket: R2Bucket,
+  key: string,
+  offset: number,
+  length: number,
+): Promise<Uint8Array | null> => {
+  const obj = await bucket.get(key, { range: { offset, length } });
+  if (obj === null) return null;
+  return await obj.bytes();
+};
+const resolvePackedRef = async (
+  bucket: R2Bucket,
+  repoId: string,
+  refPath: string,
+): Promise<string | undefined> => {
+  const packed = await readText(bucket, `${repoId}/.git/packed-refs`);
+  if (packed === null) return undefined;
+  for (const line of packed.split("\n")) {
+    if (line.startsWith("#") || line.startsWith("^")) continue;
+    const space = line.indexOf(" ");
+    if (space === -1) continue;
+    if (line.slice(space + 1).trim() === refPath) {
+      return line.slice(0, space).trim() || undefined;
+    }
+  }
+  return undefined;
+};
+const resolveRef = async (bucket: R2Bucket, repoId: string): Promise<string | undefined> => {
+  const head = await readText(bucket, `${repoId}/.git/HEAD`);
+  if (head === null) return undefined;
+  const trimmed = head.trim();
+  if (trimmed.startsWith("ref: ")) {
+    const refPath = trimmed.slice(5);
+    const oid = await readText(bucket, `${repoId}/.git/${refPath}`);
+    if (oid) return oid.trim() || undefined;
+    return await resolvePackedRef(bucket, repoId, refPath);
+  }
+  return trimmed || undefined;
+};
+const parseIdx = (data: Uint8Array, packKey: string): ParsedIdx => {
+  const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+  const fanout = new Uint32Array(256);
+  for (let i = 0; i < 256; i++) {
+    fanout[i] = view.getUint32(8 + i * 4);
+  }
+  const count = fanout[255];
+  const namesOffset = 8 + 256 * 4;
+  const names = data.slice(namesOffset, namesOffset + count * 20);
+  const crcOffset = namesOffset + count * 20;
+  const offsetOffset = crcOffset + count * 4;
+  const offsets = new Uint32Array(count);
+  const resolvedOffsets = new Float64Array(count);
+  let needsLarge = false;
+  for (let i = 0; i < count; i++) {
+    offsets[i] = view.getUint32(offsetOffset + i * 4);
+    if (offsets[i] & 0x80000000) needsLarge = true;
+  }
+  if (needsLarge) {
+    const largeOffsetOffset = offsetOffset + count * 4;
+    let largeIdx = 0;
+    for (let i = 0; i < count; i++) {
+      if (offsets[i] & 0x80000000) {
+        const v = view.getBigUint64(largeOffsetOffset + largeIdx * 8);
+        resolvedOffsets[i] = Number(v);
+        largeIdx++;
+      } else {
+        resolvedOffsets[i] = offsets[i];
+      }
+    }
+  } else {
+    for (let i = 0; i < count; i++) {
+      resolvedOffsets[i] = offsets[i];
+    }
+  }
+  const sortedIndices = new Uint32Array(count);
+  for (let i = 0; i < count; i++) sortedIndices[i] = i;
+  sortedIndices.sort((a, b) => resolvedOffsets[a] - resolvedOffsets[b]);
+  const nextOffsetByIndex = new Float64Array(count);
+  const offsetToNextOffset = new Map<number, number>();
+  for (let si = 0; si < count; si++) {
+    const idx = sortedIndices[si];
+    const offset = resolvedOffsets[idx];
+    const nextSi = si + 1;
+    if (nextSi < count) {
+      const nextOffset = resolvedOffsets[sortedIndices[nextSi]];
+      nextOffsetByIndex[idx] = nextOffset;
+      offsetToNextOffset.set(offset, nextOffset);
+    } else {
+      nextOffsetByIndex[idx] = Infinity;
+      offsetToNextOffset.set(offset, Infinity);
+    }
+  }
+  return {
+    fanout,
+    names,
+    offsets,
+    resolvedOffsets,
+    packKey,
+    nextOffsetByIndex,
+    offsetToNextOffset,
+  };
+};
+const findOidInIdx = (idx: ParsedIdx, oidHex: string): number | undefined => {
+  const oidBytes = hexToBytes(oidHex);
+  const firstByte = oidBytes[0];
+  const lo = firstByte > 0 ? idx.fanout[firstByte - 1] : 0;
+  const hi = idx.fanout[firstByte];
+  let left = lo;
+  let right = hi;
+  while (left < right) {
+    const mid = Math.floor((left + right) / 2);
+    const midOid = idx.names.slice(mid * 20, mid * 20 + 20);
+    const cmp = compareBytes(midOid, oidBytes);
+    if (cmp < 0) left = mid + 1;
+    else if (cmp > 0) right = mid;
+    else return mid;
+  }
+  return undefined;
+};
+const getOffsetInIdx = (idx: ParsedIdx, index: number): number => {
+  return idx.resolvedOffsets[index];
+};
+const parseVarint = (data: Uint8Array, offset: number): { value: number; size: number } => {
+  let value = 0;
+  let shift = 0;
+  let i = offset;
+  while (i < data.length) {
+    const byte = data[i];
+    value |= (byte & 0x7f) << shift;
+    shift += 7;
+    i++;
+    if (!(byte & 0x80)) break;
+  }
+  return { value, size: i - offset };
+};
+const GIT_OBJECT_TYPES = ["", "commit", "tree", "blob", "tag"];
+let idxCache: Map<string, ParsedIdx> | undefined;
+let packIdxKeysCache: Map<string, string[]> | undefined;
+const getPackIdxKeys = async (bucket: R2Bucket, repoId: string): Promise<string[]> => {
+  if (!packIdxKeysCache) packIdxKeysCache = new Map();
+  let keys = packIdxKeysCache.get(repoId);
+  if (keys) return keys;
+  const packPrefix = `${repoId}/.git/objects/pack/`;
+  const idxResult = await bucket.list({ prefix: packPrefix, delimiter: "/" });
+  keys = idxResult.objects.map((o) => o.key).filter((k) => k.endsWith(".idx"));
+  packIdxKeysCache.set(repoId, keys);
+  return keys;
+};
+const getParsedIdx = async (bucket: R2Bucket, idxKey: string): Promise<ParsedIdx | undefined> => {
+  if (!idxCache) idxCache = new Map();
+  let idx = idxCache.get(idxKey);
+  if (idx) return idx;
+  const data = await readBytes(bucket, idxKey);
+  if (data === null) return undefined;
+  const packKey = idxKey.replace(/\.idx$/, ".pack");
+  idx = parseIdx(data, packKey);
+  idxCache.set(idxKey, idx);
+  return idx;
+};
+const readRawObject = async (
+  bucket: R2Bucket,
+  repoId: string,
+  oid: string,
+): Promise<{ type: string; payload: Uint8Array } | undefined> => {
+  const idxKeys = await getPackIdxKeys(bucket, repoId);
+  for (const idxKey of idxKeys) {
+    const idx = await getParsedIdx(bucket, idxKey);
+    if (!idx) continue;
+    const objectIndex = findOidInIdx(idx, oid);
+    if (objectIndex === undefined) continue;
+    const offset = getOffsetInIdx(idx, objectIndex);
+    return await readPackedObject(
+      bucket,
+      repoId,
+      idx.packKey,
+      offset,
+      new Set(),
+      idx.nextOffsetByIndex[objectIndex],
+      idx.offsetToNextOffset,
+    );
+  }
+  return undefined;
+};
+const readPackedObject = async (
+  bucket: R2Bucket,
+  repoId: string,
+  packKey: string,
+  offset: number,
+  visited: Set<string>,
+  nextOffset?: number,
+  offsetToNextOffset?: Map<number, number>,
+): Promise<{ type: string; payload: Uint8Array } | undefined> => {
+  const maxRead =
+    nextOffset && nextOffset !== Infinity
+      ? Math.min(nextOffset - offset, 5 * 1024 * 1024)
+      : 5 * 1024 * 1024;
+  const headerBuf = await readRange(bucket, packKey, offset, Math.min(128, maxRead));
+  if (headerBuf === null) return undefined;
+  const { value: typeSize, size: hdrSize } = parseVarint(headerBuf, 0);
+  const type = (typeSize >> 4) & 0x07;
+  if (type === 6) {
+    let i = hdrSize;
+    let byte = headerBuf[i++];
+    let negOffset = byte & 0x7f;
+    while (byte & 0x80) {
+      negOffset += 1;
+      byte = headerBuf[i++];
+      negOffset = (negOffset << 7) + (byte & 0x7f);
+    }
+    const ofsSize = i - hdrSize;
+    const baseOffset = offset - negOffset;
+    const objStart = offset + hdrSize + ofsSize;
+    const dataLen = nextOffset
+      ? Math.min(nextOffset - objStart, maxRead - hdrSize - ofsSize)
+      : maxRead;
+    const compressed = await readRange(bucket, packKey, objStart, dataLen);
+    if (compressed === null) return undefined;
+    const inflated = await inflate(compressed);
+    const baseNextOffset = offsetToNextOffset?.get(baseOffset);
+    const base = await readPackedObject(
+      bucket,
+      repoId,
+      packKey,
+      baseOffset,
+      visited,
+      baseNextOffset,
+      offsetToNextOffset,
+    );
+    if (!base) return undefined;
+    return { type: base.type, payload: applyDelta(inflated, base.payload) };
+  }
+  if (type === 7) {
+    const baseOid = bytesToHex(headerBuf.slice(hdrSize, hdrSize + 20));
+    if (visited.has(baseOid)) return undefined;
+    visited.add(baseOid);
+    const objStart = offset + hdrSize + 20;
+    const dataLen = nextOffset ? Math.min(nextOffset - objStart, maxRead - hdrSize - 20) : maxRead;
+    const compressed = await readRange(bucket, packKey, objStart, dataLen);
+    if (compressed === null) return undefined;
+    const inflated = await inflate(compressed);
+    const base = await readRawObject(bucket, repoId, baseOid);
+    if (!base) return undefined;
+    return { type: base.type, payload: applyDelta(inflated, base.payload) };
+  }
+  const objStart = offset + hdrSize;
+  const dataLen = nextOffset ? nextOffset - objStart : maxRead;
+  const compressed = await readRange(bucket, packKey, objStart, dataLen);
+  if (compressed === null) return undefined;
+  const payload = await inflate(compressed);
+  const typeName = GIT_OBJECT_TYPES[type] || "unknown";
+  return { type: typeName, payload };
+};
+const applyDelta = (delta: Uint8Array, base: Uint8Array): Uint8Array => {
+  let i = 0;
+  const { value: baseSize, size: bs } = parseVarint(delta, i);
+  i += bs;
+  const { value: resultSize, size: rs } = parseVarint(delta, i);
+  i += rs;
+  const result = new Uint8Array(resultSize);
+  let outPos = 0;
+  while (i < delta.length) {
+    const cmd = delta[i];
+    i++;
+    if (cmd & 0x80) {
+      let copyOffset = 0;
+      let copySize = 0;
+      if (cmd & 0x01) copyOffset = delta[i++];
+      if (cmd & 0x02) copyOffset |= delta[i++] << 8;
+      if (cmd & 0x04) copyOffset |= delta[i++] << 16;
+      if (cmd & 0x08) copyOffset |= delta[i++] << 24;
+      if (cmd & 0x10) copySize = delta[i++];
+      if (cmd & 0x20) copySize |= delta[i++] << 8;
+      if (cmd & 0x40) copySize |= delta[i++] << 16;
+      if (copySize === 0) copySize = 0x10000;
+      for (let j = 0; j < copySize; j++) {
+        result[outPos + j] = base[copyOffset + j];
+      }
+      outPos += copySize;
+    } else {
+      for (let j = 0; j < cmd; j++) {
+        result[outPos + j] = delta[i + j];
+      }
+      i += cmd;
+      outPos += cmd;
+    }
+  }
+  return result;
+};
+const readGitObject = async (
+  bucket: R2Bucket,
+  repoId: string,
+  oid: string,
+): Promise<{ type: string; payload: Uint8Array } | undefined> => {
+  return await readRawObject(bucket, repoId, oid);
+};
+const parseCommit = (
+  payload: Uint8Array,
+): {
+  tree: string;
+  parents: string[];
+  message: string;
+  author?: { name: string; email: string; when: string };
+} => {
+  const text = new TextDecoder().decode(payload);
+  const lines = text.split("\n");
+  let i = 0;
+  let tree = "";
+  const parents: string[] = [];
+  let author: { name: string; email: string; when: string } | undefined;
+  while (i < lines.length && lines[i] !== "") {
+    const line = lines[i];
+    if (line.startsWith("tree ")) tree = line.slice(5);
+    else if (line.startsWith("parent ")) parents.push(line.slice(7));
+    else if (line.startsWith("author ")) {
+      const match = line.slice(7).match(/^(.*?) <(.*?)> (\d+)/);
+      if (match) author = { name: match[1], email: match[2], when: match[3] };
+    }
+    i++;
+  }
+  const message = lines
+    .slice(i + 1)
+    .join("\n")
+    .trim();
+  return { tree, parents, message, author };
+};
+const parseTree = (payload: Uint8Array): TreeEntry[] => {
+  const entries: TreeEntry[] = [];
+  let offset = 0;
+  while (offset < payload.length) {
+    const nullByte = payload.indexOf(0, offset);
+    if (nullByte === -1) break;
+    const header = new TextDecoder().decode(payload.slice(offset, nullByte));
+    const space = header.indexOf(" ");
+    if (space === -1) break;
+    const mode = header.slice(0, space);
+    const name = header.slice(space + 1);
+    offset = nullByte + 1;
+    const oidBytes = payload.slice(offset, offset + 20);
+    if (oidBytes.length < 20) break;
+    const oid = bytesToHex(oidBytes);
+    entries.push({ mode, name, oid });
+    offset += 20;
+  }
+  return entries;
+};
+const buildCommit = (oid: string, parsed: ReturnType<typeof parseCommit>): Commit => ({
+  hash: oid,
+  message: parsed.message.split("\n")[0],
+  body: parsed.message,
+  author_name: parsed.author?.name ?? "",
+  author_email: parsed.author?.email ?? "",
+  date: parsed.author?.when ? new Date(parseInt(parsed.author.when) * 1000).toISOString() : "",
+  branches: [],
+  tags: [],
+});
+export const getCommits = async (bucket: R2Bucket, repoId: string): Promise<Commit[]> => {
+  const cached = await bucket.get(`${repoId}/.git/commits.json`);
+  if (cached) {
+    return (await cached.json()) as Commit[];
+  }
+  const headOid = await resolveRef(bucket, repoId);
+  if (!headOid) return [];
+  const commits: Commit[] = [];
+  let oid: string | undefined = headOid;
+  while (oid) {
+    const obj = await readGitObject(bucket, repoId, oid);
+    if (!obj || obj.type !== "commit") break;
+    const parsed = parseCommit(obj.payload);
+    commits.push(buildCommit(oid, parsed));
+    oid = parsed.parents[0];
+  }
+  return commits;
+};
+export const getFiles = async (bucket: R2Bucket, repoId: string): Promise<FileNode[]> => {
+  const cached = await bucket.get(`${repoId}/.git/files.json`);
+  if (cached) {
+    return (await cached.json()) as FileNode[];
+  }
+  const prefix = `${repoId}/`;
+  const files: FileNode[] = [];
+  let cursor: string | undefined;
+  do {
+    const result = await bucket.list({ prefix, cursor });
+    for (const obj of result.objects) {
+      const key = obj.key;
+      if (key.startsWith(`${prefix}.git`)) continue;
+      if (key.endsWith("/")) continue;
+      const relativePath = key.slice(prefix.length);
+      if (!relativePath) continue;
+      const extIndex = relativePath.lastIndexOf(".");
+      const ext = extIndex >= 0 ? relativePath.slice(extIndex + 1) : "";
+      files.push({
+        name: relativePath,
+        path: relativePath,
+        ext,
+        size: obj.size,
+        isDirectory: false,
+        absolutePath: relativePath,
+      });
+    }
+    cursor = result.truncated ? result.cursor : undefined;
+  } while (cursor);
+  return files;
+};
+const fileOidInTree = async (
+  bucket: R2Bucket,
+  repoId: string,
+  treeOid: string,
+  filePath: string,
+): Promise<string | undefined> => {
+  const parts = filePath.split("/");
+  let currentTree = treeOid;
+  for (const part of parts) {
+    const obj = await readGitObject(bucket, repoId, currentTree);
+    if (!obj || obj.type !== "tree") return undefined;
+    const entries = parseTree(obj.payload);
+    const entry = entries.find((e) => e.name === part);
+    if (!entry) return undefined;
+    if (part === parts[parts.length - 1]) return entry.oid;
+    if (entry.mode !== "40000") return undefined;
+    currentTree = entry.oid;
+  }
+  return undefined;
+};
+export const getFileHistory = async (
+  bucket: R2Bucket,
+  repoId: string,
+  filePath: string,
+): Promise<Commit[]> => {
+  const headOid = await resolveRef(bucket, repoId);
+  if (!headOid) return [];
+  const commits: Commit[] = [];
+  let oid: string | undefined = headOid;
+  while (oid) {
+    const commitObj = await readGitObject(bucket, repoId, oid);
+    if (!commitObj || commitObj.type !== "commit") break;
+    const parsed = parseCommit(commitObj.payload);
+    const fileOid = await fileOidInTree(bucket, repoId, parsed.tree, filePath);
+    let parentFileOid: string | undefined;
+    if (parsed.parents[0]) {
+      const parentObj = await readGitObject(bucket, repoId, parsed.parents[0]);
+      if (parentObj && parentObj.type === "commit") {
+        const parentParsed = parseCommit(parentObj.payload);
+        parentFileOid = await fileOidInTree(bucket, repoId, parentParsed.tree, filePath);
+      }
+    }
+    if (fileOid !== parentFileOid) {
+      commits.push(buildCommit(oid, parsed));
+    }
+    oid = parsed.parents[0];
+  }
+  return commits;
+};
+export const getFileContentData = async (
+  bucket: R2Bucket,
+  repoId: string,
+  filePath: string,
+): Promise<Uint8Array | undefined> => {
+  const obj = await bucket.get(`${repoId}/${filePath}`);
+  if (obj === null) return undefined;
+  return await obj.bytes();
+};
+interface Change {
+  filepath: string;
+  changeType: "added" | "deleted" | "modified";
+  newOid?: string;
+  oldOid?: string;
+}
+const getTreeEntries = async (
+  bucket: R2Bucket,
+  repoId: string,
+  treeOid: string,
+): Promise<Map<string, { mode: string; oid: string }>> => {
+  const map = new Map<string, { mode: string; oid: string }>();
+  const obj = await readGitObject(bucket, repoId, treeOid);
+  if (!obj || obj.type !== "tree") return map;
+  const entries = parseTree(obj.payload);
+  for (const entry of entries) {
+    map.set(entry.name, { mode: entry.mode, oid: entry.oid });
+  }
+  return map;
+};
+const diffTrees = async (
+  bucket: R2Bucket,
+  repoId: string,
+  oldTreeOid: string | undefined,
+  newTreeOid: string,
+  prefix = "",
+): Promise<Change[]> => {
+  const changes: Change[] = [];
+  const oldEntries = oldTreeOid ? await getTreeEntries(bucket, repoId, oldTreeOid) : new Map();
+  const newEntries = await getTreeEntries(bucket, repoId, newTreeOid);
+  const allNames = new Set([...oldEntries.keys(), ...newEntries.keys()]);
+  for (const name of allNames) {
+    const path = prefix ? `${prefix}/${name}` : name;
+    const oldEntry = oldEntries.get(name);
+    const newEntry = newEntries.get(name);
+    if (!newEntry) {
+      if (oldEntry && oldEntry.mode !== "40000") {
+        changes.push({ filepath: path, changeType: "deleted", oldOid: oldEntry.oid });
+      }
+    } else if (!oldEntry) {
+      if (newEntry.mode !== "40000") {
+        changes.push({ filepath: path, changeType: "added", newOid: newEntry.oid });
+      } else {
+        changes.push(...(await diffTrees(bucket, repoId, undefined, newEntry.oid, path)));
+      }
+    } else if (oldEntry.mode === "40000" && newEntry.mode === "40000") {
+      changes.push(...(await diffTrees(bucket, repoId, oldEntry.oid, newEntry.oid, path)));
+    } else if (oldEntry.oid !== newEntry.oid) {
+      if (newEntry.mode !== "40000") {
+        changes.push({
+          filepath: path,
+          changeType: "modified",
+          newOid: newEntry.oid,
+          oldOid: oldEntry.oid,
+        });
+      }
+    }
+  }
+  return changes;
+};
+const readBlobText = async (bucket: R2Bucket, repoId: string, oid: string): Promise<string> => {
+  const obj = await readGitObject(bucket, repoId, oid);
+  if (!obj || obj.type !== "blob") return "";
+  return new TextDecoder().decode(obj.payload);
+};
+export const generateHTMLDiff = async (
+  bucket: R2Bucket,
+  repoId: string,
+  hash: string,
+): Promise<string> => {
+  const { html, parse } = await import("diff2html");
+  const { createTwoFilesPatch } = await import("diff");
+  const commitObj = await readGitObject(bucket, repoId, hash);
+  if (!commitObj || commitObj.type !== "commit") return "<p>Commit not found.</p>";
+  const parsed = parseCommit(commitObj.payload);
+  const parentOid = parsed.parents[0];
+  let parentTreeOid: string | undefined;
+  if (parentOid) {
+    const parentObj = await readGitObject(bucket, repoId, parentOid);
+    if (parentObj && parentObj.type === "commit") {
+      parentTreeOid = parseCommit(parentObj.payload).tree;
+    }
+  }
+  const changes = parentTreeOid
+    ? await diffTrees(bucket, repoId, parentTreeOid, parsed.tree)
+    : await diffTrees(bucket, repoId, undefined, parsed.tree);
+  if (changes.length === 0) {
+    return "<p>No changes in this commit.</p>";
+  }
+  const chunks: string[] = [];
+  for (const change of changes) {
+    if (change.changeType === "added" && change.newOid) {
+      const content = await readBlobText(bucket, repoId, change.newOid);
+      chunks.push(createTwoFilesPatch(`/dev/null`, `b/${change.filepath}`, "", content));
+    } else if (change.changeType === "deleted" && change.oldOid) {
+      const content = await readBlobText(bucket, repoId, change.oldOid);
+      chunks.push(createTwoFilesPatch(`a/${change.filepath}`, `/dev/null`, content, ""));
+    } else if (change.changeType === "modified" && change.newOid && change.oldOid) {
+      const [oldContent, newContent] = await Promise.all([
+        readBlobText(bucket, repoId, change.oldOid),
+        readBlobText(bucket, repoId, change.newOid),
+      ]);
+      if (oldContent.length > 1024 * 512 || newContent.length > 1024 * 512) {
+        chunks.push(`diff --git a/${change.filepath} b/${change.filepath}\n`);
+        chunks.push(`--- a/${change.filepath}\n+++ b/${change.filepath}\n`);
+        chunks.push(`@@ -1 +1 @@\n-File too large to diff\n+File too large to diff\n`);
+      } else {
+        chunks.push(
+          createTwoFilesPatch(
+            `a/${change.filepath}`,
+            `b/${change.filepath}`,
+            oldContent,
+            newContent,
+          ),
+        );
+      }
+    }
+  }
+  const diffText = chunks.join("\n");
+  if (diffText.length > 1024 * 512) {
+    return "<p>Diff too large to display.</p>";
+  }
+  const diffJson = parse(diffText);
+  const diffHtml = html(diffJson, { drawFileList: true, matching: "lines" });
+  return diffHtml;
+};

src/utils/markdown.ts ADDED Viewed

@@ -0,0 +1,17 @@
+import rehypeExpressiveCode from "rehype-expressive-code";
+import rehypeStringify from "rehype-stringify";
+import remarkParse from "remark-parse";
+import remarkRehype from "remark-rehype";
+import { unified } from "unified";
+import ecConfig from "../../ec.config.mjs";
+export const renderMarkdown = async (markdown: string) => {
+  const file = await unified()
+    .use(remarkParse)
+    .use(remarkRehype)
+    .use(rehypeExpressiveCode, ecConfig)
+    .use(rehypeStringify)
+    .process(markdown);
+  return String(file);
+};

src/utils/repoContent.ts ADDED Viewed

@@ -0,0 +1,8 @@
+export const getRepoReadme = async (
+  bucket: R2Bucket,
+  repoId: string,
+): Promise<string | undefined> => {
+  const obj = await bucket.get(`${repoId}/README.md`);
+  if (obj === null) return undefined;
+  return await obj.text();
+};

tests/repos.spec.ts ADDED Viewed

@@ -0,0 +1,59 @@
+import { expect, test } from "@playwright/test";
+const TEST_REPO = "rust-embed";
+test.describe("repo pages", () => {
+  test("repo readme page loads", async ({ page }) => {
+    const response = await page.goto(`/repos/${TEST_REPO}`);
+    expect(response?.status()).toBe(200);
+  });
+  test("repo commits page loads and shows commits", async ({ page }) => {
+    const response = await page.goto(`/repos/${TEST_REPO}/commits`);
+    expect(response?.status()).toBe(200);
+  });
+  test("repo files page loads and shows file tree", async ({ page }) => {
+    const response = await page.goto(`/repos/${TEST_REPO}/files`);
+    expect(response?.status()).toBe(200);
+  });
+  test("commit detail page loads from commits page navigation", async ({ page }) => {
+    const response = await page.goto(`/repos/${TEST_REPO}/commits`);
+    expect(response?.status()).toBe(200);
+    const firstCommit = page.locator(".commit a").first();
+    if ((await firstCommit.count()) > 0) {
+      const href = await firstCommit.getAttribute("href");
+      expect(href).toBeTruthy();
+      const commitResponse = await page.goto(href!);
+      expect(commitResponse?.status()).toBe(200);
+    }
+  });
+  test("file page loads from files page navigation", async ({ page }) => {
+    const response = await page.goto(`/repos/${TEST_REPO}/files`);
+    expect(response?.status()).toBe(200);
+    const firstFile = page.locator(".file a").first();
+    if ((await firstFile.count()) > 0) {
+      const href = await firstFile.getAttribute("href");
+      expect(href).toBeTruthy();
+      const fileResponse = await page.goto(href!);
+      expect(fileResponse?.status()).toBe(200);
+    }
+  });
+  test("file history page loads", async ({ page }) => {
+    const response = await page.goto(`/repos/${TEST_REPO}/files`);
+    expect(response?.status()).toBe(200);
+    const firstFile = page.locator(".file a").first();
+    if ((await firstFile.count()) > 0) {
+      const href = await firstFile.getAttribute("href");
+      expect(href).toBeTruthy();
+      const historyResponse = await page.goto(`${href}/history`);
+      expect(historyResponse?.status()).toBe(200);
+    }
+  });
+});

worker-configuration.d.ts CHANGED Viewed

@@ -2,7 +2,7 @@
 // Generated by Wrangler by running `wrangler types` (hash: 097be681a01785b514391866da6b5f7e)
 // Runtime types generated with [email protected] 2026-06-25 nodejs_compat
 interface __BaseEnv_Env {
-  REPOS_BUCKET: R2Bucket;
+  REPOS: R2Bucket;
   ASSETS: Fetcher;
   DATABASE_URL: string;
   DATABASE_PASSWORD: string;

wrangler.toml CHANGED Viewed

@@ -1,5 +1,6 @@
 name = "pyrossh-website"
-main = "dist/server/entry.mjs"
+main = "@astrojs/cloudflare/entrypoints/server"
+account_id = "dfdb8ca4e419990852eb214c5b50bd5e"
 compatibility_date = "2026-05-15"
 compatibility_flags = ["nodejs_compat"]
 workers_dev = false
@@ -31,7 +32,8 @@ REPOS_R2_BUCKET = "pyrossh-repos-prd"
 [[r2_buckets]]
 binding = "REPOS"
 bucket_name = "pyrossh-repos-prd"
-preview_bucket_name = "pyrossh-repos-dev"
+preview_bucket_name = "pyrossh-repos-prd"
+remote = true
 [env.dev]
 name = "pyrossh-website-dev"
@@ -42,5 +44,5 @@ REPOS_R2_BUCKET = "pyrossh-repos-dev"
 [[env.dev.r2_buckets]]
 binding = "REPOS"
-bucket_name = "pyrossh-repos-dev"
+bucket_name = "pyrossh-repos-prd"
-preview_bucket_name = "pyrossh-repos-dev"
+preview_bucket_name = "pyrossh-repos-prd"