add-extension.js

/********************************************************************************
 * Copyright (c) 2022 Gitpod and others
 *
 * This program and the accompanying materials are made available under the
 * terms of the Eclipse Public License v. 2.0 which is available at
 * http://www.eclipse.org/legal/epl-2.0.
 *
 * SPDX-License-Identifier: EPL-2.0
 ********************************************************************************/

//
// Usage:
//   node add-extension.js ext.id https://github.com/my-org/repo
// Optional extra arguments [see: extensions-schema.json]:
//   node add-extension.js abusaidm.html-snippets2 https://github.com/my-org/repo --location 'packages/xy'
//

// @ts-check
const fs = require("fs");
const minimist = require("minimist");
const util = require("util");
const exec = require("./lib/exec");
const extensionsSchema = require("./extensions-schema.json");
const fetch = require("node-fetch");
const { getPublicGalleryAPI } = require("@vscode/vsce/out/util");
const parseXmlManifest = require("@vscode/vsce/out/xml").parseXmlManifest;
const { ExtensionQueryFlags, PublishedExtension } = require("azure-devops-node-api/interfaces/GalleryInterfaces");

const flags = [
    ExtensionQueryFlags.IncludeMetadata,
    ExtensionQueryFlags.IncludeAssetUri,
    ExtensionQueryFlags.IncludeFiles,
    ExtensionQueryFlags.IncludeLatestVersionOnly,
];

const msGalleryApi = getPublicGalleryAPI();
msGalleryApi.client["_allowRetries"] = true;
msGalleryApi.client["_maxRetries"] = 5;

const getRepositoryFromMarketplace = async (/** @type {string} */ id) => {
    /** @type {[PromiseSettledResult<PublishedExtension | undefined>]} */
    let [msExtension] = await Promise.allSettled([msGalleryApi.getExtension(id, flags)]);
    if (msExtension.status === "fulfilled") {
        const vsixManifest =
            msExtension.value?.versions &&
            msExtension.value?.versions[0].files?.find(
                (file) => file.assetType === "Microsoft.VisualStudio.Services.VsixManifest",
            )?.source;
        const response = await fetch(vsixManifest);
        const data = await parseXmlManifest(await response.text());
        const url = new URL(
            data.PackageManifest.Metadata[0].Properties[0].Property.find(
                (property) => property.$.Id === "Microsoft.VisualStudio.Services.Links.Source",
            ).$.Value,
        );

        if (url.host === "github.com") {
            return url.toString().replace(".git", "");
        }

        return url.toString();
    }
};

(async () => {
    // Parse args
    const argv = minimist(process.argv.slice(2)); // without executable & script path

    // Check positional args
    if (argv._.length === 0) {
        console.error("Need two positional arguments: ext-id, repo-url or a Microsoft Marketplace URL");
        process.exit(1);
    }

    let [extID, repoURL] = argv._;
    try {
        const urlObject = new URL(extID);
        if (urlObject.host === "marketplace.visualstudio.com") {
            const id = urlObject.searchParams.get("itemName");
            if (!id) {
                console.error(`Couldn\'t get the extension ID from ${extID}`);
                process.exit(1);
            } else {
                extID = id;
                const url = await getRepositoryFromMarketplace(id);
                if (!url) {
                    console.error(`Couldn\'t get the repository URL for ${extID}`);
                    process.exit(1);
                } else {
                    repoURL = url;
                }
            }
        }
    } catch {
    } finally {
        if (argv._.length < 2 && !repoURL) {
            console.error(
                "Need two positional arguments: ext-id, repo-url, since the provided argument is not a Marketplace URL",
            );
            process.exit(1);
        }
    }

    const extDefinition = {
        repository: repoURL,
    };

    // Validate extra args
    delete argv._; // delete positional arguments
    for (const arg of Object.keys(argv)) {
        const propDef = extensionsSchema.additionalProperties.properties[arg];
        // console.debug(`arg=${arg}:`, argv[arg], propDef)
        if (!propDef) {
            console.error(`argument '${arg}' not found in ./extensions-schema.json`);
            process.exit(1);
        }

        // parse & validate value
        if (propDef.type === "string") {
            extDefinition[arg] = String(argv[arg]); // minimist might've assumed a different type (e.g. number)
        } else if (propDef.type === "number") {
            if (typeof argv[arg] !== "number") {
                console.error(
                    `argument '${arg}' should be type '${propDef.type}' but yours seems to be '${typeof argv[arg]}'`,
                );
                process.exit(1);
            }
            extDefinition[arg] = argv[arg]; // numbers are parsed by minimist already
        } else {
            console.error(
                `argument '${arg}' is of type '${propDef.type}' which is not implemented by this script, sorry`,
            );
            process.exit(1);
        }
    }
    console.info("Adding extension:", util.inspect(extDefinition, { colors: true, compact: false }));

    // Read current file
    const extensions = Object.entries(
        JSON.parse(await fs.promises.readFile("./extensions.json", { encoding: "utf8" })),
    );
    // Sort extensions (most are, but not always)
    extensions.sort(([k1], [k2]) => k1.localeCompare(k2));

    const originalList = JSON.stringify(Object.fromEntries(extensions), undefined, 2);

    // Find position & insert extension
    for (let i = 0; i < extensions.length; i++) {
        const [currentID] = extensions[i];
        // console.debug(i, currentID)
        const diff = currentID.localeCompare(extID, undefined, { sensitivity: "base" });
        if (diff === 0) {
            console.error("Extension already defined:", currentID);
            process.exit(1);
        }
        if (diff > 0) {
            extensions.splice(i, 0, [extID, extDefinition]);
            break;
        }
    }

    // Persist changes
    await fs.promises.writeFile(
        "./extensions.json",
        JSON.stringify(Object.fromEntries(extensions), undefined, 2) + "\n", // add newline at EOF
        { encoding: "utf8" },
    );

    console.info(`Successfully added ${extID}`);
    if (process.env.TEST_EXTENSION === "false") {
        console.info("Skipping tests, TEST_EXTENSION was provided.");
        process.exit(0);
    }

    console.info(`Trying to build ${extID} for the first time`);

    process.env.EXTENSIONS = extID;
    process.env.FORCE = "true";
    process.env.SKIP_PUBLISH = "true";

    const out = await exec("node publish-extensions", { quiet: true, ghtoken: true });
    if (out && out.stderr.includes("[FAIL] Could not process extension:")) {
        console.error(
            `There was an error while trying to build ${extID}. Reverting back to the previous state of extensions.json.`,
        );
        await fs.promises.writeFile(
            "./extensions.json",
            originalList + "\n", // add newline at EOF
            { encoding: "utf8" },
        );
    } else {
        console.info("Built extension successfully");
        console.info(`Feel free to use the message below for your commit:\r\nAdded \`${extID}\``);
    }
})();