ovsx 1.2.0 → 1.4.0

package/src/util.ts

@@ -8,15 +8,15 @@
  * SPDX-License-Identifier: EPL-2.0
  ********************************************************************************/
 
+import * as crypto from 'crypto';
 import * as fs from 'fs';
+import * as os from 'os';
 import * as path from 'path';
-import * as tmp from 'tmp';
 import * as http from 'http';
+import { InvalidArgumentError } from 'commander';
 import { RegistryOptions } from './registry-options';
 import { TrustedPublishingOptions } from './trusted-publishing-options';
 
-export { promisify } from 'util';
-
 export function addEnvOptions(options: RegistryOptions): void {
     options.registryUrl ??= process.env.OVSX_REGISTRY_URL;
     options.pat ??= process.env.OVSX_PAT;
@@ -29,6 +29,7 @@ export function addTrustedPublishingEnvOptions(options: TrustedPublishingOptions
     options.trustedPublishing ??= parseBooleanEnv(process.env.OVSX_TRUSTED_PUBLISHING);
     options.idToken ??= process.env.OVSX_ID_TOKEN;
     options.oidcAudience ??= process.env.OVSX_OIDC_AUDIENCE;
+    options.registrationCode ??= process.env.OVSX_REGISTRATION_CODE;
 }
 
 /** How long a request may make no progress before it is abandoned; see RegistryOptions.timeout. */
@@ -67,7 +68,8 @@ function parseBooleanEnv(value?: string): boolean | undefined {
 export function parseNonNegativeInt(value: string): number {
     const parsed = Number(value);
     if (!Number.isInteger(parsed) || parsed < 0) {
-        throw new Error(`Expected a non-negative whole number, got '${value}'.`);
+        // Commander prints only this error type as a usage message; anything else escapes as a stack trace.
+        throw new InvalidArgumentError(`Expected a non-negative whole number, got '${value}'.`);
     }
     return parsed;
 }
@@ -76,36 +78,39 @@ export function matchExtensionId(id: string): RegExpExecArray | null {
     return /^([\w-]+)(?:\.|\/)([\w-]+)$/.exec(id);
 }
 
-export function optionalStat(path: fs.PathLike): Promise<fs.Stats | undefined> {
-    return new Promise((resolve, reject) => {
-        fs.stat(path, (err, stats) => resolve(stats));
-    });
-}
-
-export function makeDirs(path: fs.PathLike): Promise<void> {
-    return new Promise((resolve, reject) => {
-        if (fs.existsSync(path)) {
-            resolve();
-        } else {
-            fs.mkdir(path, { recursive: true }, (err: NodeJS.ErrnoException | null) => {
-                if (err)
-                    reject(err);
-                else
-                    resolve();
-            });
+/**
+ * Levenshtein distance between `a` and `b`: the minimum number of single-character insertions,
+ * deletions or substitutions needed to turn one into the other. Used to suggest the closest known
+ * command for a typo.
+ */
+export function levenshtein(a: string, b: string): number {
+    if (a === b) {
+        return 0;
+    }
+    // The distance is symmetric, so keep the shorter string in `b` to bound the row size.
+    if (b.length > a.length) {
+        [a, b] = [b, a];
+    }
+    // A single row of the edit distance matrix, seeded with the distance between the empty prefix
+    // of `a` and every prefix of `b`.
+    const row = Array.from({ length: b.length + 1 }, (_, j) => j);
+    for (let i = 1; i <= a.length; i++) {
+        let diagonal = row[0];
+        row[0] = i;
+        for (let j = 1; j <= b.length; j++) {
+            const above = row[j];
+            row[j] = Math.min(row[j - 1] + 1, above + 1, diagonal + (a[i - 1] === b[j - 1] ? 0 : 1));
+            diagonal = above;
         }
-    });
+    }
+    return row[b.length];
 }
 
-export function createTempFile(options: tmp.TmpNameOptions): Promise<string> {
-    return new Promise((resolve, reject) => {
-        tmp.tmpName(options, (err: Error | null, name: string) => {
-            if (err)
-                reject(err);
-            else
-                resolve(name);
-        });
-    });
+/**
+ * Returns a random, not-yet-created file path ending in `postfix`, directly in the OS temp directory.
+ */
+export function getTempFilePath(postfix = ''): string {
+    return path.join(os.tmpdir(), `ovsx-${crypto.randomUUID()}${postfix}`);
 }
 
 export function rejectError(err: any) {
@@ -135,9 +140,9 @@ export function handleError(debug?: boolean, additionalMessage?: string, exit: b
 }
 
 /**
- * Formats a byte count for display, e.g. `1536` -> `1.5 KB`. Mirrors the registry's own
- * `FileUtils.byteCountToDisplaySize` formatting so client- and server-side size limit messages read
- * the same way.
+ * Formats a byte count for display, rounding down, e.g. `1536` -> `1 KB` and `1048577` -> `1 MB`.
+ * Mirrors the registry's own `FileUtils.byteCountToDisplaySize` formatting so client- and
+ * server-side size limit messages read the same way.
  */
 export function formatBytes(bytes: number): string {
     const units = ['bytes', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB'];
@@ -167,10 +172,12 @@ export function withStatus(error: Error, status?: number): StatusError {
 /**
  * A URL in the form it can safely be printed: no user info and no query string.
  *
- * `createNamespace`, `verifyPat`, `publish` and `delete` all put the personal access token in a
- * `token` query parameter, and an error message goes straight to stderr and from there into CI logs.
- * The query carries nothing an error needs, so it is dropped whole rather than filtered key by key -
- * a filter has to be kept in step with every parameter anyone ever adds.
+ * The personal access token travels in a header now, but `createNamespace`, `verifyPat`, `publish`
+ * and `delete` still carry it in the query string too when talking to a registry too old to resolve
+ * it from the header (see `Registry.tokenQuery`, #1344). An error message goes straight to stderr
+ * and from there into CI logs, and the query carries nothing an error needs - so it stays dropped
+ * whole rather than filtered key by key, a filter having to be kept in step with every parameter
+ * anyone ever adds.
  */
 export function redactUrl(url: URL | string): string {
     try {
@@ -189,24 +196,8 @@ export function statusError(response: http.IncomingMessage): StatusError {
     return withStatus(new Error(message), response.statusCode);
 }
 
-export function readFile(name: string, packagePath?: string, encoding: BufferEncoding = 'utf-8'): Promise<string> {
-    return new Promise((resolve, reject) => {
-        fs.readFile(
-            path.join(packagePath ?? process.cwd(), name),
-            { encoding },
-            (err: NodeJS.ErrnoException | null, content: string) => {
-                if (err) {
-                    reject(err);
-                } else {
-                    resolve(content);
-                }
-            }
-        );
-    });
-}
-
 export async function readManifest(packagePath?: string): Promise<Manifest> {
-    const content = await readFile('package.json', packagePath);
+    const content = await fs.promises.readFile(path.join(packagePath ?? process.cwd(), 'package.json'), 'utf-8');
     return JSON.parse(content);
 }
 
@@ -222,26 +213,9 @@ export function validateManifest(manifest: Manifest): void {
     }
 }
 
-export function writeFile(name: string, content: string, packagePath?: string, encoding: BufferEncoding = 'utf-8'): Promise<void> {
-    return new Promise((resolve, reject) => {
-        fs.writeFile(
-            path.join(packagePath ?? process.cwd(), name),
-            content,
-            { encoding },
-            (err: NodeJS.ErrnoException | null) => {
-                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);
+    return fs.promises.writeFile(path.join(packagePath ?? process.cwd(), 'package.json'), content, 'utf-8');
 }
 
 export interface Manifest {

package/src/verify-pat.ts

@@ -33,6 +33,8 @@ export async function verifyPat(options: VerifyPatOptions): Promise<void> {
         }
     }
 
-    options.pat = await getPAT(options.namespace, options, false);
+    const { pat, save } = await getPAT(options.namespace, options, false);
+    options.pat = pat;
     await doVerifyPat(options);
+    await save();
 }

package/src/verify.ts

@@ -14,7 +14,7 @@
 import * as crypto from 'crypto';
 import * as fs from 'fs';
 import { Registry, Extension } from './registry';
-import { addEnvOptions, createTempFile } from './util';
+import { addEnvOptions, getTempFilePath } from './util';
 import { readVSIXPackage, readZip } from './zip';
 import { VerifyOptions } from './verify-options';
 
@@ -82,7 +82,7 @@ async function resolveVersion(registry: Registry, extension: Extension, version:
 }
 
 async function downloadSignature(registry: Registry, url: string): Promise<Buffer> {
-    const sigzipPath = await createTempFile({ postfix: '.sigzip' });
+    const sigzipPath = getTempFilePath('.sigzip');
     try {
         await registry.download(sigzipPath, new URL(url));
         const entries = await readZip(sigzipPath, name => name === SIGNATURE_ENTRY);
@@ -97,7 +97,7 @@ async function downloadSignature(registry: Registry, url: string): Promise<Buffe
 }
 
 async function downloadPublicKey(registry: Registry, url: string): Promise<string> {
-    const publicKeyPath = await createTempFile({ postfix: '.pem' });
+    const publicKeyPath = getTempFilePath('.pem');
     try {
         await registry.download(publicKeyPath, new URL(url));
         return await fs.promises.readFile(publicKeyPath, 'utf-8');

package/src/zip.ts

@@ -9,19 +9,10 @@
  ********************************************************************************/
 import * as crypto from 'crypto';
 import * as yauzl from 'yauzl-promise';
-import { Readable } from 'stream';
+import { buffer } from 'stream/consumers';
 import { pipeline } from 'stream/promises';
 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 result = new Map<string, Buffer>();
 	const zipfile = await yauzl.open(packagePath);
@@ -30,8 +21,7 @@ export async function readZip(packagePath: string, filter: (name: string) => boo
 			const name = entry.filename.toLowerCase();
 			if (filter(name)) {
 				const stream = await zipfile.openReadStream(entry);
-				const buffer = await bufferStream(stream);
-				result.set(name, buffer);
+				result.set(name, await buffer(stream));
 			}
 		}
 	} finally {

package/lib/version.d.ts

@@ -1,2 +0,0 @@
-export declare const LIB_VERSION = "1.2.0";
-//# sourceMappingURL=version.d.ts.map

package/lib/version.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"version.d.ts","sourceRoot":"","sources":["../src/version.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,WAAW,UAAU,CAAC"}

package/lib/version.js

@@ -1,5 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LIB_VERSION = void 0;
-exports.LIB_VERSION = "1.2.0";
-//# sourceMappingURL=version.js.map

package/lib/version.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"version.js","sourceRoot":"","sources":["../src/version.ts"],"names":[],"mappings":";;;AAAa,QAAA,WAAW,GAAG,OAAO,CAAC"}

package/src/version.ts

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