@skydiveai/git-cache 0.1.0-beta.1480 → 0.1.0-beta.1635

package/dist/cli.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { f as startServer } from "./server-B5u5DETT.mjs";
+import { f as startServer } from "./server-DfaJ_V9K.mjs";
 //#region src/cli.ts
 /**
 * `git-cache` CLI — the published binary for @skydiveai/git-cache.

package/dist/index.d.mts

@@ -19,6 +19,8 @@ declare function metricsSnapshot(): {
   evictions: number;
   refresh_failures: number;
   refresh_deferred: number;
+  revalidations: number;
+  revalidate_failures: number;
   publish_deferred: number;
   credential_url_redirects: number;
   lfs_redirects: number;

package/dist/index.mjs

@@ -1,2 +1,2 @@
-import { a as isProtocolV2Request, c as parseAdvertisement, d as shouldBackfillAfterPassthrough, f as startServer, i as explainRejection, l as parseUpstream, n as classifyUploadRequest, o as metricsSnapshot, r as copyRequestHeaders, s as mirrorHasObjects, t as SidebandPackExtractor, u as recordColdBuildOutcome } from "./server-B5u5DETT.mjs";
+import { a as isProtocolV2Request, c as parseAdvertisement, d as shouldBackfillAfterPassthrough, f as startServer, i as explainRejection, l as parseUpstream, n as classifyUploadRequest, o as metricsSnapshot, r as copyRequestHeaders, s as mirrorHasObjects, t as SidebandPackExtractor, u as recordColdBuildOutcome } from "./server-DfaJ_V9K.mjs";
 export { SidebandPackExtractor, classifyUploadRequest, copyRequestHeaders, explainRejection, isProtocolV2Request, metricsSnapshot, mirrorHasObjects, parseAdvertisement, parseUpstream, recordColdBuildOutcome, shouldBackfillAfterPassthrough, startServer };

package/dist/{server-B5u5DETT.mjs → server-DfaJ_V9K.mjs}

@@ -116,6 +116,8 @@ const metrics = {
 	evictions: 0,
 	refresh_failures: 0,
 	refresh_deferred: 0,
+	revalidations: 0,
+	revalidate_failures: 0,
 	publish_deferred: 0,
 	credential_url_redirects: 0,
 	lfs_redirects: 0,
@@ -1311,7 +1313,27 @@ async function refreshMirror(repo, local, credHeader = null) {
 	log("info", "refresh", { repo });
 	return local;
 }
-async function ensureWarm(repo, credHeader = null) {
+/**
+* Decide how to serve a warm mirror for one request.
+*
+* `revalidateRefs` is set for the `info/refs` half of a fetch — the ref
+* advertisement, where the client learns the remote's HEAD and branch tips.
+* That answer must never be stale: serving a pre-merge advertisement is how a
+* `git fetch` right after an upstream squash-merge silently returns the old
+* `origin/<branch>` (the object-reuse win of the cache is not worth lying about
+* where HEAD is). So for `info/refs` a stale mirror BLOCKS on a synchronous
+* refresh before it answers, exactly as an explicit push invalidation does.
+* The `git-upload-pack` half keeps stale-while-revalidate: its wants come from
+* the just-served fresh advertisement, so the client only asks for objects the
+* fresh refs named, and the caller's `mirrorHasObjects` gate already falls back
+* to origin for any the mirror is missing (the new objects a merge introduced).
+*
+* A blocked refresh that FAILS (network blip, expired token, upstream 5xx)
+* returns `cacheState: 'STALE_REVALIDATE_FAILED'` rather than throwing, so the
+* caller can proxy `info/refs` straight to origin — fresh refs from upstream,
+* never a 502 and never the stale advertisement.
+*/
+async function ensureWarm(repo, credHeader = null, revalidateRefs = false) {
 	const local = localPath(repo);
 	const lastFetchMs = (await readMeta(local))?.lastFetchMs ?? 0;
 	if (!((Date.now() - lastFetchMs) / 1e3 >= config.ttlSeconds || lastFetchMs < invalidateBeforeMs)) {
@@ -1321,7 +1343,8 @@ async function ensureWarm(repo, credHeader = null) {
 			cacheState: "HIT"
 		};
 	}
-	const mustBlock = lastFetchMs < invalidateBeforeMs;
+	const fencedByPush = lastFetchMs < invalidateBeforeMs;
+	const mustBlock = fencedByPush || revalidateRefs;
 	if (!inflightRefresh.has(repo)) inflightRefresh.set(repo, withRepoLock(repo, "write", () => refreshMirror(repo, local, credHeader)).then((result) => {
 		if (result === null) {
 			metrics.refresh_deferred++;
@@ -1336,7 +1359,19 @@ async function ensureWarm(repo, credHeader = null) {
 	}).finally(() => inflightRefresh.delete(repo)));
 	if (mustBlock) {
 		await inflightRefresh.get(repo);
-		if (((await readMeta(local))?.lastFetchMs ?? 0) < invalidateBeforeMs) throw new Error("mirror refresh failed after push invalidation");
+		const refreshedMs = (await readMeta(local))?.lastFetchMs ?? 0;
+		if (!(refreshedMs >= invalidateBeforeMs && (Date.now() - refreshedMs) / 1e3 < config.ttlSeconds)) {
+			if (revalidateRefs && !fencedByPush) {
+				metrics.revalidate_failures++;
+				log("warn", "revalidate_failed", { repo });
+				return {
+					local,
+					cacheState: "STALE_REVALIDATE_FAILED"
+				};
+			}
+			throw new Error("mirror refresh failed after invalidation");
+		}
+		if (revalidateRefs) metrics.revalidations++;
 		return {
 			local,
 			cacheState: "REFRESH"
@@ -1610,6 +1645,42 @@ function isLoopbackPeer(req) {
 	const addr = req.socket.remoteAddress;
 	return addr === "127.0.0.1" || addr === "::1" || addr === "::ffff:127.0.0.1";
 }
+/**
+* Proxy an `info/refs` advertisement straight to origin and stream it back to
+* the client, retaining a bounded copy of a v0 advertisement for later ref
+* completion. Used for a cold miss AND when a warm mirror's blocking
+* revalidation failed — either way the client gets a FRESH advertisement from
+* upstream, never the mirror's stale refs.
+*/
+async function proxyInfoRefs(req, res, repo, upstreamUrl, host, credHeader) {
+	const cred = credHeader ?? await fetchCredentialHeader(host);
+	await new Promise((resolve, reject) => {
+		openUpstream(req, upstreamUrl, "info/refs", (upRes, error) => {
+			if (error) {
+				reject(error);
+				return;
+			}
+			if (upRes.statusCode === 401 || upRes.statusCode === 403) dropCredential(host);
+			res.writeHead(upRes.statusCode, upRes.headers);
+			const chunks = [];
+			let bytes = 0;
+			const CAP = 32 * 1024 * 1024;
+			upRes.on("data", (chunk) => {
+				res.write(chunk);
+				if (bytes < CAP) {
+					chunks.push(chunk);
+					bytes += chunk.length;
+				}
+			});
+			upRes.on("end", () => {
+				res.end();
+				if (upRes.statusCode === 200 && bytes < CAP && gitProtocolEnv(req.headers).GIT_PROTOCOL === void 0) advertisements.set(repo, parseAdvertisement(Buffer.concat(chunks)));
+				resolve();
+			});
+			upRes.on("error", reject);
+		}, cred);
+	});
+}
 async function handle(req, res) {
 	const parsed = new URL(req.url, "http://git-cache.local");
 	if (parsed.pathname === "/healthz") {
@@ -1685,7 +1756,7 @@ async function handle(req, res) {
 			}
 			clientCred = raw;
 		}
-		const host = up.repo.split("/")[0];
+		const host = up.repo.split("/")[0] ?? "";
 		let uploadBody = null;
 		let uploadWants = [];
 		if (up.operation === "git-upload-pack") {
@@ -1706,8 +1777,16 @@ async function handle(req, res) {
 			uploadWants = classifyUploadRequest(uploadBody).wants;
 		}
 		if (await pathExists(localPath(up.repo))) {
-			const warm = await ensureWarm(up.repo, clientCred);
+			const warm = await ensureWarm(up.repo, clientCred, up.operation === "info/refs");
 			markServed(warm.local);
+			if (warm.cacheState === "STALE_REVALIDATE_FAILED") {
+				log("info", "serve", {
+					repo: up.repo,
+					op: up.operation,
+					state: warm.cacheState
+				});
+				return proxyInfoRefs(req, res, up.repo, up.upstreamUrl, host, clientCred);
+			}
 			if (up.operation === "git-upload-pack" && !await mirrorHasObjects(warm.local, uploadWants)) {
 				await refreshMirror(up.repo, warm.local, clientCred).catch((error) => {
 					metrics.refresh_failures++;
@@ -1730,35 +1809,7 @@ async function handle(req, res) {
 			});
 			return serveUploadPack(req, res, warm.local, up.operation === "info/refs", warm.cacheState, uploadBody);
 		}
-		if (up.operation === "info/refs") {
-			const credHeader = clientCred ?? await fetchCredentialHeader(host);
-			return await new Promise((resolve, reject) => {
-				openUpstream(req, up.upstreamUrl, up.operation, (upRes, error) => {
-					if (error) {
-						reject(error);
-						return;
-					}
-					if (upRes.statusCode === 401 || upRes.statusCode === 403) dropCredential(host);
-					res.writeHead(upRes.statusCode, upRes.headers);
-					const chunks = [];
-					let bytes = 0;
-					const CAP = 32 * 1024 * 1024;
-					upRes.on("data", (chunk) => {
-						res.write(chunk);
-						if (bytes < CAP) {
-							chunks.push(chunk);
-							bytes += chunk.length;
-						}
-					});
-					upRes.on("end", () => {
-						res.end();
-						if (upRes.statusCode === 200 && bytes < CAP && gitProtocolEnv(req.headers).GIT_PROTOCOL === void 0) advertisements.set(up.repo, parseAdvertisement(Buffer.concat(chunks)));
-						resolve(void 0);
-					});
-					upRes.on("error", reject);
-				}, credHeader);
-			});
-		}
+		if (up.operation === "info/refs") return proxyInfoRefs(req, res, up.repo, up.upstreamUrl, host, clientCred);
 		const body = uploadBody ?? Buffer.alloc(0);
 		const credHeader = clientCred ?? await fetchCredentialHeader(host);
 		if (coldLeaders.has(up.repo)) return proxyColdFollowerWithBody(res, up.upstreamUrl, req.headers, body, up.repo, credHeader);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@skydiveai/git-cache",
-  "version": "0.1.0-beta.1480",
+  "version": "0.1.0-beta.1635",
   "description": "Sandbox-local Git smart-HTTP clone/fetch cache: a loopback daemon that transparently mirrors HTTPS git reads so repeated clone/fetch/ls-remote skip the origin round-trip. Runs inside an agent sandbox; pushes stay direct.",
   "homepage": "https://skydive.com",
   "license": "MIT",