"use strict";
/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/
Object.defineProperty(exports, "__esModule", { value: true });
exports.downloadAndUnzipVSCode = exports.download = exports.defaultCachePath = exports.fetchTargetInferredVersion = exports.fetchInsiderVersions = exports.fetchStableVersions = void 0;
const cp = require("child_process");
const fs = require("fs");
const os_1 = require("os");
const path = require("path");
const semver = require("semver");
const stream_1 = require("stream");
const util_1 = require("util");
const progress_1 = require("./progress");
const request = require("./request");
const util_2 = require("./util");
const extensionRoot = process.cwd();
const pipelineAsync = util_1.promisify(stream_1.pipeline);
const vscodeStableReleasesAPI = `https://update.code.visualstudio.com/api/releases/stable`;
const vscodeInsiderReleasesAPI = `https://update.code.visualstudio.com/api/releases/insider`;
const downloadDirNameFormat = /^vscode-(?<platform>[a-z]+)-(?<version>[0-9.]+)$/;
const makeDownloadDirName = (platform, version) => `vscode-${platform}-${version}`;
const DOWNLOAD_ATTEMPTS = 3;
exports.fetchStableVersions = util_2.onceWithoutRejections((timeout) => request.getJSON(vscodeStableReleasesAPI, timeout));
exports.fetchInsiderVersions = util_2.onceWithoutRejections((timeout) => request.getJSON(vscodeInsiderReleasesAPI, timeout));
/**
 * Returns the stable version to run tests against. Attempts to get the latest
 * version from the update sverice, but falls back to local installs if
 * not available (e.g. if the machine is offline).
 */
async function fetchTargetStableVersion({ timeout, cachePath, platform }) {
    try {
        const versions = await exports.fetchStableVersions(timeout);
        return versions[0];
    }
    catch (e) {
        return fallbackToLocalEntries(cachePath, platform, e);
    }
}
async function fetchTargetInferredVersion(options) {
    if (!options.extensionsDevelopmentPath) {
        return fetchTargetStableVersion(options);
    }
    // load all engines versions from all development paths. Then, get the latest
    // stable version (or, latest Insiders version) that satisfies all
    // `engines.vscode` constraints.
    const extPaths = Array.isArray(options.extensionsDevelopmentPath)
        ? options.extensionsDevelopmentPath
        : [options.extensionsDevelopmentPath];
    const maybeExtVersions = await Promise.all(extPaths.map(getEngineVersionFromExtension));
    const extVersions = maybeExtVersions.filter(util_2.isDefined);
    const matches = (v) => !extVersions.some((range) => !semver.satisfies(v, range, { includePrerelease: true }));
    try {
        const stable = await exports.fetchStableVersions(options.timeout);
        const found1 = stable.find(matches);
        if (found1) {
            return found1;
        }
        const insiders = await exports.fetchInsiderVersions(options.timeout);
        const found2 = insiders.find(matches);
        if (found2) {
            return found2;
        }
        const v = extVersions.join(', ');
        console.warn(`No version of VS Code satisfies all extension engine constraints (${v}). Falling back to stable.`);
        return stable[0]; // 🤷
    }
    catch (e) {
        return fallbackToLocalEntries(options.cachePath, options.platform, e);
    }
}
exports.fetchTargetInferredVersion = fetchTargetInferredVersion;
async function getEngineVersionFromExtension(extensionPath) {
    var _a;
    try {
        const packageContents = await fs.promises.readFile(path.join(extensionPath, 'package.json'), 'utf8');
        const packageJson = JSON.parse(packageContents);
        return (_a = packageJson === null || packageJson === void 0 ? void 0 : packageJson.engines) === null || _a === void 0 ? void 0 : _a.vscode;
    }
    catch {
        return undefined;
    }
}
async function fallbackToLocalEntries(cachePath, platform, fromError) {
    const entries = await fs.promises.readdir(cachePath).catch(() => []);
    const [fallbackTo] = entries
        .map((e) => downloadDirNameFormat.exec(e))
        .filter(util_2.isDefined)
        .filter((e) => e.groups.platform === platform)
        .map((e) => e.groups.version)
        .sort((a, b) => Number(b) - Number(a));
    if (fallbackTo) {
        console.warn(`Error retrieving VS Code versions, using already-installed version ${fallbackTo}`, fromError);
        return fallbackTo;
    }
    throw fromError;
}
async function isValidVersion(version, platform, timeout) {
    if (version === 'insiders' || version === 'stable') {
        return true;
    }
    if (util_2.isStableVersionIdentifier(version)) {
        const stableVersionNumbers = await exports.fetchStableVersions(timeout);
        if (stableVersionNumbers.includes(version)) {
            return true;
        }
    }
    if (util_2.isInsiderVersionIdentifier(version)) {
        const insiderVersionNumbers = await exports.fetchInsiderVersions(timeout);
        if (insiderVersionNumbers.includes(version)) {
            return true;
        }
    }
    if (/^[0-9a-f]{40}$/.test(version)) {
        return true;
    }
    return false;
}
function getFilename(contentDisposition) {
    const parts = contentDisposition.split(';').map((s) => s.trim());
    for (const part of parts) {
        const match = /^filename="?([^"]*)"?$/i.exec(part);
        if (match) {
            return match[1];
        }
    }
    return undefined;
}
/**
 * Download a copy of VS Code archive to `.vscode-test`.
 *
 * @param version The version of VS Code to download such as '1.32.0'. You can also use
 * `'stable'` for downloading latest stable release.
 * `'insiders'` for downloading latest Insiders.
 */
async function downloadVSCodeArchive(options) {
    var _a, _b, _c;
    if (!fs.existsSync(options.cachePath)) {
        fs.mkdirSync(options.cachePath);
    }
    const timeout = options.timeout;
    const downloadUrl = util_2.getVSCodeDownloadUrl(options.version, options.platform);
    (_a = options.reporter) === null || _a === void 0 ? void 0 : _a.report({ stage: progress_1.ProgressReportStage.ResolvingCDNLocation, url: downloadUrl });
    const res = await request.getStream(downloadUrl, timeout);
    if (res.statusCode !== 302) {
        throw 'Failed to get VS Code archive location';
    }
    const url = res.headers.location;
    if (!url) {
        throw 'Failed to get VS Code archive location';
    }
    const contentSHA256 = res.headers['x-sha256'];
    res.destroy();
    const download = await request.getStream(url, timeout);
    const totalBytes = Number(download.headers['content-length']);
    const contentDisposition = download.headers['content-disposition'];
    const fileName = contentDisposition ? getFilename(contentDisposition) : undefined;
    const isZip = (_b = fileName === null || fileName === void 0 ? void 0 : fileName.endsWith('zip')) !== null && _b !== void 0 ? _b : url.endsWith('.zip');
    const timeoutCtrl = new request.TimeoutController(timeout);
    (_c = options.reporter) === null || _c === void 0 ? void 0 : _c.report({
        stage: progress_1.ProgressReportStage.Downloading,
        url,
        bytesSoFar: 0,
        totalBytes,
    });
    let bytesSoFar = 0;
    download.on('data', (chunk) => {
        var _a;
        bytesSoFar += chunk.length;
        timeoutCtrl.touch();
        (_a = options.reporter) === null || _a === void 0 ? void 0 : _a.report({
            stage: progress_1.ProgressReportStage.Downloading,
            url,
            bytesSoFar,
            totalBytes,
        });
    });
    download.on('end', () => {
        var _a;
        timeoutCtrl.dispose();
        (_a = options.reporter) === null || _a === void 0 ? void 0 : _a.report({
            stage: progress_1.ProgressReportStage.Downloading,
            url,
            bytesSoFar: totalBytes,
            totalBytes,
        });
    });
    timeoutCtrl.signal.addEventListener('abort', () => {
        download.emit('error', new request.TimeoutError(timeout));
        download.destroy();
    });
    return {
        stream: download,
        format: isZip ? 'zip' : 'tgz',
        sha256: contentSHA256,
        length: totalBytes,
    };
}
/**
 * Unzip a .zip or .tar.gz VS Code archive stream.
 */
async function unzipVSCode(reporter, extractDir, platform, { format, stream, length, sha256 }) {
    const stagingFile = path.join(os_1.tmpdir(), `vscode-test-${Date.now()}.zip`);
    const checksum = util_2.validateStream(stream, length, sha256);
    if (format === 'zip') {
        try {
            reporter.report({ stage: progress_1.ProgressReportStage.ExtractingSynchonrously });
            // note: this used to use Expand-Archive, but this caused a failure
            // on longer file paths on windows. And we used to use the streaming
            // "unzipper", but the module was very outdated and a bit buggy.
            // Instead, use jszip. It's well-used and actually 8x faster than
            // Expand-Archive on my machine.
            if (process.platform === 'win32') {
                const [buffer, JSZip] = await Promise.all([util_2.streamToBuffer(stream), Promise.resolve().then(() => require('jszip'))]);
                await checksum;
                const content = await JSZip.loadAsync(buffer);
                // extract file with jszip
                for (const filename of Object.keys(content.files)) {
                    const file = content.files[filename];
                    const filepath = path.join(extractDir, filename);
                    if (file.dir) {
                        continue;
                    }
                    // vscode update zips are trusted, but check for zip slip anyway.
                    if (!util_2.isSubdirectory(extractDir, filepath)) {
                        throw new Error(`Invalid zip file: ${filename}`);
                    }
                    await fs.promises.mkdir(path.dirname(filepath), { recursive: true });
                    await pipelineAsync(file.nodeStream(), fs.createWriteStream(filepath));
                }
            }
            else {
                // darwin or *nix sync
                await pipelineAsync(stream, fs.createWriteStream(stagingFile));
                await checksum;
                await spawnDecompressorChild('unzip', ['-q', stagingFile, '-d', extractDir]);
            }
        }
        finally {
            fs.unlink(stagingFile, () => undefined);
        }
    }
    else {
        // tar does not create extractDir by default
        if (!fs.existsSync(extractDir)) {
            fs.mkdirSync(extractDir);
        }
        // The CLI is a singular binary that doesn't have a wrapper component to remove
        const s = platform.includes('cli-') ? 0 : 1;
        await spawnDecompressorChild('tar', ['-xzf', '-', `--strip-components=${s}`, '-C', extractDir], stream);
        await checksum;
    }
}
function spawnDecompressorChild(command, args, input) {
    return new Promise((resolve, reject) => {
        const child = cp.spawn(command, args, { stdio: 'pipe' });
        if (input) {
            input.on('error', reject);
            input.pipe(child.stdin);
        }
        child.stderr.pipe(process.stderr);
        child.stdout.pipe(process.stdout);
        child.on('error', reject);
        child.on('exit', (code) => code === 0 ? resolve() : reject(new Error(`Failed to unzip archive, exited with ${code}`)));
    });
}
exports.defaultCachePath = path.resolve(extensionRoot, '.vscode-test');
const COMPLETE_FILE_NAME = 'is-complete';
/**
 * Download and unzip a copy of VS Code.
 * @returns Promise of `vscodeExecutablePath`.
 */
async function download(options = {}) {
    let version = options === null || options === void 0 ? void 0 : options.version;
    const { platform = util_2.systemDefaultPlatform, cachePath = exports.defaultCachePath, reporter = new progress_1.ConsoleReporter(process.stdout.isTTY), timeout = 15000, } = options;
    if (version === 'stable') {
        version = await fetchTargetStableVersion({ timeout, cachePath, platform });
    }
    else if (version) {
        /**
         * Only validate version against server when no local download that matches version exists
         */
        if (!fs.existsSync(path.resolve(cachePath, `vscode-${platform}-${version}`))) {
            if (!(await isValidVersion(version, platform, timeout))) {
                throw Error(`Invalid version ${version}`);
            }
        }
    }
    else {
        version = await fetchTargetInferredVersion({
            timeout,
            cachePath,
            platform,
            extensionsDevelopmentPath: options.extensionDevelopmentPath,
        });
    }
    if (platform === 'win32-archive' && semver.satisfies(version, '>= 1.85.0', { includePrerelease: true })) {
        throw new Error('Windows 32-bit is no longer supported from v1.85 onwards');
    }
    reporter.report({ stage: progress_1.ProgressReportStage.ResolvedVersion, version });
    const downloadedPath = path.resolve(cachePath, makeDownloadDirName(platform, version));
    if (fs.existsSync(path.join(downloadedPath, COMPLETE_FILE_NAME))) {
        if (util_2.isInsiderVersionIdentifier(version)) {
            reporter.report({ stage: progress_1.ProgressReportStage.FetchingInsidersMetadata });
            const { version: currentHash, date: currentDate } = util_2.insidersDownloadDirMetadata(downloadedPath, platform);
            const { version: latestHash, timestamp: latestTimestamp } = version === 'insiders'
                ? await util_2.getLatestInsidersMetadata(util_2.systemDefaultPlatform)
                : await util_2.getInsidersVersionMetadata(util_2.systemDefaultPlatform, version);
            if (currentHash === latestHash) {
                reporter.report({ stage: progress_1.ProgressReportStage.FoundMatchingInstall, downloadedPath });
                return Promise.resolve(util_2.insidersDownloadDirToExecutablePath(downloadedPath, platform));
            }
            else {
                try {
                    reporter.report({
                        stage: progress_1.ProgressReportStage.ReplacingOldInsiders,
                        downloadedPath,
                        oldDate: currentDate,
                        oldHash: currentHash,
                        newDate: new Date(latestTimestamp),
                        newHash: latestHash,
                    });
                    await fs.promises.rm(downloadedPath, { force: true, recursive: true });
                }
                catch (err) {
                    reporter.error(err);
                    throw Error(`Failed to remove outdated Insiders at ${downloadedPath}.`);
                }
            }
        }
        else if (util_2.isStableVersionIdentifier(version)) {
            reporter.report({ stage: progress_1.ProgressReportStage.FoundMatchingInstall, downloadedPath });
            return Promise.resolve(util_2.downloadDirToExecutablePath(downloadedPath, platform));
        }
        else {
            reporter.report({ stage: progress_1.ProgressReportStage.FoundMatchingInstall, downloadedPath });
            return Promise.resolve(util_2.insidersDownloadDirToExecutablePath(downloadedPath, platform));
        }
    }
    for (let i = 0;; i++) {
        try {
            await fs.promises.rm(downloadedPath, { recursive: true, force: true });
            const download = await downloadVSCodeArchive({
                version,
                platform,
                cachePath,
                reporter,
                timeout,
            });
            // important! do not put anything async here, since unzipVSCode will need
            // to start consuming the stream immediately.
            await unzipVSCode(reporter, downloadedPath, platform, download);
            await fs.promises.writeFile(path.join(downloadedPath, COMPLETE_FILE_NAME), '');
            reporter.report({ stage: progress_1.ProgressReportStage.NewInstallComplete, downloadedPath });
            break;
        }
        catch (error) {
            if (i++ < DOWNLOAD_ATTEMPTS) {
                reporter.report({
                    stage: progress_1.ProgressReportStage.Retrying,
                    attempt: i,
                    error: error,
                    totalAttempts: DOWNLOAD_ATTEMPTS,
                });
            }
            else {
                reporter.error(error);
                throw Error(`Failed to download and unzip VS Code ${version}`);
            }
        }
    }
    reporter.report({ stage: progress_1.ProgressReportStage.NewInstallComplete, downloadedPath });
    if (util_2.isStableVersionIdentifier(version)) {
        return util_2.downloadDirToExecutablePath(downloadedPath, platform);
    }
    else {
        return util_2.insidersDownloadDirToExecutablePath(downloadedPath, platform);
    }
}
exports.download = download;
async function downloadAndUnzipVSCode(versionOrOptions, platform, reporter, extractSync) {
    return await download(typeof versionOrOptions === 'object'
        ? versionOrOptions
        : { version: versionOrOptions, platform, reporter, extractSync });
}
exports.downloadAndUnzipVSCode = downloadAndUnzipVSCode;