mirror of
https://github.com/daydreamer-json/ak-endfield-api-archive.git
synced 2026-03-22 07:12:28 +01:00
751 lines
25 KiB
TypeScript
751 lines
25 KiB
TypeScript
import path from 'node:path';
|
|
import { Octokit } from '@octokit/rest';
|
|
import ky, { HTTPError } from 'ky';
|
|
import { DateTime } from 'luxon';
|
|
import PQueue from 'p-queue';
|
|
import semver from 'semver';
|
|
import YAML from 'yaml';
|
|
import apiUtils from '../utils/api/index.js';
|
|
import argvUtils from '../utils/argv.js';
|
|
import appConfig from '../utils/config.js';
|
|
import githubUtils from '../utils/github.js';
|
|
import logger from '../utils/logger.js';
|
|
import mathUtils from '../utils/math.js';
|
|
import stringUtils from '../utils/string.js';
|
|
|
|
// Types
|
|
type LatestGameResponse = Awaited<ReturnType<typeof apiUtils.akEndfield.launcher.latestGame>>;
|
|
type LatestGameResourcesResponse = Awaited<ReturnType<typeof apiUtils.akEndfield.launcher.latestGameResources>>;
|
|
|
|
interface StoredData<T> {
|
|
req: any;
|
|
rsp: T;
|
|
updatedAt: string;
|
|
}
|
|
|
|
interface GameTarget {
|
|
name: string;
|
|
region: 'os' | 'cn';
|
|
appCode: string;
|
|
launcherAppCode: string;
|
|
channel: number;
|
|
subChannel: number;
|
|
launcherSubChannel: number;
|
|
dirName: string;
|
|
}
|
|
|
|
interface LauncherTarget {
|
|
id: 'os' | 'cn';
|
|
apps: ('EndField' | 'Arknights' | 'Official')[];
|
|
code: string;
|
|
channel: number;
|
|
}
|
|
|
|
interface MirrorFileEntry {
|
|
orig: string;
|
|
mirror: string;
|
|
origStatus: boolean;
|
|
}
|
|
|
|
interface AssetToMirror {
|
|
url: string;
|
|
name: string | null;
|
|
}
|
|
|
|
// Global/Shared State
|
|
let githubAuthCfg: any = null;
|
|
let octoClient: Octokit | null = null;
|
|
const assetsToMirror: AssetToMirror[] = [];
|
|
const networkQueue = new PQueue({ concurrency: appConfig.threadCount.network });
|
|
|
|
// Constants
|
|
const diffIgnoreRules = [
|
|
['rsp', 'pkg', 'url'],
|
|
['rsp', 'pkg', 'packs', '*', 'url'],
|
|
['rsp', 'patch', 'url'],
|
|
['rsp', 'patch', 'patches', '*', 'url'],
|
|
['rsp', 'zip_package_url'],
|
|
['rsp', 'exe_url'],
|
|
].map((path) => ({ path, pattern: /[?&]auth_key=[^&]+/g }));
|
|
|
|
// Utilities
|
|
const formatBytes = (size: number) =>
|
|
mathUtils.formatFileSize(size, {
|
|
decimals: 2,
|
|
decimalPadding: true,
|
|
unitVisible: true,
|
|
useBinaryUnit: true,
|
|
useBitUnit: false,
|
|
unit: null,
|
|
});
|
|
|
|
function getObjectDiff(
|
|
obj1: any,
|
|
obj2: any,
|
|
ignoreRules: { path: string[]; pattern: RegExp }[] = [],
|
|
currentPath: string[] = [],
|
|
) {
|
|
const diff: any = {};
|
|
const keys = new Set([...Object.keys(obj1 || {}), ...Object.keys(obj2 || {})]);
|
|
|
|
for (const key of keys) {
|
|
const val1 = obj1?.[key];
|
|
const val2 = obj2?.[key];
|
|
const fullPath = [...currentPath, key];
|
|
if (JSON.stringify(val1) === JSON.stringify(val2)) continue;
|
|
|
|
const rule = ignoreRules.find(
|
|
(r) => r.path.length === fullPath.length && r.path.every((p, i) => p === '*' || p === fullPath[i]),
|
|
);
|
|
|
|
if (rule && typeof val1 === 'string' && typeof val2 === 'string') {
|
|
const normalized1 = val1.replace(rule.pattern, '');
|
|
const normalized2 = val2.replace(rule.pattern, '');
|
|
if (normalized1 === normalized2) continue;
|
|
}
|
|
|
|
if (typeof val1 === 'object' && val1 !== null && typeof val2 === 'object' && val2 !== null) {
|
|
const nestedDiff = getObjectDiff(val1, val2, ignoreRules, fullPath);
|
|
if (Object.keys(nestedDiff).length > 0) diff[key] = nestedDiff;
|
|
} else {
|
|
diff[key] = { old: val1, new: val2 };
|
|
}
|
|
}
|
|
return diff;
|
|
}
|
|
|
|
async function saveResultWithHistory<T>(
|
|
subPaths: string[],
|
|
version: string | null,
|
|
data: { req: any; rsp: T },
|
|
options: {
|
|
saveLatest?: boolean;
|
|
ignoreRules?: typeof diffIgnoreRules;
|
|
allFileName?: string;
|
|
} = {},
|
|
) {
|
|
const { saveLatest = true, ignoreRules = [], allFileName = 'all.json' } = options;
|
|
const outputDir = argvUtils.getArgv()['outputDir'];
|
|
const filePathBase = path.join(outputDir, ...subPaths);
|
|
const dataStr = JSON.stringify(data, null, 2);
|
|
|
|
// 1. Save v{version}.json and latest.json if changed
|
|
const filesToCheck: string[] = [];
|
|
if (version) filesToCheck.push(path.join(filePathBase, `v${version}.json`));
|
|
if (saveLatest) filesToCheck.push(path.join(filePathBase, 'latest.json'));
|
|
|
|
for (const filePath of filesToCheck) {
|
|
const file = Bun.file(filePath);
|
|
if (!(await file.exists())) {
|
|
await Bun.write(filePath, dataStr);
|
|
} else {
|
|
const currentData = await file.json();
|
|
const diff = getObjectDiff(currentData, data, ignoreRules);
|
|
if (Object.keys(diff).length > 0) {
|
|
logger.trace(`Diff detected in ${filePath}:`, JSON.stringify(diff, null, 2));
|
|
await Bun.write(filePath, dataStr);
|
|
}
|
|
}
|
|
}
|
|
|
|
// 2. Update all.json history
|
|
const allFilePath = path.join(filePathBase, allFileName);
|
|
const allFile = Bun.file(allFilePath);
|
|
let allData: StoredData<T>[] = (await allFile.exists()) ? await allFile.json() : [];
|
|
|
|
const exists = allData.some((e) => {
|
|
const diff = getObjectDiff({ req: e.req, rsp: e.rsp }, data, ignoreRules);
|
|
return Object.keys(diff).length === 0;
|
|
});
|
|
|
|
if (!exists) {
|
|
allData.push({ updatedAt: DateTime.now().toISO(), ...data });
|
|
await Bun.write(allFilePath, JSON.stringify(allData, null, 2));
|
|
return true; // was updated
|
|
}
|
|
return false;
|
|
}
|
|
|
|
function queueAssetForMirroring(url: string, name: string | null = null) {
|
|
assetsToMirror.push({ url, name });
|
|
}
|
|
|
|
// Core Fetching Logic
|
|
async function fetchAndSaveLatestGames(gameTargets: GameTarget[]) {
|
|
logger.debug('Fetching latestGame ...');
|
|
for (const target of gameTargets) {
|
|
const rsp = await apiUtils.akEndfield.launcher.latestGame(
|
|
target.appCode,
|
|
target.launcherAppCode,
|
|
target.channel,
|
|
target.subChannel,
|
|
target.launcherSubChannel,
|
|
null,
|
|
target.region,
|
|
);
|
|
logger.info(
|
|
`Fetched latestGame: ${target.region.toUpperCase()}, ${target.name}, v${rsp.version}, ${formatBytes(
|
|
parseInt(rsp.pkg.total_size) - mathUtils.arrayTotal(rsp.pkg.packs.map((e) => parseInt(e.package_size))),
|
|
)}`,
|
|
);
|
|
|
|
const prettyRsp = {
|
|
req: {
|
|
appCode: target.appCode,
|
|
launcherAppCode: target.launcherAppCode,
|
|
channel: target.channel,
|
|
subChannel: target.subChannel,
|
|
launcherSubChannel: target.launcherSubChannel,
|
|
},
|
|
rsp,
|
|
};
|
|
|
|
const subChns = appConfig.network.api.akEndfield.subChannel;
|
|
if ([subChns.cnWinRel, subChns.cnWinRelBilibili, subChns.osWinRel].includes(target.subChannel)) {
|
|
if (rsp.pkg.url) queueAssetForMirroring(rsp.pkg.url);
|
|
rsp.pkg.packs.forEach((e) => queueAssetForMirroring(e.url));
|
|
}
|
|
|
|
await saveResultWithHistory(['akEndfield', 'launcher', 'game', target.dirName], rsp.version, prettyRsp, {
|
|
ignoreRules: diffIgnoreRules,
|
|
});
|
|
}
|
|
}
|
|
|
|
async function fetchAndSaveLatestGamePatches(gameTargets: GameTarget[]) {
|
|
logger.debug('Fetching latestGamePatch ...');
|
|
for (const target of gameTargets) {
|
|
const gameAllPath = path.join(
|
|
argvUtils.getArgv()['outputDir'],
|
|
'akEndfield',
|
|
'launcher',
|
|
'game',
|
|
target.dirName,
|
|
'all.json',
|
|
);
|
|
if (!(await Bun.file(gameAllPath).exists())) continue;
|
|
|
|
const gameAll = (await Bun.file(gameAllPath).json()) as StoredData<LatestGameResponse>[];
|
|
const patchAllPath = path.join(
|
|
argvUtils.getArgv()['outputDir'],
|
|
'akEndfield',
|
|
'launcher',
|
|
'game',
|
|
target.dirName,
|
|
'all_patch.json',
|
|
);
|
|
let patchAll: StoredData<LatestGameResponse>[] = (await Bun.file(patchAllPath).exists())
|
|
? await Bun.file(patchAllPath).json()
|
|
: [];
|
|
|
|
const versionList = [...new Set(gameAll.map((e) => e.rsp.version))].sort((a, b) => semver.compare(b, a)).slice(1);
|
|
let needWrite = false;
|
|
|
|
for (const ver of versionList) {
|
|
networkQueue.add(async () => {
|
|
const rsp = await apiUtils.akEndfield.launcher.latestGame(
|
|
target.appCode,
|
|
target.launcherAppCode,
|
|
target.channel,
|
|
target.subChannel,
|
|
target.launcherSubChannel,
|
|
ver,
|
|
target.region,
|
|
);
|
|
if (!rsp.patch) return;
|
|
|
|
const prettyRsp = {
|
|
req: {
|
|
appCode: target.appCode,
|
|
launcherAppCode: target.launcherAppCode,
|
|
channel: target.channel,
|
|
subChannel: target.subChannel,
|
|
launcherSubChannel: target.launcherSubChannel,
|
|
version: ver,
|
|
},
|
|
rsp,
|
|
};
|
|
|
|
const exists = patchAll.some(
|
|
(e) => Object.keys(getObjectDiff({ req: e.req, rsp: e.rsp }, prettyRsp, diffIgnoreRules)).length === 0,
|
|
);
|
|
|
|
if (!exists) {
|
|
logger.debug(
|
|
`Fetched latestGamePatch: ${target.region.toUpperCase()}, ${target.name}, v${rsp.request_version} -> v${rsp.version}, ${formatBytes(parseInt(rsp.patch.total_size) - parseInt(rsp.patch.package_size))}`,
|
|
);
|
|
patchAll.push({ updatedAt: DateTime.now().toISO(), ...prettyRsp });
|
|
needWrite = true;
|
|
|
|
const subChns = appConfig.network.api.akEndfield.subChannel;
|
|
if ([subChns.cnWinRel, subChns.cnWinRelBilibili, subChns.osWinRel].includes(target.subChannel)) {
|
|
queueAssetForMirroring(
|
|
rsp.patch.url,
|
|
new URL(rsp.patch.url).pathname.split('/').filter(Boolean).slice(-3).join('_'),
|
|
);
|
|
rsp.patch.patches.forEach((e) => queueAssetForMirroring(e.url));
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
await networkQueue.onIdle();
|
|
|
|
if (needWrite) {
|
|
await Bun.write(patchAllPath, JSON.stringify(patchAll, null, 2));
|
|
}
|
|
}
|
|
}
|
|
|
|
async function fetchAndSaveLatestGameResources(gameTargets: GameTarget[]) {
|
|
logger.debug('Fetching latestGameRes ...');
|
|
const platforms = ['Windows', 'Android', 'iOS', 'PlayStation'] as const;
|
|
const subChns = appConfig.network.api.akEndfield.subChannel;
|
|
|
|
const filteredTargets = gameTargets.filter(
|
|
(t) => t.channel !== appConfig.network.api.akEndfield.channel.cnWinRelBilibili,
|
|
);
|
|
const uniqueTargets = Array.from(
|
|
new Set(filteredTargets.map((t) => JSON.stringify({ region: t.region, appCode: t.appCode, channel: t.channel }))),
|
|
).map((s) => JSON.parse(s));
|
|
|
|
for (const target of uniqueTargets) {
|
|
const gameAllPath = path.join(
|
|
argvUtils.getArgv()['outputDir'],
|
|
'akEndfield',
|
|
'launcher',
|
|
'game',
|
|
String(target.channel),
|
|
'all.json',
|
|
);
|
|
if (!(await Bun.file(gameAllPath).exists())) continue;
|
|
|
|
const versionInfos = ((await Bun.file(gameAllPath).json()) as StoredData<LatestGameResponse>[])
|
|
.map((e) => e.rsp)
|
|
.map((r) => ({
|
|
version: r.version,
|
|
versionMinor: `${semver.major(r.version)}.${semver.minor(r.version)}`,
|
|
randStr: /_([^/]+)\/.+?$/.exec(r.pkg.file_path)?.[1] || '',
|
|
}))
|
|
.sort((a, b) => semver.compare(b.version, a.version));
|
|
|
|
for (const platform of platforms) {
|
|
let isLatestWrote = false;
|
|
for (const vInfo of versionInfos) {
|
|
if (!vInfo.randStr) throw new Error('version rand_str not found');
|
|
const rsp = await apiUtils.akEndfield.launcher.latestGameResources(
|
|
target.appCode,
|
|
vInfo.versionMinor,
|
|
vInfo.version,
|
|
vInfo.randStr,
|
|
platform,
|
|
target.region,
|
|
);
|
|
logger.info(
|
|
`Fetched latestGameRes: ${target.region.toUpperCase()}, ${platform}, v${vInfo.version}, ${rsp.res_version}`,
|
|
);
|
|
|
|
const prettyRsp = {
|
|
req: {
|
|
appCode: target.appCode,
|
|
gameVersion: vInfo.versionMinor,
|
|
version: vInfo.version,
|
|
randStr: vInfo.randStr,
|
|
platform,
|
|
},
|
|
rsp,
|
|
};
|
|
|
|
await saveResultWithHistory(
|
|
['akEndfield', 'launcher', 'game_resources', String(target.channel), platform],
|
|
vInfo.version,
|
|
prettyRsp,
|
|
{
|
|
saveLatest: !isLatestWrote,
|
|
},
|
|
);
|
|
isLatestWrote = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
async function fetchAndSaveAllGameResRawData(gameTargets: GameTarget[]) {
|
|
logger.debug('Fetching raw game resources ...');
|
|
const platforms = ['Windows', 'Android', 'iOS', 'PlayStation'] as const;
|
|
const filteredTargets = gameTargets.filter(
|
|
(t) => t.channel !== appConfig.network.api.akEndfield.channel.cnWinRelBilibili,
|
|
);
|
|
const uniqueTargets = Array.from(
|
|
new Set(filteredTargets.map((t) => JSON.stringify({ region: t.region, appCode: t.appCode, channel: t.channel }))),
|
|
).map((s) => JSON.parse(s));
|
|
|
|
const needDlRaw: { name: string; version: string; path: string }[] = [];
|
|
for (const target of uniqueTargets) {
|
|
for (const platform of platforms) {
|
|
const resAllPath = path.join(
|
|
argvUtils.getArgv()['outputDir'],
|
|
'akEndfield',
|
|
'launcher',
|
|
'game_resources',
|
|
String(target.channel),
|
|
platform,
|
|
'all.json',
|
|
);
|
|
if (await Bun.file(resAllPath).exists()) {
|
|
const resAll = (await Bun.file(resAllPath).json()) as StoredData<LatestGameResourcesResponse>[];
|
|
resAll.forEach((e) => needDlRaw.push(...e.rsp.resources));
|
|
}
|
|
}
|
|
}
|
|
|
|
const uniqueRaw = [...new Map(needDlRaw.map((item) => [item.path, item])).values()];
|
|
const wroteFiles: string[] = [];
|
|
|
|
for (const raw of uniqueRaw) {
|
|
const fileNames = raw.name.includes('main')
|
|
? ['index_main.json', 'patch.json']
|
|
: raw.name.includes('initial')
|
|
? ['index_initial.json', 'patch.json']
|
|
: ['index_main.json', 'index_initial.json', 'patch.json'];
|
|
|
|
for (const fName of fileNames) {
|
|
networkQueue.add(async () => {
|
|
const urlObj = new URL(`${raw.path}/${fName}`);
|
|
urlObj.search = '';
|
|
const localPath = path.join(
|
|
argvUtils.getArgv()['outputDir'],
|
|
'raw',
|
|
urlObj.hostname,
|
|
...urlObj.pathname.split('/').filter(Boolean),
|
|
);
|
|
|
|
if (!(await Bun.file(localPath).exists())) {
|
|
try {
|
|
const rsp = await ky
|
|
.get(urlObj.href, {
|
|
headers: { 'User-Agent': appConfig.network.userAgent.minimum },
|
|
timeout: appConfig.network.timeout,
|
|
retry: { limit: appConfig.network.retryCount },
|
|
})
|
|
.bytes();
|
|
await Bun.write(localPath, rsp);
|
|
wroteFiles.push(localPath);
|
|
} catch (err) {
|
|
if (!(err instanceof HTTPError && (err.response.status === 404 || err.response.status === 403))) throw err;
|
|
}
|
|
}
|
|
});
|
|
}
|
|
}
|
|
|
|
{
|
|
const urlSet: Set<string> = new Set();
|
|
const infileBasePath: string = path.join(argvUtils.getArgv()['outputDir'], 'akEndfield', 'launcher', 'web');
|
|
for (const target of gameTargets) {
|
|
for (const lang of apiUtils.akEndfield.defaultSettings.launcherWebLang) {
|
|
{
|
|
const allPath = path.join(infileBasePath, String(target.subChannel), 'banner', lang, 'all.json');
|
|
if (await Bun.file(allPath).exists()) {
|
|
const data: StoredData<Awaited<ReturnType<typeof apiUtils.akEndfield.launcherWeb.banner>>>[] =
|
|
await Bun.file(allPath).json();
|
|
for (const dataEntry of data) {
|
|
if (!dataEntry.rsp) continue;
|
|
dataEntry.rsp.banners.forEach((e) => urlSet.add(e.url));
|
|
}
|
|
}
|
|
}
|
|
{
|
|
const allPath = path.join(infileBasePath, String(target.subChannel), 'main_bg_image', lang, 'all.json');
|
|
if (await Bun.file(allPath).exists()) {
|
|
const data: StoredData<Awaited<ReturnType<typeof apiUtils.akEndfield.launcherWeb.mainBgImage>>>[] =
|
|
await Bun.file(allPath).json();
|
|
for (const dataEntry of data) {
|
|
if (!dataEntry.rsp) continue;
|
|
urlSet.add(dataEntry.rsp.main_bg_image.url);
|
|
if (dataEntry.rsp.main_bg_image.video_url) urlSet.add(dataEntry.rsp.main_bg_image.video_url);
|
|
}
|
|
}
|
|
}
|
|
{
|
|
const allPath = path.join(infileBasePath, String(target.subChannel), 'sidebar', lang, 'all.json');
|
|
if (await Bun.file(allPath).exists()) {
|
|
const data: StoredData<Awaited<ReturnType<typeof apiUtils.akEndfield.launcherWeb.sidebar>>>[] =
|
|
await Bun.file(allPath).json();
|
|
for (const dataEntry of data) {
|
|
if (!dataEntry.rsp) continue;
|
|
dataEntry.rsp.sidebars.forEach((e) => {
|
|
if (e.pic !== null && e.pic.url) urlSet.add(e.pic.url);
|
|
});
|
|
}
|
|
}
|
|
}
|
|
{
|
|
const allPath = path.join(infileBasePath, String(target.subChannel), 'single_ent', lang, 'all.json');
|
|
if (await Bun.file(allPath).exists()) {
|
|
const data: StoredData<Awaited<ReturnType<typeof apiUtils.akEndfield.launcherWeb.singleEnt>>>[] =
|
|
await Bun.file(allPath).json();
|
|
for (const dataEntry of data) {
|
|
if (!dataEntry.rsp) continue;
|
|
[dataEntry.rsp.single_ent.version_url].forEach((e) => {
|
|
if (e) urlSet.add(e);
|
|
});
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
for (const url of [...urlSet]) {
|
|
networkQueue.add(async () => {
|
|
const urlObj = new URL(url);
|
|
urlObj.search = '';
|
|
const localPath = path.join(
|
|
argvUtils.getArgv()['outputDir'],
|
|
'raw',
|
|
urlObj.hostname,
|
|
...urlObj.pathname.split('/').filter(Boolean),
|
|
);
|
|
|
|
if (!(await Bun.file(localPath).exists())) {
|
|
try {
|
|
const rsp = await ky
|
|
.get(urlObj.href, {
|
|
headers: { 'User-Agent': appConfig.network.userAgent.minimum },
|
|
timeout: appConfig.network.timeout,
|
|
retry: { limit: appConfig.network.retryCount },
|
|
})
|
|
.bytes();
|
|
await Bun.write(localPath, rsp);
|
|
wroteFiles.push(localPath);
|
|
} catch (err) {
|
|
if (!(err instanceof HTTPError && (err.response.status === 404 || err.response.status === 403))) throw err;
|
|
}
|
|
}
|
|
});
|
|
}
|
|
}
|
|
|
|
await networkQueue.onIdle();
|
|
logger.info(`Fetched raw game resources: ${wroteFiles.length} files`);
|
|
}
|
|
|
|
async function fetchAndSaveLatestLauncher(launcherTargets: LauncherTarget[]) {
|
|
logger.debug('Fetching latestLauncher ...');
|
|
for (const { id, apps, code, channel } of launcherTargets) {
|
|
for (const app of apps) {
|
|
const apiArgs = [code, channel, channel, null] as const;
|
|
const [rsp, rspExe] = await Promise.all([
|
|
apiUtils.akEndfield.launcher.latestLauncher(...apiArgs, app, id),
|
|
apiUtils.akEndfield.launcher.latestLauncherExe(...apiArgs, app.toLowerCase(), id),
|
|
]);
|
|
|
|
logger.info(`Fetched latestLauncher: ${id.toUpperCase()}, v${rsp.version}, ${app}`);
|
|
const channelStr = String(channel);
|
|
queueAssetForMirroring(rsp.zip_package_url);
|
|
queueAssetForMirroring(rspExe.exe_url);
|
|
|
|
await saveResultWithHistory(
|
|
['akEndfield', 'launcher', 'launcher', app, channelStr],
|
|
rsp.version,
|
|
{
|
|
req: { appCode: code, channel, subChannel: channel, targetApp: app },
|
|
rsp,
|
|
},
|
|
{ ignoreRules: diffIgnoreRules },
|
|
);
|
|
|
|
await saveResultWithHistory(
|
|
['akEndfield', 'launcher', 'launcherExe', app, channelStr],
|
|
rspExe.version,
|
|
{
|
|
req: { appCode: code, channel, subChannel: channel, ta: app.toLowerCase() },
|
|
rsp: rspExe,
|
|
},
|
|
{ ignoreRules: diffIgnoreRules },
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
async function fetchAndSaveLatestWebApis(gameTargets: GameTarget[]) {
|
|
logger.debug('Fetching latestWebApis ...');
|
|
const langs = apiUtils.akEndfield.defaultSettings.launcherWebLang;
|
|
const apis = [
|
|
{ name: 'sidebar', method: apiUtils.akEndfield.launcherWeb.sidebar, dir: 'sidebar' },
|
|
{ name: 'singleEnt', method: apiUtils.akEndfield.launcherWeb.singleEnt, dir: 'single_ent' },
|
|
{ name: 'mainBgImage', method: apiUtils.akEndfield.launcherWeb.mainBgImage, dir: 'main_bg_image' },
|
|
{ name: 'banner', method: apiUtils.akEndfield.launcherWeb.banner, dir: 'banner' },
|
|
{ name: 'announcement', method: apiUtils.akEndfield.launcherWeb.announcement, dir: 'announcement' },
|
|
] as const;
|
|
|
|
for (const target of gameTargets) {
|
|
for (const lang of langs) {
|
|
for (const api of apis) {
|
|
networkQueue.add(async () => {
|
|
const rsp = await api.method(target.appCode, target.channel, target.subChannel, lang, target.region);
|
|
if (!rsp) return;
|
|
const prettyRsp = {
|
|
req: {
|
|
appCode: target.appCode,
|
|
channel: target.channel,
|
|
subChannel: target.subChannel,
|
|
lang,
|
|
region: target.region,
|
|
platform: 'Windows',
|
|
},
|
|
rsp,
|
|
};
|
|
await saveResultWithHistory(
|
|
['akEndfield', 'launcher', 'web', String(target.subChannel), api.dir, lang],
|
|
null,
|
|
prettyRsp,
|
|
{ ignoreRules: diffIgnoreRules },
|
|
);
|
|
});
|
|
}
|
|
}
|
|
}
|
|
await networkQueue.onIdle();
|
|
}
|
|
|
|
// Mirroring and Cleanup
|
|
async function checkMirrorFileDbStatus() {
|
|
logger.info('Checking mirrored files availability ...');
|
|
const dbPath = path.join(argvUtils.getArgv()['outputDir'], 'mirror_file_list.json');
|
|
const db = (await Bun.file(dbPath).json()) as MirrorFileEntry[];
|
|
|
|
for (const entry of db) {
|
|
networkQueue.add(async () => {
|
|
try {
|
|
await ky.head(entry.orig, {
|
|
headers: { 'User-Agent': appConfig.network.userAgent.minimum },
|
|
timeout: appConfig.network.timeout,
|
|
retry: { limit: appConfig.network.retryCount },
|
|
});
|
|
entry.origStatus = true;
|
|
} catch {
|
|
if (entry.origStatus) logger.trace(`Orig inaccessible: ${entry.orig.split('/').pop()}`);
|
|
entry.origStatus = false;
|
|
}
|
|
});
|
|
}
|
|
await networkQueue.onIdle();
|
|
await Bun.write(dbPath, JSON.stringify(db));
|
|
}
|
|
|
|
async function processMirrorQueue() {
|
|
const dbPath = path.join(argvUtils.getArgv()['outputDir'], 'mirror_file_list.json');
|
|
const db = (await Bun.file(dbPath).json()) as MirrorFileEntry[];
|
|
|
|
for (const { url, name } of assetsToMirror) {
|
|
const origUrl = stringUtils.removeQueryStr(url);
|
|
if (!db.find((e) => e.orig.includes(origUrl))) {
|
|
await githubUtils.uploadAsset(octoClient, githubAuthCfg, url, name);
|
|
if (githubAuthCfg) {
|
|
db.push({
|
|
orig: origUrl,
|
|
mirror: `https://github.com/${githubAuthCfg.github.relArchive.owner}/${githubAuthCfg.github.relArchive.repo}/releases/download/${githubAuthCfg.github.relArchive.tag}/${name ?? new URL(url).pathname.split('/').pop() ?? ''}`,
|
|
origStatus: true,
|
|
});
|
|
await Bun.write(dbPath, JSON.stringify(db));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
async function mainCmdHandler() {
|
|
const authPath = 'config/config_auth.yaml';
|
|
if (await Bun.file(authPath).exists()) {
|
|
githubAuthCfg = YAML.parse(await Bun.file(authPath).text());
|
|
logger.info('Logging in to GitHub');
|
|
octoClient = new Octokit({ auth: githubAuthCfg.github.relArchive.token });
|
|
}
|
|
|
|
if (await githubUtils.checkIsActionRunning(githubAuthCfg)) {
|
|
logger.error('Duplicate execution detected');
|
|
return;
|
|
}
|
|
|
|
const cfg = appConfig.network.api.akEndfield;
|
|
const gameTargets: GameTarget[] = [
|
|
{
|
|
name: 'Official',
|
|
region: 'os',
|
|
appCode: cfg.appCode.game.osWinRel,
|
|
launcherAppCode: cfg.appCode.launcher.osWinRel,
|
|
channel: cfg.channel.osWinRel,
|
|
subChannel: cfg.subChannel.osWinRel,
|
|
launcherSubChannel: cfg.subChannel.osWinRel,
|
|
dirName: String(cfg.channel.osWinRel),
|
|
},
|
|
{
|
|
name: 'Epic',
|
|
region: 'os',
|
|
appCode: cfg.appCode.game.osWinRel,
|
|
launcherAppCode: cfg.appCode.launcher.osWinRelEpic,
|
|
channel: cfg.channel.osWinRel,
|
|
subChannel: cfg.subChannel.osWinRelEpic,
|
|
launcherSubChannel: cfg.subChannel.osWinRelEpic,
|
|
dirName: String(cfg.subChannel.osWinRelEpic),
|
|
},
|
|
{
|
|
name: 'Google Play',
|
|
region: 'os',
|
|
appCode: cfg.appCode.game.osWinRel,
|
|
launcherAppCode: cfg.appCode.launcher.osWinRelEpic,
|
|
channel: cfg.channel.osWinRel,
|
|
subChannel: cfg.subChannel.osWinRelGooglePlay,
|
|
launcherSubChannel: cfg.subChannel.osWinRelGooglePlay,
|
|
dirName: String(cfg.subChannel.osWinRelGooglePlay),
|
|
},
|
|
{
|
|
name: 'Official',
|
|
region: 'cn',
|
|
appCode: cfg.appCode.game.cnWinRel,
|
|
launcherAppCode: cfg.appCode.launcher.cnWinRel,
|
|
channel: cfg.channel.cnWinRel,
|
|
subChannel: cfg.subChannel.cnWinRel,
|
|
launcherSubChannel: cfg.subChannel.cnWinRel,
|
|
dirName: String(cfg.channel.cnWinRel),
|
|
},
|
|
{
|
|
name: 'Bilibili',
|
|
region: 'cn',
|
|
appCode: cfg.appCode.game.cnWinRel,
|
|
launcherAppCode: cfg.appCode.launcher.cnWinRel,
|
|
channel: cfg.channel.cnWinRelBilibili,
|
|
subChannel: cfg.subChannel.cnWinRelBilibili,
|
|
launcherSubChannel: cfg.subChannel.cnWinRelBilibili,
|
|
dirName: String(cfg.channel.cnWinRelBilibili),
|
|
},
|
|
];
|
|
|
|
const launcherTargets: LauncherTarget[] = [
|
|
{ id: 'os', apps: ['EndField', 'Official'], code: cfg.appCode.launcher.osWinRel, channel: cfg.channel.osWinRel },
|
|
{
|
|
id: 'cn',
|
|
apps: ['EndField', 'Arknights', 'Official'],
|
|
code: cfg.appCode.launcher.cnWinRel,
|
|
channel: cfg.channel.cnWinRel,
|
|
},
|
|
];
|
|
|
|
await fetchAndSaveLatestGames(gameTargets);
|
|
await fetchAndSaveLatestGamePatches(gameTargets);
|
|
await fetchAndSaveLatestGameResources(gameTargets);
|
|
await fetchAndSaveAllGameResRawData(gameTargets);
|
|
await fetchAndSaveLatestLauncher(launcherTargets);
|
|
await fetchAndSaveLatestWebApis(gameTargets);
|
|
|
|
await checkMirrorFileDbStatus();
|
|
await processMirrorQueue();
|
|
|
|
const relInfo = await githubUtils.getReleaseInfo(octoClient, githubAuthCfg);
|
|
if (relInfo) {
|
|
logger.info(`GitHub Releases total size: ${formatBytes(mathUtils.arrayTotal(relInfo.assets.map((a) => a.size)))}`);
|
|
}
|
|
}
|
|
|
|
export default mainCmdHandler;
|