claudeup 4.37.0 → 4.38.0

package/src/services/community-fetcher.ts

@@ -0,0 +1,90 @@
+/**
+ * community-fetcher.ts — the one thing in the community-styles feature that
+ * knows `fetch` exists.
+ *
+ * ## Why a port at all
+ *
+ * Exactly one boundary gets an interface: the network. The domain here is thin,
+ * and an interface-per-class reflex would be waste — so there is no Strategy
+ * registry, no adapter factory, and nothing else in the feature is abstracted.
+ * The gain is the one the constraints demand: no test can reach GitHub, because
+ * every exported function in `community-styles.ts` takes a `StyleFetcher` as a
+ * REQUIRED argument. Omitting it is a type error, not a forgotten mock.
+ *
+ * ## Why it does not speak `Response`
+ *
+ * The classic way a port leaks its adapter. A `Response` drags in streaming
+ * semantics, a body that can only be read once, and a `fetch`-shaped mental
+ * model into every test fake. `{ status, body, etag }` is what the caller
+ * actually uses.
+ *
+ * `headers` is the one deliberate exception. `github-budget.ts` parses
+ * `retry-after` / `x-ratelimit-reset` / `x-ratelimit-remaining` itself, and it
+ * is the module that knows the two hosts differ in what they report. Re-deriving
+ * that here would fork the rate-limit logic, which is precisely what §5.3 of the
+ * design forbids. A fake supplies `new Headers({...})`, which is a standard
+ * built-in, not a fetch import.
+ */
+
+/** What the application needs from an HTTP response. Never a `Response`. */
+export interface StyleFetchResponse {
+	status: number;
+	/** Empty for a 304 and for any status with no body. */
+	body: string;
+	etag: string | null;
+	contentType: string | null;
+	/** Handed to `github-budget` unchanged — see the header note. */
+	headers: Headers;
+}
+
+export type StyleFetcher = (
+	url: string,
+	opts?: { etag?: string | null; timeoutMs?: number; accept?: string },
+) => Promise<StyleFetchResponse>;
+
+/**
+ * 10s, matching `marketplace-fetcher.ts`. A style is a few kilobytes over a CDN
+ * — measured at ~340ms — so anything past ten seconds is a broken route rather
+ * than a slow one, and the user is waiting on a keypress they just made.
+ */
+export const FETCH_TIMEOUT_MS = 10_000;
+
+/**
+ * The real adapter. Wraps global `fetch` and nothing more: no retry, no
+ * classification, no budget check. Those are policy and belong in the service,
+ * where they can be tested without a network.
+ *
+ * Sends `GITHUB_TOKEN` / `GITHUB_PERSONAL_ACCESS_TOKEN` to `api.github.com`
+ * ONLY — exactly as `skills-manager.ts` already does. The token raises that
+ * host's 60/hr unauthenticated budget to 5000/hr and is the documented escape
+ * hatch when the advisory says the budget is spent. It is never sent to
+ * `raw.githubusercontent.com`, which needs no auth and would receive a
+ * credential it has no business seeing.
+ */
+export const githubFetcher: StyleFetcher = async (url, opts = {}) => {
+	const headers: Record<string, string> = {
+		accept: opts.accept ?? "text/plain, */*",
+		"user-agent": "claudeup",
+	};
+	if (opts.etag) headers["if-none-match"] = opts.etag;
+
+	if (new URL(url).hostname === "api.github.com") {
+		const token =
+			process.env.GITHUB_TOKEN || process.env.GITHUB_PERSONAL_ACCESS_TOKEN;
+		if (token) headers.authorization = `Bearer ${token}`;
+	}
+
+	const response = await fetch(url, {
+		headers,
+		signal: AbortSignal.timeout(opts.timeoutMs ?? FETCH_TIMEOUT_MS),
+	});
+
+	return {
+		status: response.status,
+		// 304 carries no body; reading it is still safe and yields "".
+		body: response.status === 304 ? "" : await response.text(),
+		etag: response.headers.get("etag"),
+		contentType: response.headers.get("content-type"),
+		headers: response.headers,
+	};
+};