@openwf/cli 0.1.0

package/lib.js

@@ -0,0 +1,116 @@
+const fs = require("node:fs");
+
+const getVersions = async () => {
+	if (!fs.existsSync("manifests/versions.html")) {
+		await fs.promises.mkdir("manifests", { recursive: true });
+		await fs.promises.writeFile("manifests/versions.html", await (await fetch("https://about.openwf.io/versions")).text(), "utf-8");
+	}
+	const tableRegex = /<tr id="(?<id>[0-9\.]+)"(?<attributes>[^>]*)>[^<]+<td><code>[^<]+(?:<!--[^<]+)?<\/code><\/td>[^<]+<td>(?:.|&lt;)&nbsp;(?<near>[^<]+)<\/td>/gu;
+	const attributesRegex = /data-(?<key>[^=]+)="(?<value>[^"]+)"/gu;
+	const str = fs.readFileSync("manifests/versions.html", "utf-8");
+	const versions = [];
+	for (let version; version = tableRegex.exec(str)?.groups; ) {
+		const attributesString = version.attributes;
+		version.attributes = {};
+		for (let attribute; attribute = attributesRegex.exec(attributesString)?.groups; ) {
+			version.attributes[attribute.key.replaceAll("-", "_")] = attribute.value;
+		}
+		versions.push(version);
+	}
+	return versions;
+};
+
+const getVersionType = (version) => {
+	if (version.attributes.magnet) {
+		if (version.attributes.base_manifest) {
+			return "patch";
+		} else {
+			if (version.attributes.langs) {
+				return "dirty";
+			} else {
+				return "cafee";
+			}
+		}
+	} else {
+		return "steam";
+	}
+};
+
+const getShortId = (version) => {
+	if (!version.attributes.magnet) {
+		return version.near + "-steam";
+	}
+	return version.id;
+};
+
+const downloadFile = async (url, out) => {
+	const { Readable } = require("node:stream");
+	const { body } = await fetch(url);
+	await fs.promises.writeFile(out, Readable.fromWeb(body));
+};
+
+const downloadFileFromMega = async (url, out) => {
+	const { File } = await import("megajs");
+	const file = File.fromURL(url);
+	await file.loadAttributes();
+	//console.log(`Downloading ${file.name}...`);
+	const data = await file.downloadBuffer();
+	await fs.promises.writeFile(out, data);
+};
+
+// For single-file torrents, downloadDir is the folder that contains the file.
+const verifyLocalTorrentDownload = (torrentFilePath, downloadDir) => {
+	return new Promise(resolve => {
+		const nt = require("nt");
+		nt.read(torrentFilePath, (_err, torrent) => {
+			const hasher = torrent.hashCheck(downloadDir);
+			let p;
+			hasher.on("match", (i, hash, percent) => {
+				p = percent;
+			});
+			hasher.on("end", () => {
+				resolve(p == 100);
+			});
+		});
+	});
+};
+
+const downloadUpdatePatch = async (version, btConsent) => {
+	const params = new URLSearchParams(new URL(version.attributes.magnet).search);
+	const torrentFilePath = `depot/${params.get("dn")}.torrent`;
+	if (!fs.existsSync(torrentFilePath)) {
+		const torrentFileUrl = `https://about.openwf.io/supplementals/torrents/patches/${params.get("dn")}.torrent`;
+		await fs.promises.mkdir("depot", { recursive: true });
+		await downloadFile(torrentFileUrl, torrentFilePath);
+	}
+	let needToDownload = !fs.existsSync(`depot/${params.get("dn")}`);
+	while (true) {
+		if (needToDownload) {
+			if (btConsent) {
+				const WebTorrent = (await import("webtorrent")).default;
+				await new Promise(resolve => {
+					const client = new WebTorrent();
+					client.add(torrentFilePath, { path: "depot" }, torrent => {
+						torrent.on("done", () => {
+							client.destroy();
+							resolve(`depot/${params.get("dn")}`);
+						});
+					});
+				});
+			} else {
+				//await downloadFile(params.get("ws"), `depot/${params.get("dn")}`);
+				await downloadFileFromMega(version.attributes.mega, `depot/${params.get("dn")}`);
+			}
+		}
+		if (await verifyLocalTorrentDownload(torrentFilePath, "depot")) {
+			return `depot/${params.get("dn")}`;
+		}
+		if (needToDownload) {
+			// This was a fresh download, no point in retrying.
+			throw new Error(`Failed to download ${magnetUri}`);
+		}
+		needToDownload = true;
+	}
+};
+
+module.exports = { getVersions, getVersionType, getShortId, downloadFile, downloadFileFromMega, verifyLocalTorrentDownload, downloadUpdatePatch };

package/openwf.js

@@ -0,0 +1,137 @@
+#!/usr/bin/env node
+
+const tool = process.argv[2];
+switch (tool) {
+	default: {
+		console.error("Syntax: openwf <download|install> <version>");
+		process.exit(1);
+	} break;
+
+	case "download": case "install": {
+		(async () => {
+			let target = process.argv[3];
+			if (!target) {
+				console.log(`Syntax: openwf ${tool} <version>`);
+				process.exit(1);
+			}
+
+			const fs = require("node:fs");
+			const { getVersions, getVersionType, getShortId, downloadFile, downloadUpdatePatch } = require("./lib.js");
+
+			let isFresh = !fs.existsSync("manifests/versions.html");
+			if (isFresh) {
+				console.log("Downloading versions list...");
+			}
+			let versions = await getVersions();
+			let version;
+			while (true) {
+				version = versions.find(version => getShortId(version) == target);
+				if (!version) {
+					version = versions.find(version => version.near == target);
+					if (version) {
+						target = getShortId(version);
+						console.log(`Assuming you meant ${target}`);
+					}
+				}
+				if (version || isFresh) {
+					break;
+				}
+				console.log("Refreshing versions list...");
+				await fs.promises.unlink("manifests/versions.html");
+				versions = await getVersions();
+				isFresh = true;
+			}
+			if (!version) {
+				console.log(`Unknown version: ${target}`);
+				process.exit(1);
+			}
+			const type = getVersionType(version);
+
+			let btConsent = false;
+			if (type != "steam") {
+				const yesno = require("yesno");
+				btConsent = await yesno({
+					question: "Would it be okay to use peer-to-peer networking (BitTorrent) for faster downloads? [Y/n]",
+					defaultValue: true
+				})
+			}
+
+			if (type == "steam" || type == "patch") {
+				const ContentManifest = require("lean-and-mean-steam-user/components/content_manifest");
+				const { fetchManifest, fetchDepotKey, downloadAndInstall, DEFAULT_HOSTS }  = require("steam-manifest-tools");
+
+				console.log(`Fetching manifest...`);
+				const manifestId = type == "patch" ? version.attributes.base_manifest : version.id;
+				const manifest = ContentManifest.parse(await fetchManifest("230411", manifestId));
+
+				console.log(`Fetching depot key...`);
+				let depotKey = await fetchDepotKey(manifest.depot_id);
+				depotKey = Buffer.from(depotKey, "hex");
+
+				let remaining_chunks;
+				await fs.promises.mkdir("install", { recursive: true });
+				await downloadAndInstall(
+					manifest,
+					depotKey,
+					(num_chunks) => {
+						remaining_chunks = num_chunks;
+						if (remaining_chunks == 0) {
+							console.log("Unpacking...");
+						}
+					},
+					(path, host) => { console.log(`${path}: Downloading from ${host}`); },
+					(path, status, host) => {
+						console.log(`${path}: Got ${status}`);
+						if (status == 200 && --remaining_chunks == 0) {
+							console.log("Unpacking...");
+						}
+					},
+					(path, err) => { console.log(`${path}: `, err); },
+					DEFAULT_HOSTS,
+					`install/${target}`
+				);
+			} else {
+				console.log(`Version type (${type}) not yet supported.`);
+				process.exit(1);
+			}
+			if (type == "patch") {
+				console.log("Fetching update patch...");
+				const patchArchivePath = await downloadUpdatePatch(version, btConsent);
+
+				console.log("Applying update patch...");
+				const sz = require("7zip-min");
+				await sz.unpackSome(patchArchivePath, [target], "install");
+			}
+			if (tool == "install") {
+				console.log("Downloading Bootstrapper manifest...");
+				const meta = await (await fetch("https://openwf.io/supplementals/client%20drop-in/meta")).json();
+
+				console.log(meta.hotfix ? `Downloading Bootstrapper v${meta.version} ${meta.hotfix}...` : `Downloading Bootstrapper v${meta.version}...`);
+				const gameMajor = parseInt(version.near.split(".")[0]);
+				const dllName = gameMajor >= 29 ? "dwmapi.dll" : "wtsapi32.dll";
+				await downloadFile(`https://openwf.io/supplementals/client%20drop-in/${meta.version}/dwmapi.dll`, `install/${target}/${dllName}`);
+				if (meta.hotfix) {
+					await fs.promises.mkdir(`install/${target}/OpenWF`, { recursive: true });
+					await downloadFile(`https://openwf.io/supplementals/client%20drop-in/${meta.version}/${meta.hotfix}/Hotfix.owf`, `install/${target}/OpenWF/Hotfix.owf`);
+				}
+
+				if (type != "patch" && gameMajor >= 38 && process.platform == "win32") {
+					if (!fs.existsSync(`install/${target}/OpenWF/sideloadify-cli.cache`)) {
+						console.log("Downloading sideloadify-cli...");
+						await downloadFile("https://github.com/Sainan/Sideloadify/releases/download/1.1.0/sideloadify-cli.exe", `install/${target}/OpenWF/sideloadify-cli.cache`);
+					}
+					await fs.promises.mkdir(`install/${target}/OpenWF`, { recursive: true });
+					await fs.promises.rename(`install/${target}/OpenWF/sideloadify-cli.cache`, `install/${target}/OpenWF/sideloadify-cli.exe`);
+					await new Promise(resolve => {
+						const { spawn } = require("node:child_process");
+						const ps = spawn(`install/${target}/OpenWF/sideloadify-cli.exe`, [`install/${target}/Warframe.x64.exe`], { stdio: "inherit" });
+						ps.on("close", resolve);
+					});
+					await fs.promises.rename(`install/${target}/OpenWF/sideloadify-cli.exe`, `install/${target}/OpenWF/sideloadify-cli.cache`);
+				}
+			}
+			console.log("All done.");
+			process.exit(0);
+		})();
+	} break;
+}

package/package.json

@@ -0,0 +1,21 @@
+{
+	"name": "@openwf/cli",
+	"version": "0.1.0",
+	"main": "lib.js",
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/Sainan/owf-npm.git"
+	},
+	"bin": {
+		"openwf": "openwf.js"
+	},
+	"dependencies": {
+		"7zip-min": "^3.0.1",
+		"lean-and-mean-steam-user": "^0.1.0",
+		"megajs": "^1.3.10",
+		"nt": "^0.7.1",
+		"steam-manifest-tools": "^0.1.11",
+		"webtorrent": "^2.3.0",
+		"yesno": "^0.4.0"
+	}
+}