120 lines
3.2 KiB
TypeScript
120 lines
3.2 KiB
TypeScript
import { modpackManifest } from "#globals";
|
|
import { FORGE_MAVEN, getForgeJar, getVersionManifest } from "#utils/util.ts";
|
|
import unzip from "unzipper";
|
|
import { ForgeProfile } from "#types/forgeProfile.ts";
|
|
import { sha1 } from "hash-wasm";
|
|
import { fetchFileInfo } from "#utils/curseForgeAPI.ts";
|
|
import fs from "fs";
|
|
import upath from "upath";
|
|
import buildConfig from "#buildConfig";
|
|
import logInfo from "#utils/log.ts";
|
|
|
|
/**
|
|
* Download the Forge jar.
|
|
*
|
|
* This is basically a carbon copy of the server Forge-fetching task,
|
|
* except we only download/fetch the Forge jar and enumerate the libraries it has.
|
|
*/
|
|
async function getForgeURLs() {
|
|
const { forgeJar, forgeInstallerPath } = await getForgeJar();
|
|
|
|
/**
|
|
* Parse the profile manifest.
|
|
*/
|
|
let forgeProfile: ForgeProfile | undefined = undefined;
|
|
const files = (await unzip.Open.buffer(forgeJar))?.files;
|
|
|
|
if (!files) {
|
|
throw new Error("Malformed Forge installation jar.");
|
|
}
|
|
|
|
for (const file of files) {
|
|
// Look for the installation profile.
|
|
if (!forgeProfile && file.path == "version.json") {
|
|
forgeProfile = JSON.parse((await file.buffer()).toString());
|
|
}
|
|
}
|
|
|
|
if (!forgeProfile || !forgeProfile.libraries) {
|
|
throw new Error("Malformed Forge installation profile.");
|
|
}
|
|
|
|
/**
|
|
* Finally, fetch libraries.
|
|
*/
|
|
const libraries = forgeProfile.libraries.filter((x) =>
|
|
Boolean(x?.downloads?.artifact?.url),
|
|
);
|
|
|
|
return [
|
|
FORGE_MAVEN + forgeInstallerPath,
|
|
...libraries.map((library) => library.downloads.artifact.url),
|
|
];
|
|
}
|
|
|
|
/**
|
|
* Removes ALL files from the cache directory that haven't been accessed during this run.
|
|
*/
|
|
export default async function pruneCache(): Promise<void> {
|
|
const urls = [];
|
|
|
|
// Push Forge URLs.
|
|
urls.push(...(await getForgeURLs()).map((url) => url));
|
|
|
|
// Fetch file infos.
|
|
const fileInfos = await Promise.all(
|
|
modpackManifest.files.map(async (file) =>
|
|
fetchFileInfo(file.projectID, file.fileID),
|
|
),
|
|
);
|
|
urls.push(...fileInfos.map((fileInfo) => fileInfo.downloadUrl));
|
|
|
|
// Fetch the Minecraft server.
|
|
const versionManifest = await getVersionManifest(
|
|
modpackManifest.minecraft.version,
|
|
);
|
|
if (!versionManifest) {
|
|
throw new Error(`No manifest found for Minecraft ${versionManifest}`);
|
|
}
|
|
urls.push(versionManifest.downloads.server.url);
|
|
|
|
// Push external dependencies.
|
|
if (modpackManifest.externalDependencies) {
|
|
urls.push(...modpackManifest.externalDependencies.map((dep) => dep.url));
|
|
}
|
|
|
|
const cache = (
|
|
await fs.promises.readdir(buildConfig.downloaderCacheDirectory)
|
|
).filter((entity) =>
|
|
fs
|
|
.statSync(upath.join(buildConfig.downloaderCacheDirectory, entity))
|
|
.isFile(),
|
|
);
|
|
|
|
const shaMap: { [key: string]: boolean } = {};
|
|
const hashes = await Promise.all(urls.map((url) => sha1(url)));
|
|
for (const hash of hashes) {
|
|
shaMap[hash] = true;
|
|
}
|
|
|
|
let count = 0;
|
|
let bytes = 0;
|
|
|
|
for (const sha of cache) {
|
|
if (!shaMap[sha]) {
|
|
const path = upath.join(buildConfig.downloaderCacheDirectory, sha);
|
|
const stat = fs.existsSync(path) ? await fs.promises.stat(path) : null;
|
|
|
|
if (stat && stat.isFile()) {
|
|
count += 1;
|
|
bytes += stat.size;
|
|
logInfo(`Pruning ${sha}...`);
|
|
|
|
await fs.promises.unlink(path);
|
|
}
|
|
}
|
|
}
|
|
|
|
logInfo(`Pruned ${count} files (${(bytes / 1024 / 1024).toFixed(3)} MiB)`);
|
|
}
|