main
1// Pack index v2 (src/packindex.ts) and the pack walk (src/packwalk.ts), judged by git.
2//
3// - indexPack and encodePackIndex write the bytes `git index-pack` writes for the same pack: git's own packs (OFS_DELTA
4// from repack, REF_DELTA from pack-objects without --delta-base-offset, the empty pack) and ply's (objectsForPack →
5// planDeltas → buildPack). The 64-bit offset table is read back by `git show-index`.
6// - objectsForPack over a store of fetched objects sends exactly `git rev-list --objects <tips> --not <have>`, and each
7// tree and blob carries a path where some commit holds it.
8// - End to end, the export a Worker would do with no disk: those three calls plus encodePackIndex and four small text
9// files, served as static files over plain HTTP (git's dumb protocol: no git on the server), are cloned by stock git,
10// pass `fsck --strict`, and have the source's refs.
11import { test, beforeAll as before, afterAll as after } from 'vitest';
12import assert from 'node:assert/strict';
13import { join } from 'node:path';
14import { mkdirSync, writeFileSync, readFileSync, readdirSync, mkdtempSync, existsSync } from 'node:fs';
15import { createServer } from 'node:http';
16import { execFileSync } from 'node:child_process';
17import { git, gitBuf, gitAsync, tmpRoot, fsckProblems } from './server.js';
18import { encodePackIndex, indexPack, layoutPackIndex } from '../src/packindex.js';
19import { objectsForPack, reachableObjects, mapStore } from '../src/packwalk.js';
20import { encodeDelta, planDeltas } from '../src/delta.js';
21import { buildPack, parsePack, resolvePack } from '../src/pack.js';
22import { hashObject, TYPE } from '../src/objects.js';
23import { fromHex } from '../src/sha1.js';
25let root, cleanup;
26before(() => { ({ root, cleanup } = tmpRoot()); });
27after(() => cleanup());
29const ID = ['-c', 'user.name=Ix', '-c', 'user.email=ix@example.com'];
30let n = 0;
31const fresh = (bare = true) => { const d = mkdtempSync(join(root, `r${n++}-`)); git(d, ['init', '-q', ...(bare ? ['--bare'] : []), '-b', 'main']); return d; };
32// A history with something for every pack shape: a file edited in every commit (delta chains), a renamed file, a
33// binary blob, nested directories, an executable, a symlink, a gitlink (not followed), a second branch, and an annotated
34// and a lightweight tag.
35function history() {
36 const w = fresh(false);
37 const lines = Array.from({ length: 400 }, (_, i) => `line ${i}: ${'lorem ipsum dolor sit amet '.repeat(2)}`);
38 const commit = (msg, t) => { git(w, ['add', '-A']); git(w, [...ID, 'commit', '-q', '-m', msg], { env: { ...process.env, GIT_AUTHOR_DATE: `${t} +0000`, GIT_COMMITTER_DATE: `${t} +0000` } }); };
39 mkdirSync(join(w, 'src/deep/er'), { recursive: true });
40 for (let i = 0; i < 12; i++) {
41 lines[i * 7] = `edited in commit ${i}`;
42 writeFileSync(join(w, 'src/deep/er/big.txt'), lines.join('\n'));
43 writeFileSync(join(w, i < 6 ? 'old-name.txt' : 'new-name.txt'), `${lines.slice(0, 120).join('\n')}\nv${i}\n`);
44 if (i === 6) git(w, ['rm', '-q', 'old-name.txt']);
45 writeFileSync(join(w, 'bin.dat'), Buffer.from(Array.from({ length: 3000 }, (_, k) => (k * 31 + i) & 0xff)));
46 if (i === 0) {
47 writeFileSync(join(w, 'run.sh'), '#!/bin/sh\necho hi\n'); execFileSync('chmod', ['+x', join(w, 'run.sh')]);
48 execFileSync('ln', ['-s', 'src/deep/er/big.txt', join(w, 'link')]);
49 git(w, ['update-index', '--add', '--cacheinfo', `160000,${'5'.repeat(40)},vendor/sub`]);
50 }
51 commit(`c${i}`, 1_700_000_000 + i * 60);
52 if (i === 4) git(w, [...ID, 'tag', '-a', '-m', 'annotated', 'v1']);
53 if (i === 8) { git(w, ['branch', 'side']); git(w, ['tag', 'light']); }
54 }
55 git(w, ['checkout', '-q', 'side']);
56 writeFileSync(join(w, 'side.txt'), 'only on side\n');
57 commit('side', 1_700_001_000);
58 git(w, ['checkout', '-q', 'main']);
59 return w;
60}
61// git's idx for a pack: index-pack in an empty repository (the bytes it writes, and the pack name it prints)
62function gitIndex(pack) {
63 const d = fresh();
64 const p = join(d, 'x.pack');
65 writeFileSync(p, pack);
66 git(d, ['index-pack', '-o', join(d, 'x.idx'), p]);
67 return readFileSync(join(d, 'x.idx'));
68}
69const unwrap = r => { assert.ok(r.ok, r.ok ? '' : `${r.error.code}: ${r.error.message}`); return r.value; };
70const eqBytes = (a, b, what) => { assert.equal(Buffer.compare(Buffer.from(a), Buffer.from(b)), 0, `${what}: ${a.length} vs ${b.length} bytes, not byte-identical`); };
71// every object of a repository, as a Worker holds them after one fetch: resolvePack's map
72function objectsOf(dir) {
73 const pack = gitBuf(dir, ['pack-objects', '--all', '--stdout', '-q'], '');
74 return unwrap(resolvePack(unwrap(parsePack(pack)))).objects;
75}
76const refsOf = dir => git(dir, ['for-each-ref', '--format=%(objectname) %(refname)']).trim().split('\n').map(l => l.split(' '));
78test('indexPack writes git index-pack\'s bytes for git\'s own packs: OFS deltas, REF deltas, the empty pack', () => {
79 const w = history();
80 git(w, ['repack', '-adq', '--depth=50', '--window=10']);
81 const packs = readdirSync(join(w, '.git/objects/pack'));
82 const name = packs.find(f => f.endsWith('.pack'));
83 const ofsPack = readFileSync(join(w, '.git/objects/pack', name));
84 const refPack = gitBuf(w, ['pack-objects', '--all', '--stdout', '-q'], ''); // no --delta-base-offset: REF_DELTA
85 const emptyPack = gitBuf(w, ['pack-objects', '--stdout', '-q'], '');
86 const kinds = p => { const o = unwrap(parsePack(p)).objects; return { ofs: o.filter(x => x.type === TYPE.OFS_DELTA).length, ref: o.filter(x => x.type === TYPE.REF_DELTA).length, all: o.length }; };
87 assert.ok(kinds(ofsPack).ofs > 10 && kinds(ofsPack).ref === 0, JSON.stringify(kinds(ofsPack)));
88 assert.ok(kinds(refPack).ref > 10 && kinds(refPack).ofs === 0, JSON.stringify(kinds(refPack)));
89 for (const [label, pack, gitIdx] of [['repack (OFS_DELTA)', ofsPack, readFileSync(join(w, '.git/objects/pack', name.replace(/\.pack$/, '.idx')))], ['pack-objects (REF_DELTA)', refPack, gitIndex(refPack)], ['empty', emptyPack, gitIndex(emptyPack)]]) {
90 const r = unwrap(indexPack(pack));
91 eqBytes(r.idx, gitIdx, label);
92 assert.equal(r.objects, kinds(pack).all);
93 assert.equal(r.checksum, Buffer.from(pack.subarray(pack.length - 20)).toString('hex'));
94 }
95});
97test('objectsForPack sends exactly rev-list --objects, with paths git agrees with; planDeltas + buildPack + encodePackIndex is index-pack\'s idx', async () => {
98 const w = history();
99 const all = objectsOf(w);
100 const store = mapStore(all);
101 const tips = refsOf(w).map(([oid]) => oid);
102 const listed = (args) => new Set(git(w, ['rev-list', '--objects', ...args]).trim().split('\n').filter(Boolean).map(l => l.slice(0, 40)));
103 // (oid, path) pairs that some commit holds: ls-tree -r -t of every commit
104 const held = new Set();
105 for (const c of git(w, ['rev-list', '--all']).trim().split('\n')) for (const l of git(w, ['ls-tree', '-r', '-t', c]).trim().split('\n')) { const [meta, path] = l.split('\t'); held.add(`${meta.split(' ')[2]} ${path}`); }
106 // two cuts: everything, and only what `light` (tag) and main lack beyond v1
107 const v1 = git(w, ['rev-parse', 'v1^{commit}']).trim();
108 const have = unwrap(await reachableObjects(store, [v1]));
109 assert.deepEqual(have, listed([v1]));
110 for (const [label, wanted, haveSet, notArgs] of [['everything', tips, new Set(), []], ['beyond v1', ['refs/heads/main', 'refs/tags/light'].map(r => git(w, ['rev-parse', r]).trim()), have, ['--not', v1]]]) {
111 const cands = unwrap(await objectsForPack(store, wanted, haveSet));
112 assert.deepEqual(new Set(cands.map(c => c.oid)), listed([...wanted, ...notArgs]), label);
113 assert.equal(cands.length, new Set(cands.map(c => c.oid)).size, `${label}: an object twice`);
114 for (const c of cands) {
115 assert.equal(hashObject(['', 'commit', 'tree', 'blob', 'tag'][c.type], c.data), c.oid);
116 if (c.type === TYPE.TREE || c.type === TYPE.BLOB) assert.ok(c.path === '' ? c.type === TYPE.TREE : held.has(`${c.oid} ${c.path}`), `${label}: ${c.oid} at ${c.path}`);
117 else assert.equal(c.path, null);
118 }
119 const plan = planDeltas(cands);
120 if (label === 'everything') assert.ok(plan.ofs > 20, `deltas: ${plan.ofs}`);
121 const built = await buildPack(plan.objects);
122 const idx = unwrap(encodePackIndex(built.pack, cands.map((c, i) => ({ oid: c.oid, offset: built.entries[i].offset }))));
123 eqBytes(idx, gitIndex(built.pack), `${label}: encodePackIndex`);
124 eqBytes(unwrap(indexPack(built.pack)).idx, idx, `${label}: indexPack`);
125 }
126});
128test('the 64-bit offset table: git show-index reads back every row of layoutPackIndex', () => {
129 const offsets = [12, 2 ** 31 - 1, 2 ** 31, 2 ** 32 + 5, 2 ** 40 + 3, 2 ** 53 - 1];
130 const rows = offsets.map((offset, i) => ({ oid: hashObject('blob', new TextEncoder().encode(`o${i}`)), offset, crc32: (0x9e37_79b9 * (i + 1)) >>> 0 }));
131 const checksum = fromHex('ab'.repeat(20));
132 const idx = unwrap(layoutPackIndex(rows, checksum));
133 // git show-index: "<offset> <oid> (<crc32>)" per object, in id order
134 const shown = execFileSync('git', ['show-index'], { input: idx, encoding: 'utf8' }).trim().split('\n').map(l => { const [off, oid, crc] = l.split(' '); return { oid, offset: Number(off), crc32: Number.parseInt(crc.slice(1, -1), 16) }; });
135 assert.deepEqual(shown, rows.toSorted((a, b) => (a.oid < b.oid ? -1 : 1)));
136 assert.equal(idx.length, 8 + 1024 + rows.length * 28 + 4 * 8 + 40); // four offsets at or past 2^31 take a 64-bit slot
137 eqBytes(idx.subarray(idx.length - 40, idx.length - 20), checksum, 'pack checksum');
138});
140test('refusals: a malformed index request is bad_request, a thin or duplicated pack is pack_corrupt (git agrees)', async () => {
141 const blob = new TextEncoder().encode('x'.repeat(100));
142 const oid = hashObject('blob', blob);
143 const { pack, entries } = await buildPack([{ type: TYPE.BLOB, data: blob }]);
144 const ck = pack.subarray(pack.length - 20);
145 const code = r => (r.ok ? 'ok' : `${r.error.code}:${r.error.what}`);
146 const cases = {
147 'short pack': [encodePackIndex(pack.subarray(0, 31), []), 'bad_request:pack'],
148 // the limits record is parsed once, before the pack is read (#156); a key left out is the default
149 'bad limits': [indexPack(pack, { maxDeltaChain: -1 }), 'bad_request:maxDeltaChain'],
150 'partial limits': [indexPack(pack, { maxPackObjects: 1 }), 'ok'],
151 'a cap the pack passes': [indexPack(pack, { maxPackObjects: 0 }), 'limit_exceeded:pack objects'],
152 'not a pack': [encodePackIndex(Uint8Array.from([...pack].map((b, i) => (i === 0 ? 0x51 : b))), [{ oid, offset: 12 }]), 'bad_request:pack'],
153 'version 3': [encodePackIndex(Uint8Array.from([...pack].map((b, i) => (i === 7 ? 3 : b))), [{ oid, offset: 12 }]), 'bad_request:pack'],
154 'count mismatch': [encodePackIndex(pack, []), 'bad_request:objects'],
155 'first offset not 12': [encodePackIndex(pack, [{ oid, offset: 13 }]), 'bad_request:offset'],
156 'offset in the trailer': [layoutPackIndex([{ oid, offset: 11, crc32: 0 }], ck), 'bad_request:offset'],
157 'fractional offset': [layoutPackIndex([{ oid, offset: 12.5, crc32: 0 }], ck), 'bad_request:offset'],
158 'unsafe offset': [layoutPackIndex([{ oid, offset: 2 ** 53, crc32: 0 }], ck), 'bad_request:offset'],
159 'uppercase oid': [layoutPackIndex([{ oid: oid.toUpperCase(), offset: 12, crc32: 0 }], ck), 'bad_request:oid'],
160 'short oid': [layoutPackIndex([{ oid: oid.slice(1), offset: 12, crc32: 0 }], ck), 'bad_request:oid'],
161 'crc32 too big': [layoutPackIndex([{ oid, offset: 12, crc32: 2 ** 32 }], ck), 'bad_request:crc32'],
162 'crc32 negative': [layoutPackIndex([{ oid, offset: 12, crc32: -1 }], ck), 'bad_request:crc32'],
163 'oid twice': [layoutPackIndex([{ oid, offset: 12, crc32: 0 }, { oid, offset: 40, crc32: 0 }], ck), 'bad_request:oid'],
164 'checksum 19 bytes': [layoutPackIndex([], ck.subarray(1)), 'bad_request:checksum'],
165 };
166 for (const [label, [r, want]] of Object.entries(cases)) assert.equal(code(r), want, label);
167 // two entries at one offset: the second has no bytes
168 const two = await buildPack([{ type: TYPE.BLOB, data: blob }, { type: TYPE.BLOB, data: new TextEncoder().encode('y') }]);
169 assert.equal(code(encodePackIndex(two.pack, [{ oid, offset: 12 }, { oid: hashObject('blob', new TextEncoder().encode('y')), offset: 12 }])), 'bad_request:offset');
170 assert.equal(code(encodePackIndex(two.pack, [{ oid, offset: 12 }, { oid: hashObject('blob', new TextEncoder().encode('y')), offset: two.pack.length }])), 'bad_request:offset');
171 assert.ok(entries[0].offset === 12 && two.entries[1].offset === 12 + two.entries[0].bytes);
173 // the same object twice: git index-pack --strict refuses it, and so does indexPack
174 const dup = (await buildPack([{ type: TYPE.BLOB, data: blob }, { type: TYPE.BLOB, data: blob }])).pack;
175 const d = fresh();
176 writeFileSync(join(d, 'dup.pack'), dup);
177 assert.throws(() => git(d, ['index-pack', '--strict', '-o', join(d, 'dup.idx'), join(d, 'dup.pack')]), /appears twice|duplicate/i);
178 assert.match(code(indexPack(dup)), /^pack_corrupt/);
179 // a thin pack (a REF_DELTA whose base is not in it): git index-pack refuses it without --fix-thin, and so does indexPack
180 const base = new TextEncoder().encode('base '.repeat(40));
181 const target = new TextEncoder().encode(`${'base '.repeat(40)}and more`);
182 const thin = (await buildPack([{ type: TYPE.BLOB, data: encodeDelta(base, target), base: { tag: 'ref', oid: hashObject('blob', base) } }])).pack;
183 writeFileSync(join(d, 'thin.pack'), thin);
184 assert.throws(() => git(d, ['index-pack', '-o', join(d, 'thin.idx'), join(d, 'thin.pack')]), /unresolved deltas|fatal/i);
185 assert.match(code(indexPack(thin)), /^pack_corrupt/);
186 // a corrupt trailer is the parser's refusal
187 assert.match(code(indexPack(Uint8Array.from([...pack].map((b, i) => (i === pack.length - 1 ? b ^ 1 : b))))), /^pack_corrupt/);
188 // the walk: a wanted object the store lacks is bad_request naming it; a tip of the wrong kind where a tree is named is pack_corrupt
189 const missing = await objectsForPack(mapStore(new Map()), [oid]);
190 assert.equal(code(missing), 'bad_request:object');
191 assert.match(missing.error.message, /is missing from the object store/);
192 const commitText = new TextEncoder().encode(`tree ${oid}\nauthor A <a@x> 1 +0000\ncommitter A <a@x> 1 +0000\n\nm\n`);
193 const commitOid = hashObject('commit', commitText);
194 const wrong = await objectsForPack(mapStore(new Map([[commitOid, { type: TYPE.COMMIT, data: commitText }], [oid, { type: TYPE.BLOB, data: blob }]])), [commitOid]);
195 assert.equal(code(wrong), 'pack_corrupt:object');
196});
198// A static file server: what an object store's public bucket is to git (GET only; info/refs ignores ?service=, so
199// git falls back from smart to dumb HTTP).
200function staticServer(dir) {
201 const hits = [];
202 const srv = createServer((req, res) => {
203 const path = decodeURIComponent(new URL(req.url, 'http://x').pathname);
204 hits.push(`${req.method} ${path}`);
205 const file = join(dir, path);
206 if (req.method !== 'GET' || path.includes('..') || !existsSync(file)) { res.writeHead(404); res.end(); return; }
207 res.writeHead(200, { 'content-type': 'application/octet-stream' });
208 res.end(readFileSync(file));
209 });
210 return new Promise(ok => srv.listen(0, '127.0.0.1', () => ok({ url: `http://127.0.0.1:${srv.address().port}`, hits, close: () => new Promise(c => srv.close(c)) })));
211}
213test('end to end: an export with no disk and no git (walk, plan, build, index) clones from static files with stock git', async () => {
214 const w = history();
215 const source = fresh();
216 git(w, ['push', '-q', '--mirror', source]);
217 // what a Worker has after ls-refs and one fetch: the refs (with peeled tags) and resolvePack's objects
218 const objects = objectsOf(source);
219 const refs = git(source, ['for-each-ref', '--format=%(objectname) %(refname) %(*objectname)']).trim().split('\n').map(l => { const [oid, name, peeled] = l.split(' '); return { oid, name, peeled: peeled || null }; });
220 // ---- the export: ply's public API (imported from the modules src/index.ts re-exports) and ~10 lines of layout ----
221 const order = unwrap(await objectsForPack(mapStore(objects), refs.map(r => r.oid)));
222 const plan = planDeltas(order);
223 const { pack, entries } = await buildPack(plan.objects);
224 const idx = unwrap(encodePackIndex(pack, order.map((o, i) => ({ oid: o.oid, offset: entries[i].offset }))));
225 const name = `pack-${Buffer.from(pack.subarray(pack.length - 20)).toString('hex')}`;
226 const files = {
227 [`objects/pack/${name}.pack`]: pack,
228 [`objects/pack/${name}.idx`]: idx,
229 'objects/info/packs': `P ${name}.pack\n\n`,
230 'info/refs': refs.map(r => `${r.oid}\t${r.name}\n${r.peeled ? `${r.peeled}\t${r.name}^{}\n` : ''}`).join(''),
231 HEAD: 'ref: refs/heads/main\n',
232 };
233 // ---- publish (here: a directory; in a Worker: R2 puts) and clone ----
234 const site = mkdtempSync(join(root, 'site-'));
235 for (const [key, body] of Object.entries(files)) { mkdirSync(join(site, 'repo.git', key, '..'), { recursive: true }); writeFileSync(join(site, 'repo.git', key), body); }
236 const srv = await staticServer(site);
237 try {
238 const clone = join(root, `clone-${n++}`);
239 // async: the server answers on this process's event loop, which execFileSync would block
240 const cloned = await gitAsync(root, ['clone', '-q', '--mirror', `${srv.url}/repo.git`, clone]);
241 assert.equal(cloned.status, 0, cloned.stderr);
242 assert.deepEqual(fsckProblems(clone), []);
243 assert.deepEqual(refsOf(clone), refsOf(source));
244 assert.equal(git(clone, ['rev-list', '--objects', '--all']).trim().split('\n').length, objects.size);
245 assert.ok(srv.hits.includes('GET /repo.git/info/refs') && srv.hits.some(h => h.endsWith('.idx')), srv.hits.join('\n'));
246 assert.ok(!srv.hits.some(h => h.startsWith('POST')), 'dumb HTTP: GETs only');
247 // the pack is delta-compressed: smaller than the objects whole, and git's verify-pack reads the same chain shapes
248 assert.ok(plan.ofs > 20 && pack.length < plan.rawBytes / 2, `${pack.length} B for ${plan.rawBytes} B raw, ${plan.ofs} deltas`);
249 git(root, ['verify-pack', join(site, 'repo.git', `objects/pack/${name}.idx`)]);
250 } finally { await srv.close(); }
251});
Diagnostics4 git calls · 441 ms
CallStatusSizeTime0441 ms
discover200152 B3 ms
git.upload-pack discover http.response.status_code=200 git.upstream.cf_ray=- git.upstream.phase=ls-refs git.upstream.dur_ms=3 git.response.bytes=152 git.server.agent=gitty/1.0 git.server.object_format=sha1 git.server.caps=agent ls-refs fetch object-format git.server.fetch=shallow filter sideband-all git.protocol.version=2 git.pkt.frames=8 git.pkt.data=6 git.pkt.flush=2 git.pkt.delim=0 git.pkt.bytes=152 git.pkt.payload.max=34
ls-refs200145 B · hit3 ms
git.upload-pack ls-refs http.response.status_code=200 git.upstream.cf_ray=- git.upstream.phase=ls-refs git.upstream.dur_ms=3 git.response.bytes=145 git.response.cache=HIT git.response.duration_ms=3 git.protocol.version=2 git.pkt.frames=3 git.pkt.data=2 git.pkt.flush=1 git.pkt.delim=0 git.pkt.bytes=145 git.pkt.payload.max=76 git.ls_refs.count=2 git.ls_refs.head=refs/heads/main
fetchblob:none · deepen 1020038 KiB · hit2 ms
git.upload-pack fetch http.response.status_code=200 git.upstream.cf_ray=- git.upstream.phase=fetch git.upstream.dur_ms=2 git.response.bytes=38434 git.response.cache=HIT git.response.duration_ms=2 git.fetch.filter=blob:none git.fetch.filter.requested=tree:0 git.fetch.filter.fallback=blob:none git.fetch.filter.learned=false git.fetch.wants=19912563f540228593df0c489082e5e2508e21e4 git.fetch.haves.count=0 git.fetch.deepen=10 git.fetch.thin_pack=false git.fetch.ofs_delta=true git.protocol.version=2 git.pkt.frames=6 git.pkt.data=4 git.pkt.flush=1 git.pkt.delim=1 git.pkt.bytes=38434 git.pkt.payload.max=38339 git.sideband.band1.bytes=38338 git.sideband.band2.bytes=0 git.sideband.band3.bytes=0 git.pack.objects=63 git.pack.bytes=38338 git.pack.ofs_delta=0 git.pack.ref_delta=8 git.pack.chain.max=8 git.pack.trailer=0bc36ab7adf82d3109177f11f1ea93f1ce071f77 git.pack.full=55Open pack map
fetch2006.2 KiB436 ms
git.upload-pack fetch http.response.status_code=200 git.upstream.cf_ray=- git.upstream.phase=fetch git.upstream.dur_ms=436 git.response.bytes=6377 git.response.cache=MISS git.response.duration_ms=436 git.fetch.wants=6db0a8b9b30aa918a834d689394b2d6d51da5e11 git.fetch.haves.count=0 git.fetch.deepen=0 git.fetch.thin_pack=false git.fetch.ofs_delta=true git.protocol.version=2 git.pkt.frames=3 git.pkt.data=2 git.pkt.flush=1 git.pkt.delim=0 git.pkt.bytes=6377 git.pkt.payload.max=6356 git.sideband.band1.bytes=6355 git.sideband.band2.bytes=0 git.sideband.band3.bytes=0
Each row is one HTTP round trip ply made to the git server for this page, on one timeline. discover asks what the server speaks, ls-refs lists branch tips, fetch brings objects by id. A hit was served by Workers Cache. Tap a row for its wire details.
- Remote
- https://5ad2236b39de4c8bd8f6270ea63f3ea9.artifacts.cloudflare.net/git/public-v0/ply.git
- Ref
- refs/heads/main
- Commit
- 19912563f540228593df0c489082e5e2508e21e4
- cf-ray
- a5e26a614e37f4e0
- Request
- d24f61fb…
- Protocol
- v2 · sha1
- Agent
- gitty/1.0
- Filter
- advertised
- Fetch
- shallow filter sideband-all
- Capabilities
- agent ls-refs fetch object-format