fix: return 404 for non-existent tags instead of rendering broken page

Previously, requesting ?tag=not-exists would render the download page
with broken download links because buildReleaseFromTag blindly
constructed URLs. Now fetchRelease distinguishes GitHub 404 (tag doesn't
exist) from other errors (rate limit, server error), and getRelease
returns null on confirmed 404 — skipping the fallback chain.

Also adds negative caching for 404 tags, Cache-Control: no-store on
HTML responses, and JSON.stringify for Cloudflare Workers console.log.

Author: fengmk2

routes/index.ts

@@ -55,18 +55,20 @@ async function fetchGitHub(path: string, githubToken: string | undefined): Promi
   return fetch(`https://api.github.com${path}`, { headers });
 }
 
-async function fetchRelease(
+// "not-found" means the tag definitively doesn't exist (GitHub 404).
+// null means the API failed (rate limit, network error) — fallbacks may still work.
+export async function fetchRelease(
   tag: string | undefined,
   githubToken: string | undefined,
-): Promise<GitHubRelease | null> {
+): Promise<GitHubRelease | null | "not-found"> {
   if (tag) {
     const res = await fetchGitHub(
       `/repos/${GITHUB_OWNER}/${GITHUB_REPO}/releases/tags/${tag}`,
       githubToken,
     );
     if (!res.ok) {
       console.error(`GitHub API error: ${res.status} ${res.statusText} for tag ${tag}`);
-      return null;
+      return res.status === 404 ? "not-found" : null;
     }
     return (await res.json()) as GitHubRelease;
   }
@@ -83,7 +85,7 @@ async function fetchRelease(
   const releases = (await res.json()) as GitHubRelease[];
   console.log(
     "GitHub releases:",
-    releases.map((r) => ({ tag: r.tag_name, assets: r.assets.map((a) => a.name) })),
+    JSON.stringify(releases.map((r) => ({ tag: r.tag_name, assets: r.assets.map((a) => a.name) }))),
   );
   return (
     releases.find((r) =>
@@ -144,6 +146,11 @@ async function getRelease(
 
   try {
     const release = await fetchRelease(tag, githubToken);
+    if (release === "not-found") {
+      // Cache the negative result to avoid repeated API calls for the same bad tag
+      await kv.put(key, null, { ttl: LATEST_CACHE_TTL });
+      return null;
+    }
     if (release) {
       const parsed = parseRelease(release);
       if (parsed) {
@@ -328,5 +335,5 @@ export const GET = defineHandler(async (c) => {
   if (!release) {
     return c.json({ error: tag ? `Release '${tag}' not found` : "No release found" }, 404);
   }
-  return c.html(renderDownloadPage(release));
+  return c.html(renderDownloadPage(release), { headers: { "Cache-Control": "no-store" } });
 });

tests/index.test.ts

@@ -1,5 +1,5 @@
-import { describe, expect, it } from "vite-plus/test";
-import { buildReleaseFromTag, detectArch, parseRelease } from "../routes/index";
+import { afterEach, describe, expect, it, vi } from "vite-plus/test";
+import { buildReleaseFromTag, detectArch, fetchRelease, parseRelease } from "../routes/index";
 
 describe("detectArch", () => {
   it("defaults to x64 when no query param or user-agent", () => {
@@ -133,3 +133,61 @@ describe("buildReleaseFromTag", () => {
     });
   });
 });
+
+describe("fetchRelease", () => {
+  afterEach(() => vi.unstubAllGlobals());
+
+  it('returns "not-found" when GitHub returns 404 for a tag', async () => {
+    vi.stubGlobal(
+      "fetch",
+      vi
+        .fn()
+        .mockResolvedValue(new Response("Not Found", { status: 404, statusText: "Not Found" })),
+    );
+    const result = await fetchRelease("not-exists", undefined);
+    expect(result).toBe("not-found");
+  });
+
+  it("returns null when GitHub returns 403 (rate limited) for a tag", async () => {
+    vi.stubGlobal(
+      "fetch",
+      vi
+        .fn()
+        .mockResolvedValue(new Response("Forbidden", { status: 403, statusText: "Forbidden" })),
+    );
+    const result = await fetchRelease("v1.0.0", undefined);
+    expect(result).toBeNull();
+  });
+
+  it("returns null when GitHub returns 500 for a tag", async () => {
+    vi.stubGlobal(
+      "fetch",
+      vi.fn().mockResolvedValue(
+        new Response("Internal Server Error", {
+          status: 500,
+          statusText: "Internal Server Error",
+        }),
+      ),
+    );
+    const result = await fetchRelease("v1.0.0", undefined);
+    expect(result).toBeNull();
+  });
+
+  it("returns the release when GitHub returns 200 for a tag", async () => {
+    const release = {
+      tag_name: "v1.0.0",
+      assets: [
+        {
+          name: "vp-setup-x86_64-pc-windows-msvc.exe",
+          browser_download_url: "https://example.com/x64.exe",
+        },
+      ],
+    };
+    vi.stubGlobal(
+      "fetch",
+      vi.fn().mockResolvedValue(new Response(JSON.stringify(release), { status: 200 })),
+    );
+    const result = await fetchRelease("v1.0.0", undefined);
+    expect(result).toEqual(release);
+  });
+});