generated from ztimson/template
114 lines
3.7 KiB
JavaScript
114 lines
3.7 KiB
JavaScript
import fs from 'node:fs';
|
|
import os from 'node:os';
|
|
import path from 'node:path';
|
|
import https from 'node:https';
|
|
import {fileURLToPath} from 'node:url';
|
|
import {createWriteStream} from 'node:fs';
|
|
import AdmZip from 'adm-zip';
|
|
import * as tar from 'tar';
|
|
|
|
const __dirname = path.dirname(fileURLToPath(import.meta.url));
|
|
|
|
const VERSION = '3.8.1';
|
|
const BASE_URL = 'https://download.kiwix.org/release/kiwix-tools';
|
|
const PLATFORM_MAP = {linux: 'linux', darwin: 'macos', win32: 'win'};
|
|
|
|
const BIN_DIR = path.join(__dirname, '..', 'bin');
|
|
|
|
function download(url, dest) {
|
|
return new Promise((resolve, reject) => {
|
|
const file = fs.createWriteStream(dest);
|
|
https.get(url, res => {
|
|
if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
|
|
file.close();
|
|
return resolve(download(res.headers.location, dest));
|
|
}
|
|
if (!res.statusCode || res.statusCode >= 400) {
|
|
return reject(new Error(`Download failed: ${res.statusCode} ${res.statusMessage}`));
|
|
}
|
|
res.pipe(file);
|
|
file.on('finish', () => file.close(resolve));
|
|
}).on('error', err => fs.unlink(dest, () => reject(err)));
|
|
});
|
|
}
|
|
|
|
function chmodRecursive(dir, mode) {
|
|
for (const entry of fs.readdirSync(dir, {withFileTypes: true})) {
|
|
const full = path.join(dir, entry.name);
|
|
if (entry.isDirectory()) chmodRecursive(full, mode);
|
|
else fs.chmodSync(full, mode);
|
|
}
|
|
}
|
|
|
|
async function downloadAndExtract() {
|
|
const platformName = PLATFORM_MAP[process.platform];
|
|
if (!platformName) throw new Error(`Unsupported platform: ${process.platform}`);
|
|
|
|
const ext = platformName === 'win' ? 'zip' : 'tar.gz';
|
|
const archiveName = `kiwix-tools_${platformName}-x86_64-${VERSION}.${ext}`;
|
|
const url = `${BASE_URL}/${archiveName}`;
|
|
const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'kiwix-tools-'));
|
|
const archivePath = path.join(tmpDir, archiveName);
|
|
|
|
console.log('Downloading kiwix-tools from:', url);
|
|
await download(url, archivePath);
|
|
|
|
await fs.promises.mkdir(BIN_DIR, {recursive: true});
|
|
|
|
console.log('Extracting...');
|
|
|
|
// Use npm-installable libraries for extraction
|
|
if (archiveName.endsWith('.zip')) {
|
|
const zip = new AdmZip(archivePath);
|
|
const zipName = zip.getZipName(); // e.g. "kiwix-tools_linux-x86_64-3.8.1"
|
|
const extractDir = path.join(BIN_DIR, zipName);
|
|
|
|
await zip.extractAllToAsync(extractDir, true);
|
|
|
|
// Flatten the extracted directory into BIN_DIR
|
|
if (fs.existsSync(extractDir)) {
|
|
for (const entry of await fs.promises.readdir(extractDir)) {
|
|
const src = path.join(extractDir, entry);
|
|
const dest = path.join(BIN_DIR, entry);
|
|
await fs.promises.rename(src, dest);
|
|
}
|
|
await fs.promises.rmdir(extractDir);
|
|
}
|
|
} else if (archiveName.endsWith('.tar.gz')) {
|
|
// Extract to a temp dir first to check for subdirectory wrapper
|
|
const extractDir = path.join(tmpDir, 'extracted');
|
|
await fs.promises.mkdir(extractDir, {recursive: true});
|
|
|
|
await tar.extract({
|
|
file: archivePath,
|
|
cwd: extractDir,
|
|
silent: false
|
|
});
|
|
|
|
const list = await fs.promises.readdir(extractDir, {withFileTypes: true});
|
|
const wrapper = list.find(e => e.isDirectory() && e.name.startsWith('kiwix-tools_'));
|
|
const finalDir = wrapper ? path.join(extractDir, wrapper.name) : extractDir;
|
|
|
|
// Flatten into BIN_DIR
|
|
for (const entry of await fs.promises.readdir(finalDir)) {
|
|
const src = path.join(finalDir, entry);
|
|
const dest = path.join(BIN_DIR, entry);
|
|
await fs.promises.rename(src, dest);
|
|
}
|
|
|
|
await fs.promises.rmdir(finalDir);
|
|
}
|
|
|
|
if (process.platform !== 'win32') {
|
|
chmodRecursive(BIN_DIR, 0o755);
|
|
}
|
|
|
|
await fs.promises.rm(tmpDir, {recursive: true, force: true});
|
|
console.log('Installed to:', BIN_DIR);
|
|
}
|
|
|
|
downloadAndExtract().catch(err => {
|
|
console.error(err);
|
|
process.exit(1)
|
|
}).finally(() => process.exit());
|