f1ed0fe | website

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

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

f1ed0fe — pyrossh 2026-07-08T19:48:31+05:30

feat: port core libraries to S3mini

Generated files not shown: package-lock.json

Files changed (8) hide show

package.json +10 -1
src/lib/content.ts +48 -0
src/lib/files.ts +113 -0
src/lib/gitBug.ts +187 -0
src/lib/gitReader.ts +733 -0
src/lib/markdown.ts +30 -0
src/lib/repoContent.ts +8 -0
tsconfig.json +1 -0

package.json CHANGED Viewed

@@ -8,7 +8,16 @@
   },
   "dependencies": {
     "hono": "^4.7.5",
-    "s3mini": "^0.9.5"
+    "s3mini": "^0.9.5",
+    "gray-matter": "^4.0.3",
+    "unified": "^11.0.0",
+    "remark-parse": "^11.0.0",
+    "remark-rehype": "^11.1.2",
+    "rehype-stringify": "^10.0.1",
+    "rehype-expressive-code": "^0.44.0",
+    "diff": "^9.0.0",
+    "pretty-bytes": "^7.1.0",
+    "diff2html": "^3.4.52"
   },
   "devDependencies": {
     "@cloudflare/workers-types": "^4.20250214.0",

src/lib/content.ts ADDED Viewed

@@ -0,0 +1,48 @@
+import matter from 'gray-matter'
+import { S3mini } from 's3mini'
+import { REPOS } from '../config'
+import type { RuntimePost, RuntimeRepo } from '../types'
+import { renderMarkdown } from './markdown'
+const toDate = (value: unknown) => (value instanceof Date ? value : new Date(String(value)))
+const CONTENT_PREFIX = 'content/'
+export const getRepos = (): RuntimeRepo[] =>
+  REPOS.map((repo) => ({ id: repo.title, data: { ...repo } }))
+export const getRepo = (repoId?: string): RuntimeRepo | undefined =>
+  getRepos().find((repo) => repo.id === repoId)
+export const getPosts = async (s3: S3mini): Promise<RuntimePost[]> => {
+  const objects = await s3.listObjects('/', CONTENT_PREFIX)
+  if (!objects) return []
+  const posts: RuntimePost[] = []
+  for (const obj of objects) {
+    if (!obj.Key.endsWith('.md') && !obj.Key.endsWith('.mdx')) continue
+    const source = await s3.getObject(obj.Key)
+    if (!source) continue
+    const parsed = matter(source)
+    const id = obj.Key.replace(CONTENT_PREFIX, '').replace(/\.(md|mdx)$/, '')
+    posts.push({
+      id,
+      data: {
+        title: String(parsed.data.title ?? ''),
+        description: String(parsed.data.description ?? ''),
+        pubDate: toDate(parsed.data.pubDate),
+        updatedDate: parsed.data.updatedDate ? toDate(parsed.data.updatedDate) : undefined,
+        heroImage: parsed.data.heroImage ? String(parsed.data.heroImage) : undefined,
+      },
+      body: parsed.content,
+      html: await renderMarkdown(parsed.content),
+    })
+  }
+  return posts.sort((a, b) => b.data.pubDate.valueOf() - a.data.pubDate.valueOf())
+}
+export const getPost = async (s3: S3mini, postId?: string) => {
+  const posts = await getPosts(s3)
+  return posts.find((post) => post.id === postId)
+}

src/lib/files.ts ADDED Viewed

@@ -0,0 +1,113 @@
+import { extensions as folderExtensions } from "vscode-icons/src/iconsManifest/supportedFolders.ts";
+import { extensions as fileExtensions } from "vscode-icons/src/iconsManifest/supportedExtensions.ts";
+export interface FileNode {
+  name: string;
+  path: string;
+  size: number;
+  ext: string;
+  absolutePath: string;
+  isDirectory: boolean;
+  children?: FileNode[];
+}
+export const sortAll = (a: FileNode, b: FileNode): number => {
+  if (a.isDirectory && !b.isDirectory) return -1;
+  if (!a.isDirectory && b.isDirectory) return 1;
+  return a.name.localeCompare(b.name);
+};
+export const sortChildren = (nodes: FileNode[]) => {
+  for (const node of nodes) {
+    if (node.isDirectory && node.children) {
+      node.children.sort(sortAll);
+      sortChildren(node.children);
+    }
+  }
+  return nodes.sort(sortAll);
+};
+export const buildFileTree = (files: any[]): FileNode[] => {
+  const root: FileNode[] = [];
+  for (const file of files) {
+    const parts = file.name.split("/");
+    let currentLevel = root;
+    for (let i = 0; i < parts.length; i++) {
+      const part = parts[i];
+      const isLastPart = i === parts.length - 1;
+      const currentPath = parts.slice(0, i + 1).join("/");
+      let existingNode = currentLevel.find((node) => node.name === part);
+      if (!existingNode) {
+        const newNode: FileNode = {
+          name: part,
+          path: currentPath,
+          isDirectory: !isLastPart,
+          size: file.size,
+          ext: file.ext,
+          absolutePath: file.absolutePath,
+        };
+        if (!isLastPart) {
+          newNode.children = [];
+        }
+        currentLevel.push(newNode);
+        existingNode = newNode;
+      }
+      if (!isLastPart) {
+        currentLevel = existingNode.children!;
+      }
+    }
+  }
+  return root;
+};
+export const resolveFolderIcon = (foldername: string) => {
+  for (const item of folderExtensions.supported) {
+    if (item.extensions?.includes(foldername)) {
+      return item.icon;
+    }
+  }
+  return folderExtensions.default.folder?.icon;
+};
+export const resolveFileIcon = (filename: string, fileExt: string) => {
+  const baseName = filename.split("/").pop() || filename;
+  for (const item of fileExtensions.supported) {
+    if (item.filename && item.extensions?.includes(baseName)) {
+      return item.icon;
+    }
+  }
+  for (const item of fileExtensions.supported) {
+    if (item.extensions?.includes(fileExt)) {
+      return item.icon;
+    }
+  }
+  for (const item of fileExtensions.supported) {
+    for (const lang of item.languages ?? []) {
+      if (lang?.knownExtensions?.includes(fileExt)) {
+        const langIds = Array.isArray(lang.ids) ? lang.ids : [lang.ids];
+        if (langIds.includes(fileExt)) {
+          return item.icon;
+        }
+      }
+    }
+  }
+  for (const item of fileExtensions.supported) {
+    for (const lang of item.languages ?? []) {
+      if (lang?.knownExtensions?.includes(fileExt)) {
+        return item.icon;
+      }
+    }
+  }
+  return fileExtensions.default.file?.icon;
+};

src/lib/gitBug.ts ADDED Viewed

@@ -0,0 +1,187 @@
+import { S3mini } from 's3mini'
+export type GitBugIssueState = "open" | "closed";
+export interface GitBugIssue {
+  id: string;
+  title: string;
+  state: GitBugIssueState;
+  author?: string;
+  createdAt: string;
+  updatedAt: string;
+  labels: string[];
+  body?: string;
+  comments: GitBugComment[];
+}
+export interface GitBugComment {
+  id: string;
+  author?: string;
+  createdAt: string;
+  body: string;
+}
+export interface GitBugIssuesResult {
+  issues: GitBugIssue[];
+  isAvailable: boolean;
+}
+const safeRepoId = (repoId: string) => {
+  if (!/^[a-zA-Z0-9._-]+$/.test(repoId)) {
+    throw new Error("Invalid repository id.");
+  }
+  return repoId;
+};
+const safeIssueId = (issueId: string) => {
+  if (!/^[a-f0-9]{16}$/.test(issueId)) {
+    throw new Error("Invalid issue id.");
+  }
+  return issueId;
+};
+const makeIssueId = () => crypto.randomUUID().replaceAll("-", "").slice(0, 16);
+const issuesPrefix = (repoId: string) => `${safeRepoId(repoId)}/issues/`;
+const issueKey = (repoId: string, issueId: string) =>
+  `${issuesPrefix(repoId)}${safeIssueId(issueId)}.json`;
+const normalizeLabels = (labels?: string[]) =>
+  labels?.map((label) => label.trim()).filter(Boolean) ?? [];
+const assertNotSpam = async () => {};
+const getObjectJson = async <T>(s3: S3mini, key: string) => {
+  try {
+    const body = await s3.getObject(key);
+    return body ? (JSON.parse(body) as T) : undefined;
+  } catch (error) {
+    if (error && typeof error === "object" && "name" in error && error.name === "NoSuchKey") {
+      return undefined;
+    }
+    throw error;
+  }
+};
+const putIssue = async (s3: S3mini, repoId: string, issue: GitBugIssue) => {
+  await s3.putObject(issueKey(repoId, issue.id), JSON.stringify(issue, null, 2), "application/json; charset=utf-8");
+  return issue;
+};
+export const getGitBugIssues = async (
+  s3: S3mini,
+  repoId: string,
+): Promise<GitBugIssuesResult> => {
+  try {
+    const objects = await s3.listObjects('/', issuesPrefix(repoId));
+    if (!objects) return { issues: [], isAvailable: true };
+    const issues = (
+      await Promise.all(
+        objects
+          .filter((object) => object.Key.endsWith(".json"))
+          .map(async (object) => {
+            return await getObjectJson<GitBugIssue>(s3, object.Key);
+          }),
+      )
+    ).filter((issue): issue is GitBugIssue => Boolean(issue));
+    return {
+      issues: issues.sort((a, b) => b.updatedAt.localeCompare(a.updatedAt)),
+      isAvailable: true,
+    };
+  } catch {
+    return {
+      issues: [],
+      isAvailable: false,
+    };
+  }
+};
+export const getGitBugIssue = async (
+  s3: S3mini,
+  repoId: string,
+  issueId: string,
+): Promise<GitBugIssue | undefined> => {
+  return await getObjectJson<GitBugIssue>(s3, issueKey(repoId, issueId));
+};
+export const createGitBugIssue = async (
+  s3: S3mini,
+  repoId: string,
+  input: {
+    title: string;
+    body?: string;
+    author?: string;
+    labels?: string[];
+  },
+) => {
+  const labels = normalizeLabels(input.labels);
+  await assertNotSpam();
+  const now = new Date().toISOString();
+  const issue: GitBugIssue = {
+    id: makeIssueId(),
+    title: input.title.trim(),
+    state: "open",
+    author: input.author?.trim() || "anonymous",
+    createdAt: now,
+    updatedAt: now,
+    labels,
+    body: input.body?.trim(),
+    comments: [],
+  };
+  return await putIssue(s3, repoId, issue);
+};
+export const addGitBugIssueComment = async (
+  s3: S3mini,
+  repoId: string,
+  issueId: string,
+  input: {
+    body: string;
+    author?: string;
+  },
+) => {
+  const issue = await getGitBugIssue(s3, repoId, issueId);
+  if (!issue) {
+    throw new Error("Issue not found.");
+  }
+  await assertNotSpam();
+  const now = new Date().toISOString();
+  return await putIssue(s3, repoId, {
+    ...issue,
+    updatedAt: now,
+    comments: [
+      ...issue.comments,
+      {
+        id: makeIssueId(),
+        author: input.author?.trim() || "anonymous",
+        createdAt: now,
+        body: input.body.trim(),
+      },
+    ],
+  });
+};
+export const setGitBugIssueState = async (
+  s3: S3mini,
+  repoId: string,
+  issueId: string,
+  state: GitBugIssueState,
+  author?: string,
+) => {
+  const issue = await getGitBugIssue(s3, repoId, issueId);
+  if (!issue) {
+    throw new Error("Issue not found.");
+  }
+  return await putIssue(s3, repoId, {
+    ...issue,
+    author: author?.trim() || issue.author,
+    state,
+    updatedAt: new Date().toISOString(),
+  });
+};

src/lib/gitReader.ts ADDED Viewed

@@ -0,0 +1,733 @@
+import { S3mini } from 's3mini'
+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 (s3: S3mini, key: string): Promise<string | null> => {
+  return await s3.getObject(key)
+}
+const readBytes = async (s3: S3mini, key: string): Promise<Uint8Array | null> => {
+  const buf = await s3.getObjectArrayBuffer(key)
+  return buf ? new Uint8Array(buf) : null
+}
+const readRange = async (s3: S3mini, key: string, offset: number, length: number): Promise<Uint8Array | null> => {
+  const end = offset + length - 1
+  const response = await s3.getObjectRaw(key, false, offset, end)
+  if (!response.ok) return null
+  const buf = await response.arrayBuffer()
+  return new Uint8Array(buf)
+}
+const resolvePackedRef = async (
+  s3: S3mini,
+  repoId: string,
+  refPath: string,
+): Promise<string | undefined> => {
+  const packed = await readText(s3, `${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 (s3: S3mini, repoId: string): Promise<string | undefined> => {
+  const head = await readText(s3, `${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(s3, `${repoId}/.git/${refPath}`);
+    if (oid) return oid.trim() || undefined;
+    return await resolvePackedRef(s3, 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 (s3: S3mini, 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 objects = await s3.listObjects('/', packPrefix);
+  keys = objects ? objects.map((o) => o.Key).filter((k) => k.endsWith(".idx")) : [];
+  packIdxKeysCache.set(repoId, keys);
+  return keys;
+};
+const getParsedIdx = async (s3: S3mini, idxKey: string): Promise<ParsedIdx | undefined> => {
+  if (!idxCache) idxCache = new Map();
+  let idx = idxCache.get(idxKey);
+  if (idx) return idx;
+  const data = await readBytes(s3, 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 (
+  s3: S3mini,
+  repoId: string,
+  oid: string,
+): Promise<{ type: string; payload: Uint8Array } | undefined> => {
+  const idxKeys = await getPackIdxKeys(s3, repoId);
+  for (const idxKey of idxKeys) {
+    const idx = await getParsedIdx(s3, idxKey);
+    if (!idx) continue;
+    const objectIndex = findOidInIdx(idx, oid);
+    if (objectIndex === undefined) continue;
+    const offset = getOffsetInIdx(idx, objectIndex);
+    return await readPackedObject(
+      s3,
+      repoId,
+      idx.packKey,
+      offset,
+      new Set(),
+      idx.nextOffsetByIndex[objectIndex],
+      idx.offsetToNextOffset,
+    );
+  }
+  return undefined;
+};
+const readPackedObject = async (
+  s3: S3mini,
+  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(s3, 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(s3, packKey, objStart, dataLen);
+    if (compressed === null) return undefined;
+    const inflated = await inflate(compressed);
+    const baseNextOffset = offsetToNextOffset?.get(baseOffset);
+    const base = await readPackedObject(
+      s3,
+      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(s3, packKey, objStart, dataLen);
+    if (compressed === null) return undefined;
+    const inflated = await inflate(compressed);
+    const base = await readRawObject(s3, 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(s3, 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 (
+  s3: S3mini,
+  repoId: string,
+  oid: string,
+): Promise<{ type: string; payload: Uint8Array } | undefined> => {
+  return await readRawObject(s3, 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 (s3: S3mini, repoId: string): Promise<Commit[]> => {
+  const cached = await s3.getObject(`${repoId}/.git/commits.json`);
+  if (cached) {
+    return JSON.parse(cached) as Commit[];
+  }
+  const headOid = await resolveRef(s3, repoId);
+  if (!headOid) return [];
+  const commits: Commit[] = [];
+  let oid: string | undefined = headOid;
+  while (oid) {
+    const obj = await readGitObject(s3, 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 (s3: S3mini, repoId: string): Promise<FileNode[]> => {
+  const cached = await s3.getObject(`${repoId}/.git/files.json`);
+  if (cached) {
+    return JSON.parse(cached) as FileNode[];
+  }
+  const prefix = `${repoId}/`;
+  const files: FileNode[] = [];
+  const objects = await s3.listObjects('/', prefix);
+  if (!objects) return [];
+  for (const obj of 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,
+    });
+  }
+  return files;
+};
+const fileOidInTree = async (
+  s3: S3mini,
+  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(s3, 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 (
+  s3: S3mini,
+  repoId: string,
+  filePath: string,
+): Promise<Commit[]> => {
+  const headOid = await resolveRef(s3, repoId);
+  if (!headOid) return [];
+  const commits: Commit[] = [];
+  let oid: string | undefined = headOid;
+  while (oid) {
+    const commitObj = await readGitObject(s3, repoId, oid);
+    if (!commitObj || commitObj.type !== "commit") break;
+    const parsed = parseCommit(commitObj.payload);
+    const fileOid = await fileOidInTree(s3, repoId, parsed.tree, filePath);
+    let parentFileOid: string | undefined;
+    if (parsed.parents[0]) {
+      const parentObj = await readGitObject(s3, repoId, parsed.parents[0]);
+      if (parentObj && parentObj.type === "commit") {
+        const parentParsed = parseCommit(parentObj.payload);
+        parentFileOid = await fileOidInTree(s3, repoId, parentParsed.tree, filePath);
+      }
+    }
+    if (fileOid !== parentFileOid) {
+      commits.push(buildCommit(oid, parsed));
+    }
+    oid = parsed.parents[0];
+  }
+  return commits;
+};
+export const getFileContentData = async (
+  s3: S3mini,
+  repoId: string,
+  filePath: string,
+): Promise<Uint8Array | undefined> => {
+  const buf = await s3.getObjectArrayBuffer(`${repoId}/${filePath}`);
+  return buf ? new Uint8Array(buf) : undefined;
+};
+interface Change {
+  filepath: string;
+  changeType: "added" | "deleted" | "modified";
+  newOid?: string;
+  oldOid?: string;
+}
+const getTreeEntries = async (
+  s3: S3mini,
+  repoId: string,
+  treeOid: string,
+): Promise<Map<string, { mode: string; oid: string }>> => {
+  const map = new Map<string, { mode: string; oid: string }>();
+  const obj = await readGitObject(s3, 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 (
+  s3: S3mini,
+  repoId: string,
+  oldTreeOid: string | undefined,
+  newTreeOid: string,
+  prefix = "",
+): Promise<Change[]> => {
+  const changes: Change[] = [];
+  const oldEntries = oldTreeOid ? await getTreeEntries(s3, repoId, oldTreeOid) : new Map();
+  const newEntries = await getTreeEntries(s3, 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(s3, repoId, undefined, newEntry.oid, path)));
+      }
+    } else if (oldEntry.mode === "40000" && newEntry.mode === "40000") {
+      changes.push(...(await diffTrees(s3, 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 (s3: S3mini, repoId: string, oid: string): Promise<string> => {
+  const obj = await readGitObject(s3, repoId, oid);
+  if (!obj || obj.type !== "blob") return "";
+  return new TextDecoder().decode(obj.payload);
+};
+export const generateHTMLDiff = async (
+  s3: S3mini,
+  repoId: string,
+  hash: string,
+): Promise<string> => {
+  const { html, parse } = await import("diff2html");
+  const { createTwoFilesPatch } = await import("diff");
+  const commitObj = await readGitObject(s3, 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(s3, repoId, parentOid);
+    if (parentObj && parentObj.type === "commit") {
+      parentTreeOid = parseCommit(parentObj.payload).tree;
+    }
+  }
+  const changes = parentTreeOid
+    ? await diffTrees(s3, repoId, parentTreeOid, parsed.tree)
+    : await diffTrees(s3, 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(s3, repoId, change.newOid);
+      chunks.push(createTwoFilesPatch(`/dev/null`, `b/${change.filepath}`, "", content));
+    } else if (change.changeType === "deleted" && change.oldOid) {
+      const content = await readBlobText(s3, 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(s3, repoId, change.oldOid),
+        readBlobText(s3, 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/lib/markdown.ts ADDED Viewed

@@ -0,0 +1,30 @@
+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";
+const ecConfig = {
+  shiki: {
+    engine: "javascript" as const,
+    langAlias: {
+      h: "c", ino: "c", mm: "c", plum: "txt", mi: "txt",
+      scm: "txt", podspec: "txt", lock: "txt", xcconfig: "txt",
+      plist: "xml", xcworkspacedata: "xml", xcsettings: "xml",
+      storyboard: "txt", pbxproj: "txt", mjs: "javascript",
+      snap: "javascript", gradle: "groovy", class: "java",
+      mod: "go", sum: "go",
+    },
+  },
+  styleOverrides: { codeFontSize: "0.8rem", uiFontSize: "0.8rem" },
+};
+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/lib/repoContent.ts ADDED Viewed

@@ -0,0 +1,8 @@
+import { S3mini } from 's3mini'
+export const getRepoReadme = async (
+  s3: S3mini,
+  repoId: string,
+): Promise<string | undefined> => {
+  return (await s3.getObject(`${repoId}/README.md`)) ?? undefined
+}

tsconfig.json CHANGED Viewed

@@ -7,6 +7,7 @@
     "skipLibCheck": true,
     "noEmit": true,
     "isolatedModules": true,
+    "allowImportingTsExtensions": true,
     "types": ["@cloudflare/workers-types"]
   },
   "include": ["src"]