main
ply4 git calls24 ms48 KiB3 cachedprotocol v2
399 lines20 KiBRaw
1// The public namespace: one Cloudflare Artifacts namespace this Worker serves read-only, with no PLY_TOKEN and no caller
2// credential. The Worker holds no stored secret for it. It mints a short-lived read token per repo through the
3// namespace-scoped Artifacts binding (PUBLIC_REPOS, declared in cloudflare.config.ts with the same PUBLIC_NAMESPACE),
4// caches it per isolate until near expiry, and attaches it only to an upload-pack request whose URL is exactly
5// `${PUBLIC_GIT_ORIGIN}/git/${PUBLIC_NAMESPACE}/<repo>(.git)/info/refs?service=git-upload-pack` or `…/git-upload-pack`.
6// That check runs on the raw URL of every request ply makes and of every redirect hop, because the attaching fetch sits
7// below the redirect-following guards (createGuardedFetch, createViewerFetch) and each hop calls it again.
8import { atIndex, captureGroup, chainGet, fromNullable, mapGet, thrownField } from './absent.ts';
9import { unwrapOr } from './option.ts';
10import { plyError } from 'ply';
11import { extractRequestPath, rawPathHasUnsafeSegment } from './pathguard.ts';
13import { PUBLIC_NAMESPACE } from './public-namespace.ts';
15export { PUBLIC_NAMESPACE };
17/** The account's Artifacts git host (account 5ad2236b…, the account that owns the `ply` Worker). */
18export const PUBLIC_GIT_HOST = '5ad2236b39de4c8bd8f6270ea63f3ea9.artifacts.cloudflare.net';
19export const PUBLIC_GIT_ORIGIN = `https://${PUBLIC_GIT_HOST}`;
21/** Read-token lifetime asked of Artifacts, and how long before expiry the Worker stops using a cached token. */
22export const READ_TOKEN_TTL_S = 3600;
23export const READ_TOKEN_REFRESH_S = 300;
24const MAX_CACHED_TOKENS = 64;
25const MS_PER_SECOND = 1000;
27// Artifacts names: start with a letter or digit, then letters, digits, `.`, `_`, `-` (developers.cloudflare.com/artifacts/platform/limits).
28// `..` and a trailing `.git` are refused here so the name and its `.git` URL form are one-to-one.
29const REPO_NAME = /^[A-Za-z0-9][A-Za-z0-9._-]{0,99}$/;
31export function isPublicRepoName(name: string): boolean {
32 return typeof name === 'string' && REPO_NAME.test(name) && !name.includes('..') && !/\.git$/i.test(name);
35const GIT_SUFFIX = '.git';
37/**
38 * The public-namespace repo name when `host` + `repoPath` is exactly one repo under PUBLIC_NAMESPACE.
39 * That name is the short viewer URL `/r/<name>`.
40 */
41export function publicRepoShortName(host: string, repoPath: string): string | null {
42 if (host !== PUBLIC_GIT_HOST) return null;
43 const prefix = `git/${PUBLIC_NAMESPACE}/`;
44 if (!repoPath.startsWith(prefix) || !repoPath.endsWith(GIT_SUFFIX)) return null;
45 const name = repoPath.slice(prefix.length, -GIT_SUFFIX.length);
46 return isPublicRepoName(name) ? name : null;
49export type RepoPresence = true | false | 'unknown';
51function thrownText(error: unknown): string {
52 const message = thrownField(error, 'message');
53 return String(message.tag === 'some' ? message.value : error);
56// `handle[Symbol.dispose]()` when the stub exposes it. A null handle still throws, matching a property read.
57// A present non-function throws when called. A missing dispose is a no-op.
58function releaseStub(handle: unknown): void {
59 const dispose = (handle as Partial<Disposable>)[Symbol.dispose];
60 const present = fromNullable(dispose);
61 if (present.tag === 'none') return;
62 const fn = present.value as (this: unknown) => void;
63 fn.call(handle);
66/** True when the namespace binding has the repo. `unknown` when the binding is missing or errors for another reason. */
67export async function publicRepoExists(binding: unknown, name: string): Promise<RepoPresence> {
68 if (!isPublicRepoName(name)) return false;
69 if (binding === null || typeof binding !== 'object') return 'unknown';
70 const get = chainGet(binding, 'get');
71 if (get.tag === 'none' || typeof get.value !== 'function') return 'unknown';
72 try {
73 const handle = await (binding as { get(name: string): Promise<unknown> }).get(name);
74 try { releaseStub(handle); } catch { /* releasing the RPC stub is best effort */ }
75 return true;
76 } catch (e) {
77 if (/not.?found|does not exist|no such/i.test(thrownText(e))) return false;
78 return 'unknown';
79 }
82/** How long an isolate trusts a `true` from publicRepoExists: the same minute the namespace listing is cached. */
83export const EXISTS_TTL_MS = 60_000;
84const MAX_EXISTS_MEMO = 256;
85const existsMemo = new WeakMap<object, Map<string, number>>();
86/** The memo's last stretch in which a request refreshes it in the background instead of letting it expire. */
87export const EXISTS_REFRESH_AHEAD_MS = 20_000;
88const existsFlights = new WeakMap<object, Set<string>>();
90/**
91 * publicRepoExists, with a `true` remembered per isolate (and per binding object) for EXISTS_TTL_MS. Each /r page asked
92 * the binding first, before any git: 37 of a 105 ms page (trace 7dc622ba…, 59f39490). Only `true` is kept, so a
93 * new repo is seen at once and a deleted one is a 404 within the minute; `false` and `unknown` always ask again.
94 */
95export async function publicRepoExistsMemo(binding: unknown, name: string, now: number = Date.now(), defer: ((p: Promise<unknown>) => void) | null = null): Promise<RepoPresence> {
96 if (binding === null || typeof binding !== 'object') return publicRepoExists(binding, name);
97 let memo = existsMemo.get(binding);
98 if (!memo) { memo = new Map(); existsMemo.set(binding, memo); }
99 const until = mapGet(memo, name);
100 if (until.tag === 'some' && until.value > now) {
101 // Refresh ahead: in the memo's last EXISTS_REFRESH_AHEAD_MS a request still answers from it (a `true` is never used
102 // past its minute) and asks the binding again in waitUntil. An expired memo put the binding's get on the page's
103 // critical path: 80 of the 271 slowest /r/ply pages (p99 cut 47 ms) waited 200-513 ms for it after git had finished
104 // (2a4741c0, run tail1).
105 if (defer !== null && until.value - now <= EXISTS_REFRESH_AHEAD_MS) {
106 let flying = existsFlights.get(binding);
107 if (!flying) { flying = new Set(); existsFlights.set(binding, flying); }
108 if (!flying.has(name)) {
109 flying.add(name);
110 const set = memo;
111 const started = now;
112 defer(publicRepoExists(binding, name).then(found => {
113 if (found === true) { set.delete(name); set.set(name, started + EXISTS_TTL_MS); }
114 else if (found === false) set.delete(name);
115 }).catch(() => {}).finally(() => { flying.delete(name); }));
116 }
117 }
118 return true;
119 }
120 const found = await publicRepoExists(binding, name);
121 if (found === true) {
122 memo.delete(name);
123 if (memo.size >= MAX_EXISTS_MEMO) { const first = memo.keys().next(); if (!first.done) memo.delete(first.value); }
124 memo.set(name, now + EXISTS_TTL_MS);
125 } else {
126 memo.delete(name);
127 }
128 return found;
131/** The canonical remote for a repo in the public namespace. */
132export function publicRemote(name: string, origin: string = PUBLIC_GIT_ORIGIN): string {
133 if (!isPublicRepoName(name)) throw plyError('bad_request', 'not a public repository name');
134 return `${origin}/git/${PUBLIC_NAMESPACE}/${name}.git`;
137function escapeRegExp(s: string): string {
138 return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
141const NS = escapeRegExp(PUBLIC_NAMESPACE);
142const REPO_PATH = new RegExp(`^/git/${NS}/([^/]+?)(\\.git)?$`);
143const ENDPOINT_PATH = new RegExp(`^/git/${NS}/([^/]+?)(\\.git)?/(info/refs|git-upload-pack)$`);
145/** The repo name when `raw` is exactly a public-namespace repo URL on `origin` (no trailing endpoint). */
146export function publicRepoOfRemote(raw: string, origin: string = PUBLIC_GIT_ORIGIN): string | null {
147 const path = cleanPath(raw, origin);
148 if (path === null) return null;
149 const name = captureGroup(REPO_PATH.exec(path), 1);
150 return name.tag === 'some' && isPublicRepoName(name.value) ? name.value : null;
153/**
154 * True when `raw` names any repo under the public namespace on `origin`, compared case-insensitively. Used only to
155 * refuse writes, so a case or `.git` variant that Artifacts might also resolve is refused, never allowed.
156 */
157export function isPublicNamespaceRemote(raw: string, origin: string = PUBLIC_GIT_ORIGIN): boolean {
158 let u: URL;
159 try { u = new URL(raw); } catch { return false; }
160 if (u.origin.toLowerCase() !== origin.toLowerCase()) return false;
161 return u.pathname.toLowerCase().startsWith(`/git/${PUBLIC_NAMESPACE.toLowerCase()}/`);
164// The raw path of `raw` when its origin is exactly `origin`, with no userinfo, fragment, or unsafe segment. The raw
165// string is checked before the URL parser folds `.`, `..`, or encoded separators away.
166function cleanPath(raw: string, origin: string): string | null {
167 if (typeof raw !== 'string' || raw.length > 2048) return null;
168 // oxlint-disable-next-line no-control-regex -- a URL with controls is not one we attach a credential to
169 if (/[\u0000-\u001f\u007f\s\\#]/.test(raw)) return null;
170 const rawPath = extractRequestPath(raw);
171 if (/[%@]/.test(rawPath)) return null;
172 if (rawPathHasUnsafeSegment(rawPath)) return null;
173 let u: URL;
174 try { u = new URL(raw); } catch { return null; }
175 if (u.username || u.password || u.hash) return null;
176 if (u.origin !== origin) return null;
177 // The raw string's own origin must be the canonical one too: no `HTTPS://`, no `:443`, no trailing dot.
178 if (!raw.startsWith(`${origin}/`)) return null;
179 if (u.pathname !== rawPath) return null;
180 return u.pathname;
183/**
184 * The repo name when (`method`, `raw`) is a git upload-pack exchange for a public repo: `GET …/info/refs` with exactly
185 * `?service=git-upload-pack`, or `POST …/git-upload-pack` with no query. Anything else, receive-pack included, is null.
186 */
187export function publicUploadPackRepo(method: string, raw: string, origin: string = PUBLIC_GIT_ORIGIN): string | null {
188 const path = cleanPath(raw, origin);
189 if (path === null) return null;
190 const matched = ENDPOINT_PATH.exec(path);
191 const name = captureGroup(matched, 1);
192 if (name.tag === 'none' || !isPublicRepoName(name.value)) return null;
193 const query = raw.slice(origin.length + path.length);
194 const verb = method.toUpperCase();
195 const endpoint = captureGroup(matched, 3);
196 if (endpoint.tag === 'some' && endpoint.value === 'info/refs') return verb === 'GET' && query === '?service=git-upload-pack' ? name.value : null;
197 return verb === 'POST' && query === '' ? name.value : null;
200/** The subset of the Artifacts Workers binding this module uses. `expiresAt` and repo `status` are read at runtime. */
201export type ArtifactsNamespace = {
202 get(name: string): Promise<{ createToken(scope: 'read' | 'write', ttl: number): Promise<{ plaintext: string }> } & Partial<Disposable>>;
203 list?(opts: { limit: number }): Promise<{ repos: { name: string }[] }>;
204};
206type Cached = { token: string; expiresAtMs: number };
208export type TokenSource = {
209 /** A read token for `repo` that has more than READ_TOKEN_REFRESH_S left. */
210 readToken(repo: string): Promise<string>;
211 /** Every token this isolate has minted and not yet dropped, with each string form that could be echoed. */
212 secrets(): string[];
213};
215function expiryMs(expiresAt: unknown, token: string, now: number): number {
216 if (expiresAt instanceof Date) return expiresAt.getTime();
217 if (typeof expiresAt === 'number') return expiresAt < 1e12 ? expiresAt * MS_PER_SECOND : expiresAt;
218 if (typeof expiresAt === 'string' && !Number.isNaN(Date.parse(expiresAt))) return Date.parse(expiresAt);
219 // Token format: art_v1_<40 hex>?expires=<unix seconds> (developers.cloudflare.com/artifacts/api/git-protocol).
220 const seconds = captureGroup(/[?&]expires=(\d+)/.exec(token), 1);
221 return seconds.tag === 'some' && seconds.value ? Number(seconds.value) * MS_PER_SECOND : now + READ_TOKEN_TTL_S * MS_PER_SECOND;
224function presentText(value: unknown): string {
225 const plain = chainGet(value, 'plaintext');
226 return plain.tag === 'some' ? String(plain.value) : '';
229/**
230 * Per-isolate read tokens, minted through the namespace-scoped binding. Concurrent requests for one repo share one
231 * mint. Only `createToken('read', …)` is ever called.
232 */
233export function createTokenSource(binding: ArtifactsNamespace, now: () => number = Date.now): TokenSource {
234 const cache = new Map<string, Cached>();
235 const pending = new Map<string, Promise<string>>();
236 const retired: string[] = [];
237 const mint = async (repo: string): Promise<string> => {
238 const asked = binding.get(repo);
239 asked.catch(() => {});
240 let handle: Awaited<typeof asked> | null = null;
241 try {
242 // Workers RPC promise pipelining: on the real binding get() returns an RpcPromise, and createToken called on it
243 // rides the same round trip as get (one RPC to Artifacts, not two in series). Serial, a GitCache miss from APAC
244 // paid get 243 ms + createToken 484 ms before its upstream request (trace 827ee16c…, 2a4741c0, run tail1). A plain
245 // Promise (tests, a binding without pipelining) has no createToken: wait for the handle first.
246 const piped = (asked as unknown as Record<string, unknown>)['createToken'];
247 const minted = typeof piped === 'function'
248 ? await (asked as unknown as Awaited<typeof asked>).createToken('read', READ_TOKEN_TTL_S)
249 : await (handle = await asked).createToken('read', READ_TOKEN_TTL_S);
250 const token = presentText(minted);
251 if (token.length < 8) throw plyError('upstream_5xx', 'the public namespace did not return a read token');
252 const old = cache.get(repo);
253 if (old) retired.push(old.token);
254 if (retired.length > MAX_CACHED_TOKENS) retired.splice(0, retired.length - MAX_CACHED_TOKENS);
255 if (cache.size >= MAX_CACHED_TOKENS && !cache.has(repo)) {
256 const next = cache.keys().next();
257 if (!next.done) {
258 const first = next.value;
259 const hit = mapGet(cache, first);
260 retired.push(hit.tag === 'some' ? hit.value.token : '');
261 cache.delete(first);
262 }
263 }
264 const exp = chainGet(minted, 'expiresAt');
265 cache.set(repo, { token, expiresAtMs: expiryMs(exp.tag === 'some' ? exp.value : null, token, now()) });
266 return token;
267 } finally {
268 if (handle === null) handle = await asked.catch(() => null);
269 try { if (handle !== null) releaseStub(handle); } catch { /* releasing the RPC stub is best effort */ }
270 }
271 };
272 return {
273 async readToken(repo) {
274 if (!isPublicRepoName(repo)) throw plyError('bad_request', 'not a public repository name');
275 const hit = cache.get(repo);
276 if (hit && hit.expiresAtMs - now() > READ_TOKEN_REFRESH_S * MS_PER_SECOND) return hit.token;
277 let p = pending.get(repo);
278 if (!p) {
279 p = mint(repo).finally(() => pending.delete(repo));
280 pending.set(repo, p);
281 }
282 try { return await p; }
283 catch (e) {
284 const code = thrownField(e, 'code');
285 if (code.tag === 'some' && code.value === 'upstream_5xx') throw e;
286 // binding.get throws when the repo does not exist (developers.cloudflare.com/artifacts/api/workers-binding/#getname).
287 if (/not.?found|does not exist|no such/i.test(thrownText(e))) throw plyError('not_found', `no repository ${repo} in the public namespace`, { miss: { kind: 'repository' } });
288 throw plyError('upstream_5xx', 'could not mint a read token for the public namespace');
289 }
290 },
291 secrets() {
292 const out: string[] = [];
293 for (const t of [...[...cache.values()].map(c => c.token), ...retired]) {
294 if (!t) continue;
295 const bare = unwrapOr(atIndex(t.split('?'), 0), t);
296 out.push(t, bare, btoa(`x-access-token:${t}`), btoa(`x-access-token:${bare}`), encodeURIComponent(t));
297 }
298 return out;
299 },
300 };
303// One token source per binding object, so an isolate shares its cached tokens across requests.
304const SOURCES = new WeakMap<object, TokenSource>();
306export function tokenSourceFor(binding: unknown): TokenSource | null {
307 if (binding === null || typeof binding !== 'object') return null;
308 const get = chainGet(binding, 'get');
309 if (get.tag === 'none' || typeof get.value !== 'function') return null;
310 let source = SOURCES.get(binding);
311 if (!source) { source = createTokenSource(binding as ArtifactsNamespace); SOURCES.set(binding, source); }
312 return source;
315const LIST_TTL_MS = 60_000;
316const LIST_LIMIT = 100;
317let listed: { at: number; names: string[] } | null = null;
319/** Names from `binding.list()`. `/view` and `/r/` both render this value. */
320export type PublicRepoList = {
321 names: readonly string[];
322 /** True only when `list()` threw and this isolate has no cached page to show. */
323 unavailable: boolean;
324};
326export const EMPTY_PUBLIC_REPOS: PublicRepoList = { names: [], unavailable: false };
328/**
329 * Repo names in the public namespace, cached for a minute per isolate.
330 * A missing binding or an empty namespace is an empty list, not a failure.
331 * `unavailable` is set only when the upstream `list()` call throws and nothing is cached.
332 */
333export async function listPublicRepos(binding: unknown, now: number = Date.now()): Promise<PublicRepoList> {
334 if (binding === null || typeof binding !== 'object') return EMPTY_PUBLIC_REPOS;
335 const list = chainGet(binding, 'list');
336 if (list.tag === 'none' || typeof list.value !== 'function') return EMPTY_PUBLIC_REPOS;
337 if (listed && now - listed.at < LIST_TTL_MS) return { names: listed.names, unavailable: false };
338 try {
339 const page = await (binding as { list(opts: { limit: number }): Promise<unknown> }).list({ limit: LIST_LIMIT });
340 const reposField = chainGet(page, 'repos');
341 const repos = (reposField.tag === 'none' ? [] : reposField.value) as readonly { status: unknown; name: unknown }[];
342 const names = repos.filter(r => !r.status || r.status === 'ready').map(r => String(r.name)).filter(isPublicRepoName).sort();
343 listed = { at: now, names };
344 return { names, unavailable: false };
345 } catch {
346 if (listed) return { names: listed.names, unavailable: false };
347 return { names: [], unavailable: true };
348 }
351/** Host fetch. Callers omit the second argument; this alias does not restate that parameter. */
352export type FetchLike = typeof globalThis.fetch;
354function requestUrl(input: RequestInfo | URL): string {
355 if (typeof input === 'string') return input;
356 if (input instanceof URL) return input.href;
357 return input.url;
360function methodOf(input: RequestInfo | URL, init: RequestInit | null): string {
361 const method = chainGet(init, 'method');
362 if (method.tag === 'some') return method.value as string;
363 return input instanceof Request ? input.method : 'GET';
366function headersOf(input: RequestInfo | URL, init: RequestInit | null): Headers {
367 const headers = chainGet(init, 'headers');
368 if (headers.tag === 'some') return new Headers(headers.value as HeadersInit);
369 if (input instanceof Request) return new Headers(input.headers);
370 return new Headers();
373/**
374 * The innermost fetch. When the request is a public upload-pack exchange (`publicUploadPackRepo`) and carries no
375 * Authorization of its own, it gets `Authorization: Bearer <read token>`. Every other request passes through unchanged.
376 * A caller's own credential always wins: the Worker's token is never added next to it or in place of it.
377 */
378export function withPublicReadCredential(inner: FetchLike, tokens: TokenSource | null, origin: string = PUBLIC_GIT_ORIGIN): FetchLike {
379 return async (input, init) => {
380 if (!tokens) return inner(input, init);
381 const url = requestUrl(input);
382 const given = fromNullable(init);
383 const initValue = given.tag === 'some' ? given.value : null;
384 const method = methodOf(input, initValue);
385 const repo = publicUploadPackRepo(method, url, origin);
386 if (repo === null) return inner(input, init);
387 const headers = headersOf(input, initValue);
388 if (headers.has('authorization')) return inner(input, init);
389 headers.set('authorization', `Bearer ${await tokens.readToken(repo)}`);
390 const next: RequestInit = given.tag === 'some' ? { ...given.value, method, headers } : { method, headers };
391 return inner(url, next);
392 };
395/** Removes every string form of every minted token from `text`. */
396export function scrubSecrets(secrets: readonly string[]): (text: string) => string {
397 const list = [...new Set(secrets.filter(s => typeof s === 'string' && s.length >= 8))].sort((a, b) => b.length - a.length);
398 return text => list.reduce((s, x) => s.split(x).join('[redacted]'), String(text));
Diagnostics4 git calls · 24 ms
CallStatusSizeTime024 ms
discover200152 B2 ms
git.upload-pack discover
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=ls-refs
git.upstream.dur_ms=2
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 · hit2 ms
git.upload-pack ls-refs
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=ls-refs
git.upstream.dur_ms=2
git.response.bytes=145
git.response.cache=HIT
git.response.duration_ms=2
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 1020040 KiB · hit3 ms
git.upload-pack fetch
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=fetch
git.upstream.dur_ms=3
git.response.bytes=41349
git.response.cache=HIT
git.response.duration_ms=3
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=526b305930b8ef382f2d7a1f9c0238730a585921
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=41349
git.pkt.payload.max=41254
git.sideband.band1.bytes=41253
git.sideband.band2.bytes=0
git.sideband.band3.bytes=0
git.pack.objects=61
git.pack.bytes=41253
git.pack.ofs_delta=0
git.pack.ref_delta=0
git.pack.chain.max=0
git.pack.trailer=ab60efef4b7243678c75de64a4386986ee885c1c
git.pack.full=61
Open pack map
fetch2006.8 KiB · hit19 ms
git.upload-pack fetch
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=fetch
git.upstream.dur_ms=19
git.response.bytes=7004
git.response.cache=HIT
git.response.duration_ms=19
git.fetch.wants=c123398d36b385bd32626f57c8509c1038dbf65a
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=7004
git.pkt.payload.max=6983
git.sideband.band1.bytes=6982
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-web.git
Ref
refs/heads/main
Commit
526b305930b8ef382f2d7a1f9c0238730a585921
cf-ray
a5e3025d7a1c7929
Request
6c3bb3f3…
Protocol
v2 · sha1
Agent
gitty/1.0
Filter
advertised
Fetch
shallow filter sideband-all
Capabilities
agent ls-refs fetch object-format