ovsx 0.9.5 → 0.10.1

package/src/main.ts

@@ -15,8 +15,9 @@ import { verifyPat } from './verify-pat';
 import { publish } from './publish';
 import { handleError } from './util';
 import { getExtension } from './get';
-
-const pkg = require('../package.json');
+import login from './login';
+import logout from './logout';
+import { LIB_VERSION } from './version';
 
 module.exports = function (argv: string[]): void {
     const program = new commander.Command();
@@ -24,7 +25,7 @@ module.exports = function (argv: string[]): void {
         .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');
+        .version(LIB_VERSION, '-V, --version', 'Print the Eclipse Open VSX CLI version');
 
     const createNamespaceCmd = program.command('create-namespace <name>');
     createNamespaceCmd.description('Create a new namespace')
@@ -52,7 +53,8 @@ module.exports = function (argv: string[]): void {
         .option('--pre-release', 'Mark this package as a pre-release')
         .option('--no-dependencies', 'Disable dependency detection via npm or yarn')
         .option('--skip-duplicate', 'Fail silently if version already exists on the marketplace')
-        .action((extensionFile: string, { target, packagePath, baseContentUrl, baseImagesUrl, yarn, preRelease, dependencies, skipDuplicate }) => {
+        .option('--packageVersion <version>', 'Version of the provided VSIX packages.')
+        .action((extensionFile: string, { target, packagePath, baseContentUrl, baseImagesUrl, yarn, preRelease, dependencies, skipDuplicate, packageVersion }) => {
             if (extensionFile !== undefined && packagePath !== undefined) {
                 console.error('\u274c  Please specify either a package file or a package path, but not both.\n');
                 publishCmd.help();
@@ -67,16 +69,17 @@ 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.");
+            if (extensionFile !== undefined && packageVersion !== undefined)
+                console.warn("Ignoring option '--packageVersion' for prepackaged extension.");
             const { registryUrl, pat } = program.opts();
-            publish({ extensionFile, registryUrl, pat, targets: typeof target === 'string' ? [target] : target, packagePath: typeof packagePath === 'string' ? [packagePath] : packagePath, baseContentUrl, baseImagesUrl, yarn, preRelease, dependencies, skipDuplicate })
+            publish({ extensionFile, registryUrl, pat, targets: typeof target === 'string' ? [target] : target, packagePath: typeof packagePath === 'string' ? [packagePath] : packagePath, baseContentUrl, baseImagesUrl, yarn, preRelease, dependencies, skipDuplicate, packageVersion })
                 .then(results => {
                     const reasons = results.filter(result => result.status === 'rejected')
-                        .map(result => result as PromiseRejectedResult)
                         .map(rejectedResult => rejectedResult.reason);
 
                     if (reasons.length > 0) {
                         const message = 'See the documentation for more information:\n'
-                        + 'https://github.com/eclipse/openvsx/wiki/Publishing-Extensions';
+                            + 'https://github.com/eclipse/openvsx/wiki/Publishing-Extensions';
                         const errorHandler = handleError(program.debug, message, false);
                         for (const reason of reasons) {
                             errorHandler(reason);
@@ -99,6 +102,19 @@ module.exports = function (argv: string[]): void {
                 .catch(handleError(program.debug));
         });
 
+    const loginCmd = program.command('login <namespace>');
+    loginCmd.description('Adds a namespace to the list of known namespaces')
+        .action((namespace: string) => {
+            const { registryUrl, pat } = program.opts();
+            login({ namespace, registryUrl, pat }).catch(handleError(program.debug));
+        });
+
+    const logoutCmd = program.command('logout <namespace>');
+    logoutCmd.description('Removes a namespace from the list of known namespaces')
+        .action((namespace: string) => {
+            logout(namespace).catch(handleError(program.debug));
+        });
+
     program
         .command('*', '', { noHelp: true })
         .action((cmd: commander.Command) => {

package/src/ovsx

@@ -2,8 +2,8 @@
 
 const semver = require('semver');
 
-if (semver.lt(process.versions.node, '18.0.0')) {
-    console.error('ovsx requires at least NodeJS version 18. Check your installed version with `node --version`.');
+if (semver.lt(process.versions.node, '20.0.0')) {
+    console.error('ovsx requires at least NodeJS version 20. Check your installed version with `node --version`.');
     process.exit(1);
 }
 

package/src/publish.ts

@@ -8,32 +8,29 @@
  * SPDX-License-Identifier: EPL-2.0
  ********************************************************************************/
 import { createVSIX, IPackageOptions } from '@vscode/vsce';
-import { createTempFile, addEnvOptions } from './util';
+import { createTempFile, addEnvOptions, getPAT } from './util';
 import { Extension, Registry, RegistryOptions } from './registry';
 import { checkLicense } from './check-license';
+import { readVSIXPackage } from './zip';
 
 /**
  * Publishes an extension.
  */
 export async function publish(options: PublishOptions = {}): Promise<PromiseSettledResult<void>[]> {
-        addEnvOptions(options);
-        const internalPublishOptions: InternalPublishOptions[] = [];
-        const packagePaths = options.packagePath || [undefined];
-        const targets = options.targets || [undefined];
-        for (const packagePath of packagePaths) {
-            for (const target of targets) {
-                internalPublishOptions.push({ ... options, packagePath: packagePath, target: target });
-            }
+    addEnvOptions(options);
+    const internalPublishOptions: InternalPublishOptions[] = [];
+    const packagePaths = options.packagePath || [undefined];
+    const targets = options.targets || [undefined];
+    for (const packagePath of packagePaths) {
+        for (const target of targets) {
+            internalPublishOptions.push({ ...options, packagePath: packagePath, target: target });
         }
+    }
 
-        return Promise.allSettled(internalPublishOptions.map(publishOptions => doPublish(publishOptions)));
+    return Promise.allSettled(internalPublishOptions.map(publishOptions => doPublish(publishOptions)));
 }
 
 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?.endsWith('.vsix')) {
         options.extensionFile = options.packagePath;
@@ -48,6 +45,11 @@ async function doPublish(options: InternalPublishOptions = {}): Promise<void> {
         console.warn("Ignoring option '--pre-release' for prepackaged extension.");
     }
 
+    if (!options.pat) {
+        const namespace = (await readVSIXPackage(options.extensionFile!)).publisher;
+        options.pat = await getPAT(namespace, options);
+    }
+
     let extension: Extension | undefined;
     try {
         extension = await registry.publish(options.extensionFile!, options.pat);
@@ -100,6 +102,10 @@ interface PublishCommonOptions extends RegistryOptions {
      * Whether to fail silently if version already exists on the marketplace
      */
     skipDuplicate?: boolean;
+    /**
+     * Extension version. Only valid with `packagePath`.
+     */
+    packageVersion?: string;
 }
 
 // Interface used by top level CLI
@@ -141,7 +147,7 @@ interface InternalPublishOptions extends PublishCommonOptions {
     /**
      * Whether to do dependency detection via npm or yarn
      */
-     dependencies?: boolean;
+    dependencies?: boolean;
 }
 
 async function packageExtension(options: InternalPublishOptions, registry: Registry): Promise<void> {
@@ -158,7 +164,8 @@ async function packageExtension(options: InternalPublishOptions, registry: Regis
         baseImagesUrl: options.baseImagesUrl,
         useYarn: options.yarn,
         dependencies: options.dependencies,
-        preRelease: options.preRelease
+        preRelease: options.preRelease,
+        version: options.packageVersion
     };
     await createVSIX(packageOptions);
 }

package/src/registry.ts

@@ -9,7 +9,6 @@
  ********************************************************************************/
 
 import * as http from 'http';
-import * as https from 'https';
 import * as fs from 'fs';
 import * as querystring from 'querystring';
 import * as followRedirects from 'follow-redirects';
@@ -167,10 +166,7 @@ export class Registry {
     }
 
     private getProtocol(url: URL) {
-        if (url.protocol === 'https:')
-            return followRedirects.https as typeof https;
-        else
-            return followRedirects.http as typeof http;
+        return url.protocol === 'https:' ? followRedirects.https : followRedirects.http;
     }
 
     private getRequestOptions(method?: string, headers?: http.OutgoingHttpHeaders, maxBodyLength?: number): http.RequestOptions {

package/src/store.ts

@@ -0,0 +1,142 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { homedir } from 'os';
+
+interface StoreEntry {
+    name: string
+    value: string
+}
+
+export interface Store extends Iterable<StoreEntry> {
+	readonly size: number;
+	get(name: string): string | undefined;
+	add(name: string, value: string): Promise<void>;
+	delete(name: string): Promise<void>;
+}
+
+export class FileStore implements Store {
+	private static readonly DefaultPath = path.join(homedir(), '.ovsx');
+
+	static async open(path: string = FileStore.DefaultPath): Promise<FileStore> {
+		try {
+			const rawStore = await fs.promises.readFile(path, 'utf8');
+			return new FileStore(path, JSON.parse(rawStore).entries);
+		} catch (err: any) {
+			if (err.code === 'ENOENT') {
+				return new FileStore(path, []);
+			} else if (/SyntaxError/.test(err)) {
+				throw new Error(`Error parsing file store: ${path}.`);
+			}
+
+			throw err;
+		}
+	}
+
+	get size(): number {
+		return this.entries.length;
+	}
+
+	private constructor(readonly path: string, private entries: StoreEntry[]) { }
+
+	private async save(): Promise<void> {
+		await fs.promises.writeFile(this.path, JSON.stringify({ entries: this.entries }), { mode: '0600' });
+	}
+
+	async deleteStore(): Promise<void> {
+		try {
+			await fs.promises.unlink(this.path);
+		} catch {
+			// noop
+		}
+	}
+
+	get(name: string): string | undefined {
+        return this.entries.find(p => p.name === name)?.value;
+	}
+
+	async add(name: string, value: string): Promise<void> {
+        const newEntry: StoreEntry = { name, value };
+		this.entries = [...this.entries.filter(p => p.name !== name), newEntry];
+		await this.save();
+	}
+
+	async delete(name: string): Promise<void> {
+		this.entries = this.entries.filter(p => p.name !== name);
+		await this.save();
+	}
+
+	[Symbol.iterator]() {
+		return this.entries[Symbol.iterator]();
+	}
+}
+
+export class KeytarStore implements Store {
+	static async open(serviceName = 'ovsx'): Promise<KeytarStore> {
+		const keytar = await import('keytar');
+		const creds = await keytar.findCredentials(serviceName);
+
+		return new KeytarStore(
+			keytar,
+			serviceName,
+			creds.map(({ account, password }) => ({ name: account, value: password }))
+		);
+	}
+
+	get size(): number {
+		return this.entries.length;
+	}
+
+	private constructor(
+		private readonly keytar: typeof import('keytar'),
+		private readonly serviceName: string,
+		private entries: StoreEntry[]
+	) { }
+
+	get(name: string): string | undefined {
+        return this.entries.find(p => p.name === name)?.value;
+	}
+
+	async add(name: string, value: string): Promise<void> {
+        const newEntry: StoreEntry = { name, value };
+		this.entries = [...this.entries.filter(p => p.name !== name), newEntry];
+		await this.keytar.setPassword(this.serviceName, name, value);
+	}
+
+	async delete(name: string): Promise<void> {
+		this.entries = this.entries.filter(p => p.name !== name);
+		await this.keytar.deletePassword(this.serviceName, name);
+	}
+
+	[Symbol.iterator](): Iterator<StoreEntry, any, undefined> {
+		return this.entries[Symbol.iterator]();
+	}
+}
+
+export async function openDefaultStore(): Promise<Store> {
+	if (/^file$/i.test(process.env['OVSX_STORE'] ?? '')) {
+		return await FileStore.open();
+	}
+
+	let keytarStore: Store;
+	try {
+		keytarStore = await KeytarStore.open();
+	} catch (err) {
+		const store = await FileStore.open();
+		console.warn(`Failed to open credential store. Falling back to storing secrets clear-text in: ${store.path}.`);
+		return store;
+	}
+
+	const fileStore = await FileStore.open();
+
+	// migrate from file store
+	if (fileStore.size) {
+		for (const { name, value } of fileStore) {
+			await keytarStore.add(name, value);
+		}
+
+		await fileStore.deleteStore();
+		console.info(`Migrated ${fileStore.size} publishers to system credential manager. Deleted local store '${fileStore.path}'.`);
+	}
+
+	return keytarStore;
+}

package/src/util.ts

@@ -14,6 +14,10 @@ import * as tmp from 'tmp';
 import * as http from 'http';
 import * as readline from 'readline';
 import { RegistryOptions } from './registry';
+import { VerifyPatOptions, doVerifyPat } from './verify-pat';
+import { PublishOptions } from './publish';
+import { openDefaultStore } from './store';
+import { CreateNamespaceOptions } from './create-namespace';
 
 export { promisify } from 'util';
 
@@ -183,3 +187,29 @@ export async function getUserChoice<R extends string>(text: string, values: R[],
     }
     return defaultValue;
 }
+
+export async function requestPAT(namespace: string, options: CreateNamespaceOptions | PublishOptions | VerifyPatOptions, verify: boolean = true): Promise<string> {
+    const pat = await getUserInput(`Personal Access Token for namespace '${namespace}':`);
+    if (verify) {
+        await doVerifyPat({ ...options, namespace, pat });
+    }
+
+    return pat;
+}
+
+export async function getPAT(namespace: string, options: CreateNamespaceOptions | PublishOptions | VerifyPatOptions, verify: boolean = true): Promise<string> {
+    if (options?.pat) {
+        return options.pat;
+    }
+
+    const store = await openDefaultStore();
+    let pat = store.get(namespace);
+    if (pat) {
+        return pat;
+    }
+
+    pat = await requestPAT(namespace, options, verify);
+    await store.add(namespace, pat);
+
+    return pat;
+}

package/src/verify-pat.ts

@@ -9,39 +9,42 @@
  ********************************************************************************/
 
 import { Registry, RegistryOptions } from './registry';
-import { readManifest, addEnvOptions } from './util';
+import { readManifest, addEnvOptions, getPAT } from './util';
 
 /**
  * Validates that a Personal Access Token can publish to a namespace.
  */
 export async function verifyPat(options: VerifyPatOptions): Promise<void> {
     addEnvOptions(options);
-    if (!options.pat) {
-        throw new Error("A personal access token must be given with the option '--pat'.");
-    }
-
     if (!options.namespace) {
-      let error;
-      try {
-        options.namespace = (await readManifest()).publisher;
-      } catch (e) {
-        error = e;
-      }
+        let error;
+        try {
+            options.namespace = (await readManifest()).publisher;
+        } catch (e) {
+            error = e;
+        }
 
-      if (!options.namespace) {
-        throw new Error(
-          `Unable to read the namespace's name. Please supply it as an argument or run ovsx from the extension folder.` +
-          (error ? `\n\n${error}` : '')
-        );
-      }
+        if (!options.namespace) {
+            throw new Error(
+                `Unable to read the namespace's name. Please supply it as an argument or run ovsx from the extension folder.` +
+                (error ? `\n\n${error}` : '')
+            );
+        }
     }
 
+    options.pat = await getPAT(options.namespace, options, false);
+    await doVerifyPat(options);
+}
+
+export async function doVerifyPat(options: VerifyPatOptions) {
     const registry = new Registry(options);
-    const result = await registry.verifyPat(options.namespace, options.pat);
+    const namespace = options.namespace as string;
+    const pat = options.pat as string;
+    const result = await registry.verifyPat(namespace, pat);
     if (result.error) {
         throw new Error(result.error);
     }
-    console.log(`\ud83d\ude80  PAT valid to publish at ${options.namespace}`);
+    console.log(`\ud83d\ude80  PAT valid to publish at ${namespace}`);
 }
 
 export interface VerifyPatOptions extends RegistryOptions {

package/src/version.ts

@@ -0,0 +1 @@
+export const LIB_VERSION = "0.10.1";

package/src/zip.ts

@@ -0,0 +1,55 @@
+import { Entry, open, ZipFile } from 'yauzl';
+import { Readable } from 'stream';
+import { Manifest } from './util';
+
+async function bufferStream(stream: Readable): Promise<Buffer> {
+	return await new Promise((resolve, reject) => {
+		const buffers: Buffer[] = [];
+		stream.on('data', buffer => buffers.push(buffer));
+		stream.once('error', reject);
+		stream.once('end', () => resolve(Buffer.concat(buffers)));
+	});
+}
+
+export async function readZip(packagePath: string, filter: (name: string) => boolean): Promise<Map<string, Buffer>> {
+	const zipfile = await new Promise<ZipFile>((resolve, reject) =>
+		open(packagePath, { lazyEntries: true }, (err, zipfile) => (err ? reject(err) : resolve(zipfile)))
+	);
+
+	return await new Promise((resolve, reject) => {
+		const result = new Map<string, Buffer>();
+
+		zipfile.once('close', () => resolve(result));
+
+		zipfile.readEntry();
+		zipfile.on('entry', (entry: Entry) => {
+			const name = entry.fileName.toLowerCase();
+
+			if (filter(name)) {
+				zipfile.openReadStream(entry, (err, stream) => {
+					if (err) {
+						zipfile.close();
+						return reject(err);
+					}
+
+					bufferStream(stream).then(buffer => {
+						result.set(name, buffer);
+						zipfile.readEntry();
+					});
+				});
+			} else {
+				zipfile.readEntry();
+			}
+		});
+	});
+}
+
+export async function readVSIXPackage(packagePath: string): Promise<Manifest> {
+	const map = await readZip(packagePath, name => /^extension\/package\.json$/i.test(name));
+	const rawManifest = map.get('extension/package.json');
+	if (!rawManifest) {
+		throw new Error('Manifest not found.');
+	}
+
+    return JSON.parse(rawManifest.toString('utf8')) as Manifest;
+}