778948f | website

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

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

778948f — pyrossh 2026-07-07T11:31:05+05:30

feat: port business logic to @pyrossh/core package

Files changed (10) hide show

packages/shared/core/package.json +25 -0
packages/shared/core/src/content.ts +47 -0
packages/shared/core/src/files.ts +113 -0
packages/shared/core/src/gitBug.ts +268 -0
packages/shared/core/src/gitReader.ts +741 -0
packages/shared/core/src/index.ts +21 -0
packages/shared/core/src/markdown.ts +20 -0
packages/shared/core/src/repoContent.ts +8 -0
packages/shared/core/tsconfig.json +4 -0
pnpm-lock.yaml +58 -0

packages/shared/core/package.json ADDED Viewed

@@ -0,0 +1,25 @@
+{
+  "name": "@pyrossh/core",
+  "version": "0.0.0",
+  "private": true,
+  "type": "module",
+  "main": "src/index.ts",
+  "types": "src/index.ts",
+  "dependencies": {
+    "@pyrossh/config": "workspace:*",
+    "@pyrossh/types": "workspace:*",
+    "diff": "^9.0.0",
+    "diff2html": "^3.4.52",
+    "gray-matter": "^4.0.3",
+    "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",
+    "unified": "^11.0.5"
+  },
+  "devDependencies": {
+    "vscode-icons": "https://github.com/vscode-icons/vscode-icons.git"
+  }
+}

packages/shared/core/src/content.ts ADDED Viewed

@@ -0,0 +1,47 @@
+import matter from "gray-matter";
+import { REPOS } from "@pyrossh/config";
+import type { RuntimeRepo, RuntimePost } from "@pyrossh/types";
+import { renderMarkdown } from "./markdown";
+const toDate = (value: unknown) => (value instanceof Date ? value : new Date(String(value)));
+export const getRepos = (): RuntimeRepo[] =>
+  REPOS.map((repo) => ({ id: repo.title, data: { ...repo } }));
+export const getRepo = (repoId?: string) => getRepos().find((repo) => repo.id === repoId);
+const CONTENT_PREFIX = "content/";
+export const getPosts = async (bucket: R2Bucket): Promise<RuntimePost[]> => {
+  const objects = await bucket.list({ prefix: CONTENT_PREFIX });
+  const posts: RuntimePost[] = [];
+  for (const obj of objects.objects) {
+    if (!obj.key.endsWith(".md") && !obj.key.endsWith(".mdx")) continue;
+    const file = await bucket.get(obj.key);
+    if (!file) continue;
+    const source = await file.text();
+    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 (bucket: R2Bucket, postId?: string) => {
+  const posts = await getPosts(bucket);
+  return posts.find((post) => post.id === postId);
+};

packages/shared/core/src/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;
+};

packages/shared/core/src/gitBug.ts ADDED Viewed

@@ -0,0 +1,268 @@
+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;
+}
+type SpamScanner = typeof import("spamscanner").default.prototype;
+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`;
+let spamScanner: SpamScanner | undefined;
+const normalizeLabels = (labels?: string[]) =>
+  labels?.map((label) => label.trim()).filter(Boolean) ?? [];
+const safeHeaderValue = (value: string) => value.replaceAll(/[\r\n]+/g, " ").trim();
+const getSpamScanner = async () => {
+  if (!spamScanner) {
+    try {
+      const { default: SpamScanner } = await import("spamscanner");
+      spamScanner = new SpamScanner({
+        enableAuthentication: false,
+        enableNsfwDetection: true,
+        enableReputation: true,
+        enableToxicityDetection: true,
+        timeout: 10_000,
+      });
+    } catch {
+      console.warn("Spam scanner not available (unsupported in Workers environment)");
+      return undefined;
+    }
+  }
+  return spamScanner;
+};
+const makeSpamScanEmail = (input: {
+  subject: string;
+  body?: string;
+  author?: string;
+  labels?: string[];
+}) => {
+  const author = input.author?.trim() || "anonymous";
+  return [
+    "From: git-bug <[email protected]>",
+    "To: [email protected]",
+    `Subject: ${safeHeaderValue(input.subject)}`,
+    `X-GitBug-Author: ${safeHeaderValue(author)}`,
+    input.labels?.length
+      ? `X-GitBug-Labels: ${safeHeaderValue(input.labels.join(", "))}`
+      : undefined,
+    "",
+    input.body?.trim() ?? "",
+  ]
+    .filter((line) => line !== undefined)
+    .join("\n");
+};
+const assertNotSpam = async (input: {
+  subject: string;
+  body?: string;
+  author?: string;
+  labels?: string[];
+}) => {
+  const scanner = await getSpamScanner();
+  if (!scanner) return;
+  const result = await scanner.scan(makeSpamScanEmail(input));
+  if (result.isSpam) {
+    throw new Error(`Spam detected: ${result.message}`);
+  }
+};
+const getObjectJson = async <T>(bucket: R2Bucket, key: string) => {
+  try {
+    const object = await bucket.get(key);
+    if (object === null) return undefined;
+    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") {
+      return undefined;
+    }
+    throw error;
+  }
+};
+const putIssue = async (bucket: R2Bucket, repoId: string, issue: GitBugIssue) => {
+  await bucket.put(issueKey(repoId, issue.id), JSON.stringify(issue, null, 2), {
+    httpMetadata: { contentType: "application/json; charset=utf-8" },
+  });
+  return issue;
+};
+export const getGitBugIssues = async (
+  bucket: R2Bucket,
+  repoId: string,
+): Promise<GitBugIssuesResult> => {
+  try {
+    const issues: GitBugIssue[] = [];
+    let cursor: string | undefined;
+    do {
+      const page = await bucket.list({
+        prefix: issuesPrefix(repoId),
+        cursor,
+      });
+      const pageIssues = await Promise.all(
+        page.objects
+          .filter((object) => object.key.endsWith(".json"))
+          .map(async (object) => {
+            return await getObjectJson<GitBugIssue>(bucket, object.key);
+          }),
+      );
+      issues.push(...pageIssues.filter((issue): issue is GitBugIssue => Boolean(issue)));
+      cursor = page.truncated ? page.cursor : undefined;
+    } while (cursor);
+    return {
+      issues: issues.sort((a, b) => b.updatedAt.localeCompare(a.updatedAt)),
+      isAvailable: true,
+    };
+  } catch {
+    return {
+      issues: [],
+      isAvailable: false,
+    };
+  }
+};
+export const getGitBugIssue = async (
+  bucket: R2Bucket,
+  repoId: string,
+  issueId: string,
+): Promise<GitBugIssue | undefined> => {
+  return await getObjectJson<GitBugIssue>(bucket, issueKey(repoId, issueId));
+};
+export const createGitBugIssue = async (
+  bucket: R2Bucket,
+  repoId: string,
+  input: {
+    title: string;
+    body?: string;
+    author?: string;
+    labels?: string[];
+  },
+) => {
+  const labels = normalizeLabels(input.labels);
+  await assertNotSpam({
+    subject: input.title,
+    body: input.body,
+    author: input.author,
+    labels,
+  });
+  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(bucket, repoId, issue);
+};
+export const addGitBugIssueComment = async (
+  bucket: R2Bucket,
+  repoId: string,
+  issueId: string,
+  input: {
+    body: string;
+    author?: string;
+  },
+) => {
+  const issue = await getGitBugIssue(bucket, repoId, issueId);
+  if (!issue) {
+    throw new Error("Issue not found.");
+  }
+  await assertNotSpam({
+    subject: `Comment on ${issue.title}`,
+    body: input.body,
+    author: input.author,
+    labels: issue.labels,
+  });
+  const now = new Date().toISOString();
+  return await putIssue(bucket, repoId, {
+    ...issue,
+    updatedAt: now,
+    comments: [
+      ...issue.comments,
+      {
+        id: makeIssueId(),
+        author: input.author?.trim() || "anonymous",
+        createdAt: now,
+        body: input.body.trim(),
+      },
+    ],
+  });
+};
+export const setGitBugIssueState = async (
+  bucket: R2Bucket,
+  repoId: string,
+  issueId: string,
+  state: GitBugIssueState,
+  author?: string,
+) => {
+  const issue = await getGitBugIssue(bucket, repoId, issueId);
+  if (!issue) {
+    throw new Error("Issue not found.");
+  }
+  return await putIssue(bucket, repoId, {
+    ...issue,
+    author: author?.trim() || issue.author,
+    state,
+    updatedAt: new Date().toISOString(),
+  });
+};

packages/shared/core/src/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;
+};

packages/shared/core/src/index.ts ADDED Viewed

@@ -0,0 +1,21 @@
+export { renderMarkdown } from "./markdown";
+export { getRepos, getRepo, getPosts, getPost } from "./content";
+export {
+  getGitBugIssues,
+  getGitBugIssue,
+  createGitBugIssue,
+  addGitBugIssueComment,
+  setGitBugIssueState,
+} from "./gitBug";
+export type { GitBugIssueState, GitBugIssue, GitBugComment, GitBugIssuesResult } from "./gitBug";
+export { getRepoReadme } from "./repoContent";
+export { buildFileTree, sortChildren, sortAll, resolveFolderIcon, resolveFileIcon } from "./files";
+export type { FileNode } from "./files";
+export {
+  getCommits,
+  getFiles,
+  getFileHistory,
+  getFileContentData,
+  generateHTMLDiff,
+} from "./gitReader";
+export type { Commit } from "./gitReader";

packages/shared/core/src/markdown.ts ADDED Viewed

@@ -0,0 +1,20 @@
+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" },
+  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);
+};

packages/shared/core/src/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();
+};

packages/shared/core/tsconfig.json ADDED Viewed

@@ -0,0 +1,4 @@
+{
+  "extends": "../../../tsconfig.base.json",
+  "include": ["src"]
+}

pnpm-lock.yaml CHANGED Viewed

@@ -319,6 +319,51 @@ importers:
   packages/shared/config: {}
+  packages/shared/core:
+    dependencies:
+      '@pyrossh/config':
+        specifier: workspace:*
+        version: link:../config
+      '@pyrossh/types':
+        specifier: workspace:*
+        version: link:../types
+      diff:
+        specifier: ^9.0.0
+        version: 9.0.0
+      diff2html:
+        specifier: ^3.4.52
+        version: 3.4.56
+      gray-matter:
+        specifier: ^4.0.3
+        version: 4.0.3
+      pretty-bytes:
+        specifier: ^7.1.0
+        version: 7.1.0
+      rehype-expressive-code:
+        specifier: ^0.44.0
+        version: 0.44.0
+      rehype-stringify:
+        specifier: ^10.0.1
+        version: 10.0.1
+      remark-parse:
+        specifier: ^11.0.0
+        version: 11.0.0
+      remark-rehype:
+        specifier: ^11.1.2
+        version: 11.1.2
+      spamscanner:
+        specifier: ^6.1.5
+        version: 6.1.5(@tensorflow/[email protected](@tensorflow/[email protected]))(@tensorflow/[email protected])(@tensorflow/[email protected]([email protected]))([email protected])([email protected])
+      unified:
+        specifier: ^11.0.5
+        version: 11.0.5
+    devDependencies:
+      vscode-icons:
+        specifier: https://github.com/vscode-icons/vscode-icons.git
+        version: https://codeload.github.com/vscode-icons/vscode-icons/tar.gz/7edc186619964d42ddf7da6f36c46e7cd6bcb0a8
+  packages/shared/types: {}
 packages:
   '@antfu/[email protected]':
@@ -5465,6 +5510,11 @@ packages:
   [email protected]:
     resolution: {integrity: sha512-ulCrSnFnfQ16YzvwnYUgEbUEl/ZG7u2eV27YhvLObSHKkb8fw1Z9cgsnUwjTEeDIdJDoTDTDpxuhQwoenoLNMg==}
+  vscode-icons@https://codeload.github.com/vscode-icons/vscode-icons/tar.gz/7edc186619964d42ddf7da6f36c46e7cd6bcb0a8:
+    resolution: {gitHosted: true, integrity: sha512-UlXu55W0F7EFAA1tHF+sJzGKx8P784KlHwPJ7xYOqxaGPJSWU9rfUmj0vpHtewu2ATTTwZQTF95jUIm0dWFZig==, tarball: https://codeload.github.com/vscode-icons/vscode-icons/tar.gz/7edc186619964d42ddf7da6f36c46e7cd6bcb0a8}
+    version: 12.19.0
+    engines: {node: '>=18.15.0', vscode: ^1.82.0}
   vscode-icons@https://codeload.github.com/vscode-icons/vscode-icons/tar.gz/e4668f9a6cd557cfa4c2546a2449b66a8bb66ddb:
     resolution: {gitHosted: true, integrity: sha512-wHJnKRT1j2gGk/gSzbLZjCCz06ptkd4gWtrBwRZ15Rp9G7ghROy6Jh9wo1LlR2YoZDey2hsqSYdlWHuDcl475A==, tarball: https://codeload.github.com/vscode-icons/vscode-icons/tar.gz/e4668f9a6cd557cfa4c2546a2449b66a8bb66ddb}
     version: 12.19.0
@@ -11002,6 +11052,14 @@ snapshots:
       vscode-languageserver-types: 3.18.0
       vscode-uri: 3.1.0
+  vscode-icons@https://codeload.github.com/vscode-icons/vscode-icons/tar.gz/7edc186619964d42ddf7da6f36c46e7cd6bcb0a8:
+    dependencies:
+      inversify: 6.2.2([email protected])
+      lodash: 4.18.1
+      open: 8.4.2
+      reflect-metadata: 0.2.2
+      semver: 7.8.5
   vscode-icons@https://codeload.github.com/vscode-icons/vscode-icons/tar.gz/e4668f9a6cd557cfa4c2546a2449b66a8bb66ddb:
     dependencies:
       inversify: 6.2.2([email protected])