ovsx 0.1.0-next.e000fdb → 0.3.0

package/src/main.ts

@@ -19,31 +19,27 @@ const pkg = require('../package.json');
 
 module.exports = function (argv: string[]): void {
     const program = new commander.Command();
-    program.usage('<command> [options]');
-    program.option('--debug', 'include debug information on error');
-
-    const versionCmd = program.command('version');
-    versionCmd.description('Output the version number.')
-        .action(() => console.log(`Eclipse Open VSX CLI version ${pkg.version}`));
+    program.usage('<command> [options]')
+        .option('-r, --registryUrl <url>', 'Use the registry API at this base URL.')
+        .option('-p, --pat <token>', 'Personal access token.')
+        .option('--debug', 'Include debug information on error')
+        .version(pkg.version, '-V, --version', 'Print the Eclipse Open VSX CLI version');
 
     const createNamespaceCmd = program.command('create-namespace <name>');
     createNamespaceCmd.description('Create a new namespace')
-        .option('-r, --registryUrl <url>', 'Use the registry API at this base URL.')
-        .option('-p, --pat <token>', 'Personal access token (required).')
-        .action((name: string, { registryUrl, pat }) => {
+        .action((name: string) => {
+            const { registryUrl, pat } = program.opts();
             createNamespace({ name, registryUrl, pat })
                 .catch(handleError(program.debug));
         });
 
     const publishCmd = program.command('publish [extension.vsix]');
     publishCmd.description('Publish an extension, packaging it first if necessary.')
-        .option('-r, --registryUrl <url>', 'Use the registry API at this base URL.')
-        .option('-p, --pat <token>', 'Personal access token (required).')
-        .option('--packagePath <path>', 'Package and publish the extension at the specified path.')
+        .option('-i, --packagePath <paths...>', 'Publish the provided VSIX packages.')
         .option('--baseContentUrl <url>', 'Prepend all relative links in README.md with this URL.')
         .option('--baseImagesUrl <url>', 'Prepend all relative image links in README.md with this URL.')
         .option('--yarn', 'Use yarn instead of npm while packing extension files.')
-        .action((extensionFile: string, { registryUrl, pat, packagePath, baseContentUrl, baseImagesUrl, yarn }) => {
+        .action((extensionFile: string, { packagePath, baseContentUrl, baseImagesUrl, yarn }) => {
             if (extensionFile !== undefined && packagePath !== undefined) {
                 console.error('\u274c  Please specify either a package file or a package path, but not both.\n');
                 publishCmd.help();
@@ -54,32 +50,39 @@ module.exports = function (argv: string[]): void {
                 console.warn("Ignoring option '--baseImagesUrl' for prepackaged extension.");
             if (extensionFile !== undefined && yarn !== undefined)
                 console.warn("Ignoring option '--yarn' for prepackaged extension.");
-            publish({ extensionFile, registryUrl, pat, packagePath, baseContentUrl, baseImagesUrl, yarn })
-                .catch(handleError(program.debug));
+            const { registryUrl, pat } = program.opts();
+            publish({ extensionFile, registryUrl, pat, packagePath: typeof packagePath === 'string' ? [packagePath] : packagePath, baseContentUrl, baseImagesUrl, yarn })
+                .catch(handleError(program.debug,
+                    'See the documentation for more information:\n'
+                    + 'https://github.com/eclipse/openvsx/wiki/Publishing-Extensions'
+                ));
         });
 
     const getCmd = program.command('get <namespace.extension>');
     getCmd.description('Download an extension or its metadata.')
-        .option('-v, --version <version>', 'Specify an exact version or a version range.')
-        .option('-r, --registryUrl <url>', 'Use the registry API at this base URL.')
+        .option('-v, --versionRange <version>', 'Specify an exact version or a version range.')
         .option('-o, --output <path>', 'Save the output in the specified file or directory.')
         .option('--metadata', 'Print the extension\'s metadata instead of downloading it.')
-        .action((extensionId: string, { version, registryUrl, output, metadata }) => {
-            if (typeof version === 'function') // If not specified, `version` yields a function
-                version = undefined;
-            getExtension({ extensionId, version, registryUrl, output, metadata })
+        .action((extensionId: string, { versionRange, output, metadata }) => {
+            const { registryUrl } = program.opts();
+            getExtension({ extensionId, version: versionRange, registryUrl, output, metadata })
                 .catch(handleError(program.debug));
         });
 
     program
         .command('*', '', { noHelp: true })
-        .action((cmd: string) => {
+        .action((cmd: commander.Command) => {
             const availableCommands = program.commands.map((c: any) => c._name) as string[];
-            const suggestion = availableCommands.find(c => leven(c, cmd) < c.length * 0.4);
-            if (suggestion)
-                console.error(`Unknown command '${cmd}', did you mean '${suggestion}'?\n`);
-            else
-                console.error(`Unknown command '${cmd}'`);
+            const actualCommand = cmd.args[0];
+            if (actualCommand) {
+                const suggestion = availableCommands.find(c => leven(c, actualCommand) < c.length * 0.4);
+                if (suggestion)
+                    console.error(`Unknown command '${actualCommand}', did you mean '${suggestion}'?\n`);
+                else
+                    console.error(`Unknown command '${actualCommand}'.\n`);
+            } else {
+                console.error('Unknown command.');
+            }
             program.help();
         });
 

package/src/ovsx

@@ -1,7 +1,9 @@
 #!/usr/bin/env node
 
-if (global.URL === undefined) {
-    console.error('ovsx requires at least NodeJS version 10. Check your installed version with `node --version`.');
+const semver = require('semver');
+
+if (semver.lt(process.versions.node, '14.0.0')) {
+    console.error('ovsx requires at least NodeJS version 14. Check your installed version with `node --version`.');
     process.exit(1);
 }
 

package/src/publish.ts

@@ -8,60 +8,53 @@
  * SPDX-License-Identifier: EPL-2.0
  ********************************************************************************/
 
-import { createVSIX } from 'vsce';
-import { createTempFile } from './util';
-import { Registry } from './registry';
+import { createVSIX, ICreateVSIXOptions } from 'vsce';
+import { createTempFile, addEnvOptions } from './util';
+import { Registry, RegistryOptions } from './registry';
+import { checkLicense } from './check-license';
 
 /**
  * Publishes an extension.
  */
 export async function publish(options: PublishOptions = {}): Promise<void> {
-    if (!options.registryUrl) {
-        options.registryUrl = process.env.OVSX_REGISTRY_URL;
-    }
-    if (!options.pat) {
-        options.pat = process.env.OVSX_PAT;
-        if (!options.pat) {
-            throw new Error("A personal access token must be given with the option '--pat'.");
+        addEnvOptions(options);
+        if (options.packagePath) {
+            // call the publish command for every package path
+            await Promise.all(options.packagePath.map(path => doPublish({ ...options, packagePath: path })));
+        } else {
+            return doPublish({ ... options, packagePath: undefined });
         }
+}
+
+async function doPublish(options: InternalPublishOptions = {}): Promise<void> {
+    if (!options.pat) {
+        throw new Error("A personal access token must be given with the option '--pat'.");
     }
+
+    // if the packagePath is a link to a vsix, don't need to package it
+    if (options.packagePath && options.packagePath.endsWith('.vsix')) {
+        options.extensionFile = options.packagePath;
+        delete options.packagePath;
+    }
+    const registry = new Registry(options);
     if (!options.extensionFile) {
-        options.extensionFile = await createTempFile({ postfix: '.vsix' });
-        await createVSIX({
-            cwd: options.packagePath,
-            packagePath: options.extensionFile,
-            baseContentUrl: options.baseContentUrl,
-            baseImagesUrl: options.baseImagesUrl,
-            useYarn: options.yarn
-        });
+        await packageExtension(options, registry);
         console.log(); // new line
     }
-    const registry = new Registry({ url: options.registryUrl });
-    const extension = await registry.publish(options.extensionFile, options.pat);
+
+    const extension = await registry.publish(options.extensionFile!, options.pat);
     if (extension.error) {
         throw new Error(extension.error);
     }
     console.log(`\ud83d\ude80  Published ${extension.namespace}.${extension.name} v${extension.version}`);
 }
 
-export interface PublishOptions {
-    /**
-     * The base URL of the registry API.
-     */
-    registryUrl?: string;
-    /**
-     * Personal access token.
-     */
-    pat?: string;
+interface PublishCommonOptions extends RegistryOptions {
     /**
      * Path to the vsix file to be published. Cannot be used together with `packagePath`.
      */
     extensionFile?: string;
-    /**
-     * Path to the extension to be packaged and published. Cannot be used together
-     * with `extensionFile`.
-     */
-    packagePath?: string;
+
     /**
 	 * The base URL for links detected in Markdown files. Only valid with `packagePath`.
 	 */
@@ -75,3 +68,40 @@ export interface PublishOptions {
 	 */
     yarn?: boolean;
 }
+
+// Interface used by top level CLI
+export interface PublishOptions extends PublishCommonOptions {
+
+    /**
+     * Paths to the extension to be packaged and published. Cannot be used together
+     * with `extensionFile`.
+     */
+    packagePath?: string[];
+}
+
+// Interface used internally by the doPublish method
+interface InternalPublishOptions extends PublishCommonOptions {
+
+    /**
+     * Only one path for our internal command.
+     * Path to the extension to be packaged and published. Cannot be used together
+     * with `extensionFile`.
+     */
+    packagePath?: string;
+}
+
+async function packageExtension(options: InternalPublishOptions, registry: Registry): Promise<void> {
+    if (registry.requiresLicense) {
+        await checkLicense(options.packagePath!);
+    }
+
+    options.extensionFile = await createTempFile({ postfix: '.vsix' });
+    const createVSIXOptions: ICreateVSIXOptions = {
+        cwd: options.packagePath,
+        packagePath: options.extensionFile,
+        baseContentUrl: options.baseContentUrl,
+        baseImagesUrl: options.baseImagesUrl,
+        useYarn: options.yarn
+    };
+    await createVSIX(createVSIXOptions);
+}

package/src/registry.ts

@@ -24,16 +24,25 @@ export class Registry {
     readonly url: string;
     readonly maxNamespaceSize: number;
     readonly maxPublishSize: number;
+    readonly username?: string;
+    readonly password?: string;
 
     constructor(options: RegistryOptions = {}) {
-        if (options.url && options.url.endsWith('/'))
-            this.url = options.url.substring(0, options.url.length - 1);
-        else if (options.url)
-            this.url = options.url;
+        if (options.registryUrl && options.registryUrl.endsWith('/'))
+            this.url = options.registryUrl.substring(0, options.registryUrl.length - 1);
+        else if (options.registryUrl)
+            this.url = options.registryUrl;
         else
             this.url = DEFAULT_URL;
         this.maxNamespaceSize = options.maxNamespaceSize || DEFAULT_NAMESPACE_SIZE;
         this.maxPublishSize = options.maxPublishSize || DEFAULT_PUBLISH_SIZE;
+        this.username = options.username;
+        this.password = options.password;
+    }
+
+    get requiresLicense(): boolean {
+        const url = new URL(this.url);
+        return url.hostname === 'open-vsx.org' || url.hostname.endsWith('.open-vsx.org');
     }
 
     createNamespace(name: string, pat: string): Promise<Response> {
@@ -73,8 +82,9 @@ export class Registry {
     download(file: string, url: URL): Promise<void> {
         return new Promise((resolve, reject) => {
             const stream = fs.createWriteStream(file);
+            const requestOptions = this.getRequestOptions();
             const request = this.getProtocol(url)
-                                .request(url, response => {
+                                .request(url, requestOptions, response => {
                 response.on('end', () => {
                     if (response.statusCode !== undefined && (response.statusCode < 200 || response.statusCode > 299)) {
                         reject(statusError(response));
@@ -98,8 +108,9 @@ export class Registry {
 
     getJson<T extends Response>(url: URL): Promise<T> {
         return new Promise((resolve, reject) => {
+            const requestOptions = this.getRequestOptions();
             const request = this.getProtocol(url)
-                                .request(url, this.getJsonResponse<T>(resolve, reject));
+                                .request(url, requestOptions, this.getJsonResponse<T>(resolve, reject));
             request.on('error', reject);
             request.end();
         });
@@ -107,7 +118,7 @@ export class Registry {
 
     post<T extends Response>(content: string | Buffer | Uint8Array, url: URL, headers?: http.OutgoingHttpHeaders, maxBodyLength?: number): Promise<T> {
         return new Promise((resolve, reject) => {
-            const requestOptions = { method: 'POST', headers, maxBodyLength } as http.RequestOptions;
+            const requestOptions = this.getRequestOptions('POST', headers, maxBodyLength);
             const request = this.getProtocol(url)
                                 .request(url, requestOptions, this.getJsonResponse<T>(resolve, reject));
             request.on('error', reject);
@@ -119,7 +130,7 @@ export class Registry {
     postFile<T extends Response>(file: string, url: URL, headers?: http.OutgoingHttpHeaders, maxBodyLength?: number): Promise<T> {
         return new Promise((resolve, reject) => {
             const stream = fs.createReadStream(file);
-            const requestOptions = { method: 'POST', headers, maxBodyLength } as http.RequestOptions;
+            const requestOptions = this.getRequestOptions('POST', headers, maxBodyLength);
             const request = this.getProtocol(url)
                                 .request(url, requestOptions, this.getJsonResponse<T>(resolve, reject));
             stream.on('error', err => {
@@ -150,6 +161,21 @@ export class Registry {
             return followRedirects.http as typeof http;
     }
 
+    private getRequestOptions(method?: string, headers?: http.OutgoingHttpHeaders, maxBodyLength?: number): http.RequestOptions {
+        if (this.username && this.password) {
+            if (!headers) {
+                headers = {};
+            }
+            const credentials = Buffer.from(this.username + ':' + this.password).toString('base64');
+            headers['Authorization'] = 'Basic ' + credentials;
+        }
+        return {
+            method,
+            headers,
+            maxBodyLength
+        } as http.RequestOptions;
+    }
+
     private getJsonResponse<T extends Response>(resolve: (value: T) => void, reject: (reason: any) => void): (res: http.IncomingMessage) => void {
         return response => {
             response.setEncoding('UTF-8');
@@ -186,8 +212,29 @@ export class Registry {
 }
 
 export interface RegistryOptions {
-    url?: string;
+    /**
+     * The base URL of the registry API.
+     */
+    registryUrl?: string;
+    /**
+     * Personal access token.
+     */
+    pat?: string;
+    /**
+     * User name for basic authentication.
+     */
+    username?: string;
+    /**
+     * Password for basic authentication.
+     */
+    password?: string;
+    /**
+     * Maximal request body size for creating namespaces.
+     */
     maxNamespaceSize?: number;
+    /**
+     * Maximal request body size for publishing.
+     */
     maxPublishSize?: number;
 }
 
@@ -206,8 +253,7 @@ export interface Extension extends Response {
     namespace: string;
     version: string;
     publishedBy: UserData;
-    unrelatedPublisher: boolean;
-    namespaceAccess: 'public' | 'restricted';
+    verified: boolean;
     // key: version, value: url
     allVersions: { [version: string]: string };
 

package/src/util.ts

@@ -9,11 +9,29 @@
  ********************************************************************************/
 
 import * as fs from 'fs';
+import * as path from 'path';
 import * as tmp from 'tmp';
 import * as http from 'http';
+import * as readline from 'readline';
+import { RegistryOptions } from './registry';
 
 export { promisify } from 'util';
 
+export function addEnvOptions(options: RegistryOptions): void {
+    if (!options.registryUrl) {
+        options.registryUrl = process.env.OVSX_REGISTRY_URL;
+    }
+    if (!options.pat) {
+        options.pat = process.env.OVSX_PAT;
+    }
+    if (!options.username) {
+        options.username = process.env.OVSX_USERNAME;
+    }
+    if (!options.password) {
+        options.password = process.env.OVSX_PASSWORD;
+    }
+}
+
 export function matchExtensionId(id: string): RegExpExecArray | null {
     return /^([\w-]+)(?:\.|\/)([\w-]+)$/.exec(id);
 }
@@ -50,10 +68,13 @@ export function createTempFile(options: tmp.TmpNameOptions): Promise<string> {
     });
 }
 
-export function handleError(debug?: boolean): (reason: any) => void {
+export function handleError(debug?: boolean, additionalMessage?: string): (reason: any) => void {
     return reason => {
         if (reason instanceof Error && !debug) {
             console.error(`\u274c  ${reason.message}`);
+            if (additionalMessage) {
+                console.error(additionalMessage);
+            }
         } else if (typeof reason === 'string') {
             console.error(`\u274c  ${reason}`);
         } else if (reason !== undefined) {
@@ -71,3 +92,91 @@ export function statusError(response: http.IncomingMessage): Error {
     else
         return new Error(`The server responded with status ${response.statusCode}.`);
 }
+
+export function readFile(name: string, packagePath?: string, encoding = 'utf-8'): Promise<string> {
+    return new Promise((resolve, reject) => {
+        fs.readFile(
+            path.join(packagePath || process.cwd(), name),
+            { encoding },
+            (err, content) => {
+                if (err) {
+                    reject(err);
+                } else {
+                    resolve(content);
+                }
+            }
+        );
+    });
+}
+
+export async function readManifest(packagePath?: string): Promise<Manifest> {
+    const content = await readFile('package.json', packagePath);
+    return JSON.parse(content);
+}
+
+export function validateManifest(manifest: Manifest): void {
+    if (!manifest.publisher) {
+        throw new Error("Missing required field 'publisher'.");
+    }
+    if (!manifest.name) {
+        throw new Error("Missing required field 'name'.");
+    }
+    if (!manifest.version) {
+        throw new Error("Missing required field 'version'.");
+    }
+}
+
+export function writeFile(name: string, content: string, packagePath?: string, encoding = 'utf-8'): Promise<void> {
+    return new Promise((resolve, reject) => {
+        fs.writeFile(
+            path.join(packagePath || process.cwd(), name),
+            content,
+            { encoding },
+            err => {
+                if (err) {
+                    reject(err);
+                } else {
+                    resolve();
+                }
+            }
+        );
+    });
+}
+
+export function writeManifest(manifest: Manifest, packagePath?: string): Promise<void> {
+    const content = JSON.stringify(manifest, null, 4);
+    return writeFile('package.json', content, packagePath);
+}
+
+export interface Manifest {
+    publisher: string;
+    name: string;
+    version: string;
+    license?: string;
+}
+
+export function getUserInput(text: string): Promise<string> {
+    return new Promise(resolve => {
+        const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+        rl.question(text, answer => {
+            resolve(answer);
+            rl.close();
+        });
+    });
+}
+
+export async function getUserChoice<R extends string>(text: string, values: R[],
+        defaultValue: R, lowerCase = true): Promise<R> {
+    const prompt = text + '\n' + values.map(v => v === defaultValue ? `[${v}]` : v).join('/') + ': ';
+    const answer = await getUserInput(prompt);
+    if (!answer) {
+        return defaultValue;
+    }
+    const lcAnswer = lowerCase ? answer.toLowerCase() : answer;
+    for (const value of values) {
+        if (value.startsWith(lcAnswer)) {
+            return value;
+        }
+    }
+    return defaultValue;
+}