dtu-github-actions 0.0.0

package/dist/server/routes/artifacts.js

@@ -0,0 +1,332 @@
+import fs from "node:fs";
+import path from "node:path";
+import { state } from "../store.js";
+import { getBaseUrl } from "./dtu.js";
+import { config } from "../../config.js";
+const ARTIFACT_DIR = path.join(config.DTU_CACHE_DIR, "artifacts");
+if (!fs.existsSync(ARTIFACT_DIR)) {
+    fs.mkdirSync(ARTIFACT_DIR, { recursive: true });
+}
+const TWIRP_PREFIX = "/twirp/github.actions.results.api.v1.ArtifactService";
+export function registerArtifactRoutes(app) {
+    // ── Twirp endpoints (used by actions/upload-artifact@v4 & actions/download-artifact@v4) ──
+    // CreateArtifact — returns a signed upload URL
+    app.post(`${TWIRP_PREFIX}/CreateArtifact`, (req, res) => {
+        const { name, version } = req.body || {};
+        if (!name) {
+            res.writeHead(400, { "Content-Type": "application/json" });
+            return res.end(JSON.stringify({ msg: "Missing artifact name" }));
+        }
+        const containerId = Math.floor(Math.random() * 1000000);
+        const baseUrl = getBaseUrl(req);
+        state.pendingArtifacts.set(containerId, { name, files: new Map() });
+        console.log(`[DTU] CreateArtifact "${name}" (v${version}) → container ${containerId}`);
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({
+            ok: true,
+            signedUploadUrl: `${baseUrl}/_apis/artifactblob/${containerId}/upload`,
+        }));
+    });
+    // FinalizeArtifact — mark upload as complete
+    app.post(`${TWIRP_PREFIX}/FinalizeArtifact`, (req, res) => {
+        const { name } = req.body || {};
+        if (!name) {
+            res.writeHead(400, { "Content-Type": "application/json" });
+            return res.end(JSON.stringify({ msg: "Missing artifact name" }));
+        }
+        let foundId = null;
+        for (const [id, pending] of state.pendingArtifacts) {
+            if (pending.name === name) {
+                foundId = id;
+                break;
+            }
+        }
+        if (foundId === null) {
+            console.warn(`[DTU] FinalizeArtifact: not found "${name}"`);
+            res.writeHead(404, { "Content-Type": "application/json" });
+            return res.end(JSON.stringify({ ok: false }));
+        }
+        const pending = state.pendingArtifacts.get(foundId);
+        state.artifacts.set(name, { containerId: foundId, files: new Map(pending.files) });
+        state.pendingArtifacts.delete(foundId);
+        console.log(`[DTU] FinalizeArtifact "${name}" (container ${foundId})`);
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ ok: true, artifactId: String(foundId) }));
+    });
+    // ListArtifacts — find artifacts by name
+    app.post(`${TWIRP_PREFIX}/ListArtifacts`, (req, res) => {
+        const { nameFilter } = req.body || {};
+        const filterName = typeof nameFilter === "string" ? nameFilter : nameFilter?.value;
+        console.log(`[DTU] ListArtifacts (filter: ${filterName || "none"})`);
+        const artifacts = [];
+        for (const [name, art] of state.artifacts) {
+            if (filterName && name !== filterName) {
+                continue;
+            }
+            artifacts.push({
+                workflowRunBackendId: "00000000-0000-0000-0000-000000000001",
+                databaseId: String(art.containerId),
+                name,
+                size: String(art.files.size > 0 ? fs.statSync(Array.from(art.files.values())[0]).size : 0),
+                createdAt: new Date().toISOString(),
+            });
+        }
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ artifacts }));
+    });
+    // GetSignedArtifactURL — return a download URL for an artifact
+    app.post(`${TWIRP_PREFIX}/GetSignedArtifactURL`, (req, res) => {
+        const { name } = req.body || {};
+        const baseUrl = getBaseUrl(req);
+        const artifact = state.artifacts.get(name);
+        if (!artifact) {
+            console.warn(`[DTU] GetSignedArtifactURL: not found "${name}"`);
+            res.writeHead(404, { "Content-Type": "application/json" });
+            return res.end(JSON.stringify({ signedUrl: "" }));
+        }
+        console.log(`[DTU] GetSignedArtifactURL "${name}" → container ${artifact.containerId}`);
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({
+            signedUrl: `${baseUrl}/_apis/artifactblob/${artifact.containerId}/download`,
+        }));
+    });
+    // ── Blob endpoints (signed URL targets) ──
+    // Block storage for Azure block blob protocol
+    // @actions/artifact v4 uses: PUT ?comp=block&blockid=X (upload block) then PUT ?comp=blocklist (commit)
+    const blockStore = new Map(); // containerId → blockId → data
+    // Upload blob (PUT from signed URL) — implements Azure Block Blob protocol
+    app.put("/_apis/artifactblob/:containerId/upload", async (req, res) => {
+        const containerId = req.params.containerId;
+        const containerIdNum = parseInt(containerId, 10);
+        const comp = req.query.comp;
+        const blockId = req.query.blockid;
+        const pending = state.pendingArtifacts.get(containerIdNum);
+        if (!pending) {
+            console.warn(`[DTU] Blob upload to invalid container: ${containerId}`);
+            res.writeHead(404);
+            return res.end();
+        }
+        // Collect body (may be streaming/chunked)
+        let buffer;
+        try {
+            if (Buffer.isBuffer(req.body)) {
+                buffer = req.body;
+            }
+            else if (typeof req.body === "string") {
+                buffer = Buffer.from(req.body);
+            }
+            else {
+                const chunks = [];
+                for await (const chunk of req) {
+                    chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
+                }
+                buffer = Buffer.concat(chunks);
+            }
+        }
+        catch (e) {
+            console.error("[DTU] Failed to read blob upload body:", e);
+            res.writeHead(500);
+            return res.end();
+        }
+        if (comp === "block" && blockId) {
+            // Stage a block
+            if (!blockStore.has(containerId)) {
+                blockStore.set(containerId, new Map());
+            }
+            blockStore.get(containerId).set(blockId, buffer);
+            console.log(`[DTU] Staged block ${blockId} for container ${containerId} (${buffer.length} bytes)`);
+            res.writeHead(201);
+            return res.end();
+        }
+        if (comp === "blocklist") {
+            // Commit: assemble staged blocks in order from XML block list
+            const blocks = blockStore.get(containerId) ?? new Map();
+            const diskPath = path.join(ARTIFACT_DIR, `${containerId}_blob.zip`);
+            // Parse blockid list from XML: <Latest>blockid</Latest> entries
+            const xml = buffer.toString("utf8");
+            const ids = [];
+            for (const m of xml.matchAll(/<Latest>([^<]+)<\/Latest>/g)) {
+                ids.push(m[1]);
+            }
+            const assembled = ids.length > 0
+                ? Buffer.concat(ids.map((id) => blocks.get(id) ?? Buffer.alloc(0)))
+                : Buffer.concat(Array.from(blocks.values())); // fallback: concat all in insertion order
+            fs.writeFileSync(diskPath, assembled);
+            blockStore.delete(containerId);
+            pending.files.set("artifact.zip", diskPath);
+            console.log(`[DTU] Committed block blob for container ${containerId} (${assembled.length} bytes, ${ids.length} blocks)`);
+            res.writeHead(201);
+            return res.end();
+        }
+        // Single-block upload (no comp param) — write directly
+        const diskPath = path.join(ARTIFACT_DIR, `${containerIdNum}_blob.zip`);
+        fs.writeFileSync(diskPath, buffer);
+        pending.files.set("artifact.zip", diskPath);
+        console.log(`[DTU] Blob uploaded to container ${containerIdNum} (${buffer.length} bytes)`);
+        res.writeHead(201, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ ok: true }));
+    });
+    // Download blob (GET from signed URL)
+    app.get("/_apis/artifactblob/:containerId/download", (req, res) => {
+        const containerId = parseInt(req.params.containerId, 10);
+        let found = null;
+        for (const art of state.artifacts.values()) {
+            if (art.containerId === containerId) {
+                found = art;
+                break;
+            }
+        }
+        if (!found || found.files.size === 0) {
+            console.warn(`[DTU] Blob download: container ${containerId} not found`);
+            res.writeHead(404);
+            return res.end();
+        }
+        const diskPath = Array.from(found.files.values())[0];
+        if (!fs.existsSync(diskPath)) {
+            console.warn(`[DTU] Blob download: file missing ${diskPath}`);
+            res.writeHead(404);
+            return res.end();
+        }
+        console.log(`[DTU] Blob download from container ${containerId}`);
+        const stat = fs.statSync(diskPath);
+        res.writeHead(200, {
+            "Content-Type": "application/zip",
+            "Content-Length": stat.size,
+        });
+        fs.createReadStream(diskPath).pipe(res);
+    });
+    // ── Simple REST endpoints (used by curl-based smoke/e2e tests) ──
+    // Create artifact container
+    app.post("/_apis/artifacts", (req, res) => {
+        const { name } = req.body || {};
+        if (!name) {
+            res.writeHead(400, { "Content-Type": "application/json" });
+            return res.end(JSON.stringify({ error: "Missing artifact name" }));
+        }
+        const containerId = Math.floor(Math.random() * 1000000);
+        const baseUrl = getBaseUrl(req);
+        state.pendingArtifacts.set(containerId, { name, files: new Map() });
+        console.log(`[DTU] Created artifact container ${containerId} for "${name}"`);
+        res.writeHead(201, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({
+            containerId,
+            name,
+            fileContainerResourceUrl: `${baseUrl}/_apis/artifacts/${containerId}`,
+        }));
+    });
+    // Upload file to artifact container
+    app.put("/_apis/artifacts/:containerId", (req, res) => {
+        const containerId = parseInt(req.params.containerId, 10);
+        const itemPath = req.query.itemPath || "artifact.bin";
+        const pending = state.pendingArtifacts.get(containerId);
+        if (!pending) {
+            console.warn(`[DTU] Artifact upload to invalid container: ${containerId}`);
+            res.writeHead(404);
+            return res.end();
+        }
+        console.log(`[DTU] Uploading artifact file "${itemPath}" to container ${containerId}`);
+        const diskPath = path.join(ARTIFACT_DIR, `${containerId}_${path.basename(itemPath)}`);
+        try {
+            if (Buffer.isBuffer(req.body) || typeof req.body === "string") {
+                const buffer = Buffer.isBuffer(req.body) ? req.body : Buffer.from(req.body);
+                fs.writeFileSync(diskPath, buffer);
+            }
+            else {
+                res.writeHead(500, { "Content-Type": "text/plain" });
+                return res.end("Expected raw buffer/string body");
+            }
+            pending.files.set(itemPath, diskPath);
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ ok: true }));
+        }
+        catch (e) {
+            console.error("[DTU] Failed to write artifact file:", e);
+            res.writeHead(500);
+            res.end();
+        }
+    });
+    // Finalize artifact
+    app.patch("/_apis/artifacts", (req, res) => {
+        const { artifactName } = req.body || {};
+        if (!artifactName) {
+            res.writeHead(400, { "Content-Type": "application/json" });
+            return res.end(JSON.stringify({ error: "Missing artifactName" }));
+        }
+        let foundId = null;
+        for (const [id, pending] of state.pendingArtifacts) {
+            if (pending.name === artifactName) {
+                foundId = id;
+                break;
+            }
+        }
+        if (foundId === null) {
+            console.warn(`[DTU] Finalize artifact not found: "${artifactName}"`);
+            res.writeHead(404);
+            return res.end();
+        }
+        const pending = state.pendingArtifacts.get(foundId);
+        state.artifacts.set(artifactName, {
+            containerId: foundId,
+            files: new Map(pending.files),
+        });
+        state.pendingArtifacts.delete(foundId);
+        console.log(`[DTU] Finalized artifact "${artifactName}" (container ${foundId}, ${pending.files.size} file(s))`);
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ ok: true, containerId: foundId }));
+    });
+    // List / get artifact by name
+    app.get("/_apis/artifacts", (req, res) => {
+        const artifactName = req.query.artifactName;
+        const baseUrl = getBaseUrl(req);
+        if (artifactName) {
+            const artifact = state.artifacts.get(artifactName);
+            if (!artifact) {
+                res.writeHead(200, { "Content-Type": "application/json" });
+                return res.end(JSON.stringify({ count: 0, value: [] }));
+            }
+            res.writeHead(200, { "Content-Type": "application/json" });
+            return res.end(JSON.stringify({
+                count: 1,
+                value: [
+                    {
+                        containerId: artifact.containerId,
+                        name: artifactName,
+                        fileContainerResourceUrl: `${baseUrl}/_apis/artifactfiles/${artifact.containerId}`,
+                    },
+                ],
+            }));
+        }
+        const value = Array.from(state.artifacts.entries()).map(([name, art]) => ({
+            containerId: art.containerId,
+            name,
+            fileContainerResourceUrl: `${baseUrl}/_apis/artifactfiles/${art.containerId}`,
+        }));
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ count: value.length, value }));
+    });
+    // Download artifact file (REST)
+    app.get("/_apis/artifactfiles/:containerId", (req, res) => {
+        const containerId = parseInt(req.params.containerId, 10);
+        let found = null;
+        for (const art of state.artifacts.values()) {
+            if (art.containerId === containerId) {
+                found = art;
+                break;
+            }
+        }
+        if (!found || found.files.size === 0) {
+            res.writeHead(404);
+            return res.end();
+        }
+        const [, diskPath] = Array.from(found.files.entries())[0];
+        if (!fs.existsSync(diskPath)) {
+            res.writeHead(404);
+            return res.end();
+        }
+        res.writeHead(200, {
+            "Content-Type": "application/octet-stream",
+            "Content-Length": fs.statSync(diskPath).size,
+        });
+        fs.createReadStream(diskPath).pipe(res);
+    });
+}

package/dist/server/routes/cache.d.ts

@@ -0,0 +1,2 @@
+import { Polka } from "polka";
+export declare function registerCacheRoutes(app: Polka): void;

package/dist/server/routes/cache.js

@@ -0,0 +1,230 @@
+import fs from "node:fs";
+import path from "node:path";
+import { execSync } from "node:child_process";
+import { state } from "../store.js";
+import { getBaseUrl } from "./dtu.js";
+import { config } from "../../config.js";
+// Ensure DTU has a temp dir for caching
+const CACHE_DIR = config.DTU_CACHE_DIR;
+if (!fs.existsSync(CACHE_DIR)) {
+    fs.mkdirSync(CACHE_DIR, { recursive: true });
+}
+// Pre-built empty tar.gz to serve as a synthetic cache hit for virtual keys.
+// The runner downloads it, extracts nothing, and marks the key as a primary hit
+// (so it skips the save step entirely). This avoids 60+ seconds of unnecessary
+// gzip compression for bind-mounted paths like the pnpm store.
+const EMPTY_TAR_GZ_PATH = path.join(CACHE_DIR, "__empty__.tar.gz");
+if (!fs.existsSync(EMPTY_TAR_GZ_PATH)) {
+    execSync(`tar -czf ${EMPTY_TAR_GZ_PATH} -T /dev/null`);
+}
+const VIRTUAL_CACHE_ID = 0; // sentinel ID for virtual (no-op) caches
+export function registerCacheRoutes(app) {
+    // 1. Check if cache exists
+    const checkCacheHandler = (req, res) => {
+        const keys = (req.query.keys || "").split(",").map((k) => k.trim());
+        const version = req.query.version;
+        console.log(`[DTU] Checking cache for keys: ${keys.join(", ")} (version: ${version})`);
+        for (const key of keys) {
+            if (!key) {
+                continue;
+            }
+            // Virtual key: bind-mounted path already on disk — return a synthetic hit
+            // so the runner skips both the tar extraction and the tar save.
+            if (state.isVirtualCacheKey(key)) {
+                console.log(`[DTU] Virtual cache hit for key: ${key} (skip tar)`);
+                res.writeHead(200, { "Content-Type": "application/json" });
+                return res.end(JSON.stringify({
+                    result: "hit",
+                    archiveLocation: `${getBaseUrl(req)}/_apis/artifactcache/artifacts/${VIRTUAL_CACHE_ID}`,
+                    cacheKey: key,
+                }));
+            }
+            const entry = state.caches.get(key);
+            if (entry && entry.version === version) {
+                // Validate archive file still exists on disk
+                const cacheIdMatch = entry.archiveLocation.match(/artifacts\/(\d+)/);
+                if (cacheIdMatch) {
+                    const filePath = path.join(CACHE_DIR, `cache_${cacheIdMatch[1]}.tar.gz`);
+                    if (!fs.existsSync(filePath)) {
+                        console.warn(`[DTU] Evicting stale cache "${key}" — file missing: ${filePath}`);
+                        state.caches.delete(key);
+                        state.saveCachesToDisk();
+                        continue;
+                    }
+                }
+                console.log(`[DTU] Cache hit for key: ${key}`);
+                // Construct archiveLocation dynamically from the current request so stale
+                // hostnames persisted in caches.json don't cause download failures.
+                const archiveLocation = cacheIdMatch
+                    ? `${getBaseUrl(req)}/_apis/artifactcache/artifacts/${cacheIdMatch[1]}`
+                    : entry.archiveLocation;
+                res.writeHead(200, { "Content-Type": "application/json" });
+                return res.end(JSON.stringify({
+                    result: "hit",
+                    archiveLocation,
+                    cacheKey: key,
+                }));
+            }
+        }
+        console.log(`[DTU] Cache miss for keys: ${keys.join(", ")}`);
+        res.writeHead(204);
+        res.end();
+    };
+    app.get("/_apis/artifactcache/caches", checkCacheHandler);
+    app.get("/_apis/artifactcache/cache", checkCacheHandler);
+    // 2. Reserve cache space (create pending cache)
+    app.post("/_apis/artifactcache/caches", (req, res) => {
+        const { key, version } = req.body;
+        console.log(`[DTU] Reserving cache for key: ${key} (version: ${version})`);
+        // Virtual key: acknowledge immediately without touching disk
+        if (state.isVirtualCacheKey(key)) {
+            console.log(`[DTU] Virtual cache reservation for key: ${key} — no-op`);
+            res.writeHead(201, { "Content-Type": "application/json" });
+            return res.end(JSON.stringify({ cacheId: VIRTUAL_CACHE_ID }));
+        }
+        // Immutable: reject if this key+version is already cached (committed)
+        const existing = state.caches.get(key);
+        if (existing && existing.version === version) {
+            console.log(`[DTU] Cache already exists for key: ${key} — skipping reservation`);
+            res.writeHead(409, { "Content-Type": "application/json" });
+            return res.end(JSON.stringify({ message: "Cache already exists" }));
+        }
+        // Also reject if another job has already reserved this key+version (in-flight)
+        // This prevents multiple parallel jobs from all winning a reservation for the
+        // same cache key, generating redundant tar processes and orphaned temp files.
+        for (const [, pending] of state.pendingCaches) {
+            if (pending.key === key && pending.version === version) {
+                console.log(`[DTU] Cache reservation in-flight for key: ${key} — another job is already saving it`);
+                res.writeHead(409, { "Content-Type": "application/json" });
+                return res.end(JSON.stringify({ message: "Cache already exists" }));
+            }
+        }
+        // Assign a unique cache ID
+        const cacheId = Math.floor(Math.random() * 1000000);
+        const tempPath = path.join(CACHE_DIR, `temp_${cacheId}.tar.gz`);
+        fs.writeFileSync(tempPath, ""); // create an empty file
+        state.pendingCaches.set(cacheId, { tempPath, key, version });
+        res.writeHead(201, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ cacheId }));
+    });
+    // 3. Upload cache chunk
+    app.patch("/_apis/artifactcache/caches/:cacheId", (req, res) => {
+        const cacheId = parseInt(req.params.cacheId, 10);
+        // Virtual cache ID: discard the upload entirely — we don't need the archive
+        if (cacheId === VIRTUAL_CACHE_ID) {
+            res.writeHead(200);
+            return res.end();
+        }
+        const pending = state.pendingCaches.get(cacheId);
+        if (!pending) {
+            console.warn(`[DTU] Cache upload to invalid ID: ${cacheId}`);
+            res.writeHead(404);
+            return res.end();
+        }
+        const contentRange = req.headers["content-range"];
+        console.log(`[DTU] Uploading cache chunk to ID ${cacheId}, Content-Range: ${contentRange}`);
+        let startOffset = -1;
+        if (contentRange && typeof contentRange === "string") {
+            const match = contentRange.match(/bytes (\d+)-/);
+            if (match) {
+                startOffset = parseInt(match[1], 10);
+            }
+        }
+        try {
+            if (Buffer.isBuffer(req.body) || typeof req.body === "string") {
+                const buffer = Buffer.isBuffer(req.body) ? req.body : Buffer.from(req.body);
+                if (startOffset >= 0) {
+                    const fd = fs.openSync(pending.tempPath, "r+");
+                    fs.writeSync(fd, buffer, 0, buffer.length, startOffset);
+                    fs.closeSync(fd);
+                }
+                else {
+                    fs.appendFileSync(pending.tempPath, buffer);
+                }
+            }
+            else {
+                res.writeHead(500, { "Content-Type": "text/plain" });
+                return res.end("Expected raw buffer/string body");
+            }
+            res.writeHead(200);
+            res.end();
+        }
+        catch (e) {
+            console.error("[DTU] Failed to write cache chunk:", e);
+            res.writeHead(500);
+            res.end();
+        }
+    });
+    // 4. Commit cache
+    app.post("/_apis/artifactcache/caches/:cacheId", (req, res) => {
+        const cacheId = parseInt(req.params.cacheId, 10);
+        // Virtual cache ID: no-op commit
+        if (cacheId === VIRTUAL_CACHE_ID) {
+            res.writeHead(200);
+            return res.end();
+        }
+        const { size } = req.body || { size: 0 };
+        const pending = state.pendingCaches.get(cacheId);
+        if (!pending) {
+            console.warn(`[DTU] Cache commit to invalid ID: ${cacheId}`);
+            res.writeHead(404);
+            return res.end();
+        }
+        console.log(`[DTU] Committing cache ID ${cacheId} (key: ${pending.key})`);
+        // Delete old archive if this key already existed (prevents orphaned files)
+        const oldEntry = state.caches.get(pending.key);
+        if (oldEntry) {
+            const oldMatch = oldEntry.archiveLocation.match(/artifacts\/(\d+)/);
+            if (oldMatch) {
+                const oldPath = path.join(CACHE_DIR, `cache_${oldMatch[1]}.tar.gz`);
+                try {
+                    fs.unlinkSync(oldPath);
+                    console.log(`[DTU] Deleted old cache file: ${oldPath}`);
+                }
+                catch {
+                    // File may already be gone
+                }
+            }
+        }
+        const finalPath = path.join(CACHE_DIR, `cache_${cacheId}.tar.gz`);
+        fs.renameSync(pending.tempPath, finalPath);
+        const baseUrl = getBaseUrl(req);
+        const archiveLocation = `${baseUrl}/_apis/artifactcache/artifacts/${cacheId}`;
+        state.caches.set(pending.key, {
+            version: pending.version,
+            archiveLocation,
+            size,
+        });
+        state.saveCachesToDisk();
+        state.pendingCaches.delete(cacheId);
+        res.writeHead(200);
+        res.end();
+    });
+    // 5. Download cache archive
+    app.get("/_apis/artifactcache/artifacts/:cacheId", (req, res) => {
+        const cacheId = parseInt(req.params.cacheId, 10);
+        // Virtual sentinel: serve the empty tar.gz
+        if (cacheId === VIRTUAL_CACHE_ID) {
+            res.writeHead(200, {
+                "Content-Type": "application/octet-stream",
+                "Content-Disposition": 'attachment; filename="cache.tar.gz"',
+                "Content-Length": fs.statSync(EMPTY_TAR_GZ_PATH).size,
+            });
+            return fs.createReadStream(EMPTY_TAR_GZ_PATH).pipe(res);
+        }
+        const filePath = path.join(CACHE_DIR, `cache_${cacheId}.tar.gz`);
+        if (!fs.existsSync(filePath)) {
+            console.warn(`[DTU] Cache artifact not found: ${cacheId}`);
+            res.writeHead(404);
+            return res.end();
+        }
+        console.log(`[DTU] Downloading cache ID ${cacheId}`);
+        res.writeHead(200, {
+            "Content-Type": "application/octet-stream",
+            "Content-Disposition": `attachment; filename="cache_${cacheId}.tar.gz"`,
+            "Content-Length": fs.statSync(filePath).size,
+        });
+        const readStream = fs.createReadStream(filePath);
+        readStream.pipe(res);
+    });
+}

package/dist/server/routes/cache.test.d.ts

@@ -0,0 +1 @@
+export {};