@volter/twin-standard 1.0.29 → 1.0.31

package/src/walk/git-client.ts

@@ -0,0 +1,138 @@
+import type { GitFile } from './journey-kit.ts';
+// The git client a journey's git steps are: what `git clone` and `git push` send over smart HTTP (protocol v0),
+// built on the kernel's git library, so a life reaches a pack's git plane with a client's own bytes. It keeps no
+// working copy between steps: a push fetches the ref's tip as a clone would have, writes its files on top and
+// sends the ref command with a pack of what it made.
+import { MemoryBlobStore, git } from '@volter/world-core/runtime';
+
+type Fetch = (request: Request) => Promise<Response>;
+export type GitAnswer = { status: number; body: unknown; text: string };
+
+const ENC = new TextEncoder();
+const DEC = new TextDecoder();
+const cat = (...parts: Uint8Array[]): Uint8Array => git.concat(...parts);
+
+/** The refs a smart-HTTP advertisement names, and the World's date the server answered at. */
+async function advertised(fetch: Fetch, base: string, service: git.Service, headers: Record<string, string>): Promise<{ status: number; refs: Map<string, string>; date: number; text: string }> {
+  const res = await fetch(new Request(`${base}/info/refs?service=${service}`, { headers }));
+  const bytes = new Uint8Array(await res.arrayBuffer());
+  const refs = new Map<string, string>();
+  if (res.status !== 200) return { status: res.status, refs, date: 0, text: DEC.decode(bytes) };
+  const first = git.readPktLines(bytes);
+  for (const line of git.readPktLines(first.rest).lines) {
+    const [sha, name] = line.split('\0')[0]!.trim().split(' ');
+    if (sha && name && sha !== git.ZERO_SHA) refs.set(name, sha);
+  }
+  return { status: res.status, refs, date: Date.parse(res.headers.get('date') ?? '') || 0, text: '' };
+}
+
+/** Fetch `sha` and everything it reaches into `store`, as upload-pack sends it. */
+async function fetchInto(fetch: Fetch, base: string, sha: string, store: git.GitObjectStore, headers: Record<string, string>): Promise<void> {
+  const body = cat(git.pktLine(`want ${sha} ofs-delta no-progress\n`), git.FLUSH, git.pktLine('done\n'));
+  const res = await fetch(new Request(`${base}/git-upload-pack`, { method: 'POST', headers: { ...headers, 'content-type': 'application/x-git-upload-pack-request' }, body: body as unknown as BodyInit }));
+  const bytes = new Uint8Array(await res.arrayBuffer());
+  const nak = git.readPktLines(bytes.subarray(0, 8));
+  if (!nak.lines[0]?.startsWith('NAK')) throw new Error(`upload-pack answered ${DEC.decode(bytes.subarray(0, 120)).trim()}`);
+  await git.readPack(bytes.subarray(8), store);
+}
+
+/** Every file under `tree`, by path. */
+async function flatten(store: git.GitObjectStore, tree: string, prefix = '', out = new Map<string, { mode: string; sha: string }>()): Promise<Map<string, { mode: string; sha: string }>> {
+  const obj = await store.read(tree);
+  for (const e of obj ? git.decodeTree(obj.payload) : []) {
+    if (e.mode === '40000') await flatten(store, e.sha, `${prefix}${e.name}/`, out);
+    else out.set(`${prefix}${e.name}`, { mode: e.mode, sha: e.sha });
+  }
+  return out;
+}
+
+/** The tree of `files`, nested by directory; each object it writes is pushed onto `made`. */
+async function build(store: git.GitObjectStore, files: Map<string, { mode: string; sha: string }>, made: string[]): Promise<string> {
+  const here: git.TreeEntry[] = [];
+  const dirs = new Map<string, Map<string, { mode: string; sha: string }>>();
+  for (const [path, e] of files) {
+    const slash = path.indexOf('/');
+    if (slash < 0) { here.push({ mode: e.mode, name: path, sha: e.sha }); continue; }
+    const dir = path.slice(0, slash);
+    if (!dirs.has(dir)) dirs.set(dir, new Map());
+    dirs.get(dir)!.set(path.slice(slash + 1), e);
+  }
+  for (const [dir, inner] of dirs) here.push({ mode: '40000', name: dir, sha: await build(store, inner, made) });
+  const sha = await store.write('tree', git.encodeTree(git.sortTreeEntries(here)));
+  made.push(sha);
+  return sha;
+}
+
+/** `git clone`: the ref's tip (HEAD by default) and the paths of its tree. */
+export async function gitClone(fetch: Fetch, base: string, step: { ref?: string }, headers: Record<string, string>): Promise<GitAnswer> {
+  const ad = await advertised(fetch, base, 'git-upload-pack', headers);
+  if (ad.status !== 200) return { status: ad.status, body: ad.text, text: ad.text };
+  const ref = step.ref ?? 'HEAD';
+  const sha = ad.refs.get(ref);
+  if (!sha) { const text = `fatal: Remote branch ${ref} not found in upstream origin`; return { status: 404, body: text, text }; }
+  const store = new git.GitObjectStore(new MemoryBlobStore(), 'clone');
+  await fetchInto(fetch, base, sha, store, headers);
+  const commit = git.decodeCommit((await store.read(sha))!.payload);
+  const files = await flatten(store, commit.tree);
+  const body = { sha, message: commit.message.trim(), paths: [...files.keys()].sort(), refs: [...ad.refs.keys()].sort() };
+  return { status: 200, body, text: JSON.stringify(body) };
+}
+
+export type GitPush = {
+  ref: string;
+  /** a path's new content, or null to delete it */
+  files?: Record<string, GitFile>;
+  message?: string;
+  author?: string;
+  /** rewrite the tip instead of building on it (`git commit --amend`), which only a force push lands */
+  amend?: boolean;
+  /** delete the ref (`git push origin :<ref>`) */
+  delete?: boolean;
+};
+
+/** `git push`: a commit of `files` on the ref's tip (a new ref starts from HEAD's), sent with the pack of what it made.
+ *  The answer is the server's report: `unpack`, the ref's `result` (`ok`, or its `ng` reason) and the pushed `sha`. */
+export async function gitPush(fetch: Fetch, base: string, step: GitPush, headers: Record<string, string>): Promise<GitAnswer> {
+  const ad = await advertised(fetch, base, 'git-receive-pack', headers);
+  if (ad.status !== 200) return { status: ad.status, body: ad.text, text: ad.text };
+  const old = ad.refs.get(step.ref) ?? git.ZERO_SHA;
+  const store = new git.GitObjectStore(new MemoryBlobStore(), 'push');
+  let next = git.ZERO_SHA;
+  const made: string[] = [];
+  if (!step.delete) {
+    const tip = old !== git.ZERO_SHA ? old : ad.refs.get('HEAD');
+    let files = new Map<string, { mode: string; sha: string }>();
+    let parents: string[] = [];
+    if (tip) {
+      await fetchInto(fetch, base, tip, store, headers);
+      const commit = git.decodeCommit((await store.read(tip))!.payload);
+      files = await flatten(store, commit.tree);
+      parents = step.amend ? commit.parents : [tip];
+    }
+    for (const [path, content] of Object.entries(step.files ?? {})) {
+      if (content === null) { files.delete(path); continue; }
+      if (typeof content === 'object' && content.mode === '160000') { files.set(path, { mode: content.mode, sha: content.sha }); continue; }
+      const sha = await store.write('blob', ENC.encode(typeof content === 'string' ? content : content.content));
+      made.push(sha);
+      files.set(path, { mode: typeof content === 'string' ? '100644' : content.mode, sha });
+    }
+    const tree = await build(store, files, made);
+    const [name, email] = (step.author ?? 'octocat <octocat@github.com>').split(/\s*<|>/);
+    // the commit is dated by the World's clock, as the server's Date header reads it
+    const who = { name: name!.trim(), email: (email ?? '').trim(), time: Math.floor(ad.date / 1000), tz: '+0000' };
+    next = await store.write('commit', git.encodeCommit({ tree, parents, author: who, committer: who, message: `${step.message ?? 'Update'}\n` }));
+    made.push(next);
+  }
+  const objects = await Promise.all([...new Set(made)].map(async (sha) => ({ ...(await store.read(sha))! })));
+  const command = git.pktLine(`${old} ${next} ${step.ref}\0report-status\n`);
+  const body = step.delete ? cat(command, git.FLUSH) : cat(command, git.FLUSH, await git.writePack(objects));
+  const res = await fetch(new Request(`${base}/git-receive-pack`, { method: 'POST', headers: { ...headers, 'content-type': 'application/x-git-receive-pack-request' }, body: body as unknown as BodyInit }));
+  const bytes = new Uint8Array(await res.arrayBuffer());
+  if (res.status !== 200) { const text = DEC.decode(bytes); return { status: res.status, body: text, text }; }
+  const lines = git.readPktLines(bytes).lines.map((l) => l.trim());
+  const unpack = lines.find((l) => l.startsWith('unpack '))?.slice(7) ?? '';
+  const verdict = lines.find((l) => l.startsWith('ok ') || l.startsWith('ng '));
+  const result = verdict?.startsWith('ok ') ? 'ok' : verdict?.slice(4 + step.ref.length).trim() ?? '';
+  const answer = { unpack, result, sha: next, before: old };
+  return { status: res.status, body: answer, text: JSON.stringify(answer) };
+}