@vscode/vsce 3.9.3-0 → 3.9.3-10

package/out/publish.js

@@ -40,21 +40,30 @@ exports.publish = publish;
 exports.unpublish = unpublish;
 exports.getPAT = getPAT;
 const fs = __importStar(require("fs"));
-const util_1 = require("util");
 const semver = __importStar(require("semver"));
 const GalleryInterfaces_1 = require("azure-devops-node-api/interfaces/GalleryInterfaces");
 const package_1 = require("./package");
-const tmp = __importStar(require("tmp"));
 const store_1 = require("./store");
-const util_2 = require("./util");
+const util_1 = require("./util");
 const zip_1 = require("./zip");
 const validation_1 = require("./validation");
 const form_data_1 = __importDefault(require("form-data"));
 const path_1 = require("path");
+const os_1 = require("os");
 const cockatiel_1 = require("cockatiel");
 const auth_1 = require("./auth");
-const tmpName = (0, util_1.promisify)(tmp.tmpName);
+const oidc_1 = require("./oidc");
+async function withTemporaryPackage(fn) {
+    const directory = await fs.promises.mkdtemp((0, path_1.join)((0, os_1.tmpdir)(), 'vsce-'));
+    try {
+        return await fn((0, path_1.join)(directory, 'extension.vsix'));
+    }
+    finally {
+        await fs.promises.rm(directory, { recursive: true, force: true });
+    }
+}
 async function publish(options = {}) {
+    validateAuthenticationOptions(options);
     if (options.packagePath) {
         if (options.version) {
             throw new Error(`Both options not supported simultaneously: 'packagePath' and 'version'.`);
@@ -106,38 +115,40 @@ async function publish(options = {}) {
     else {
         const cwd = options.cwd || process.cwd();
         const manifest = await (0, package_1.readManifest)(cwd);
-        (0, util_2.patchOptionsWithManifest)(options, manifest);
+        (0, util_1.patchOptionsWithManifest)(options, manifest);
         // Validate marketplace requirements before prepublish to avoid unnecessary work
         validateManifestForPublishing(manifest, options);
         await (0, package_1.prepublish)(cwd, manifest, options.useYarn);
         await (0, package_1.versionBump)(options);
         if (options.targets) {
             for (const target of options.targets) {
-                const packagePath = await tmpName();
-                const packageResult = await (0, package_1.pack)({ ...options, target, packagePath });
-                const manifestValidated = validateManifestForPublishing(packageResult.manifest, options);
-                const sigzipPath = options.signTool ? await (0, package_1.signPackage)(packagePath, options.signTool) : undefined;
-                await _publish(packagePath, sigzipPath, manifestValidated, { ...options, target });
+                await withTemporaryPackage(async (packagePath) => {
+                    const packageResult = await (0, package_1.pack)({ ...options, target, packagePath });
+                    const manifestValidated = validateManifestForPublishing(packageResult.manifest, options);
+                    const sigzipPath = options.signTool ? await (0, package_1.signPackage)(packagePath, options.signTool) : undefined;
+                    await _publish(packagePath, sigzipPath, manifestValidated, { ...options, target });
+                });
             }
         }
         else {
-            const packagePath = await tmpName();
-            const packageResult = await (0, package_1.pack)({ ...options, packagePath });
-            const manifestValidated = validateManifestForPublishing(packageResult.manifest, options);
-            const sigzipPath = options.signTool ? await (0, package_1.signPackage)(packagePath, options.signTool) : undefined;
-            await _publish(packagePath, sigzipPath, manifestValidated, options);
+            await withTemporaryPackage(async (packagePath) => {
+                const packageResult = await (0, package_1.pack)({ ...options, packagePath });
+                const manifestValidated = validateManifestForPublishing(packageResult.manifest, options);
+                const sigzipPath = options.signTool ? await (0, package_1.signPackage)(packagePath, options.signTool) : undefined;
+                await _publish(packagePath, sigzipPath, manifestValidated, options);
+            });
         }
     }
 }
 async function _publish(packagePath, sigzipPath, manifest, options) {
     const pat = await getPAT(manifest.publisher, options);
-    const api = await (0, util_2.getGalleryAPI)(pat);
+    const api = await (0, util_1.getGalleryAPI)(pat);
     const packageStream = fs.createReadStream(packagePath);
     const name = `${manifest.publisher}.${manifest.name}`;
     const description = options.target
         ? `${name} (${options.target}) v${manifest.version}`
         : `${name} v${manifest.version}`;
-    util_2.log.info(`Publishing '${description}'...`);
+    util_1.log.info(`Publishing '${description}'...`);
     let extension = null;
     try {
         try {
@@ -153,7 +164,7 @@ async function _publish(packagePath, sigzipPath, manifest, options) {
                 (v.targetPlatform === options.target));
             if (versionExists) {
                 if (options.skipDuplicate) {
-                    util_2.log.done(`Version ${manifest.version} is already published. Skipping publish.`);
+                    util_1.log.done(`Version ${manifest.version} is already published. Skipping publish.`);
                     return;
                 }
                 else {
@@ -170,7 +181,7 @@ async function _publish(packagePath, sigzipPath, manifest, options) {
                 catch (err) {
                     if (err.statusCode === 409) {
                         if (options.skipDuplicate) {
-                            util_2.log.done(`Version ${manifest.version} is already published. Skipping publish.`);
+                            util_1.log.done(`Version ${manifest.version} is already published. Skipping publish.`);
                             return;
                         }
                         else {
@@ -202,9 +213,9 @@ async function _publish(packagePath, sigzipPath, manifest, options) {
         }
         throw err;
     }
-    util_2.log.info(`Extension URL (might take a few minutes): ${(0, util_2.getPublishedUrl)(name)}`);
-    util_2.log.info(`Hub URL: ${(0, util_2.getHubUrl)(manifest.publisher, manifest.name)}`);
-    util_2.log.done(`Published ${description}.`);
+    util_1.log.info(`Extension URL (might take a few minutes): ${(0, util_1.getPublishedUrl)(name)}`);
+    util_1.log.info(`Hub URL: ${(0, util_1.getHubUrl)(manifest.publisher, manifest.name)}`);
+    util_1.log.done(`Published ${description}.`);
 }
 async function _publishSignedPackage(api, packageName, packageStream, sigzipName, sigzipStream, manifest) {
     const extensionType = 'Visual Studio Code';
@@ -219,7 +230,7 @@ async function _publishSignedPackage(api, packageName, packageStream, sigzipName
     });
     const publishWithRetry = (0, cockatiel_1.retry)((0, cockatiel_1.handleWhen)(err => err.message.includes('timeout')), {
         maxAttempts: 3,
-        backoff: new cockatiel_1.IterableBackoff([5000, 10000, 20000])
+        backoff: new cockatiel_1.IterableBackoff([5_000, 10_000, 20_000])
     });
     return await publishWithRetry.execute(async () => {
         return await api.publishExtensionWithPublisherSignature(undefined, form, manifest.publisher, manifest.name, extensionType);
@@ -237,15 +248,15 @@ async function unpublish(options = {}) {
     }
     const fullName = `${publisher}.${name}`;
     if (!options.force) {
-        const answer = await (0, util_2.read)(`This will delete ALL published versions! Please type '${fullName}' to confirm: `);
+        const answer = await (0, util_1.read)(`This will delete ALL published versions! Please type '${fullName}' to confirm: `);
         if (answer !== fullName) {
             throw new Error('Aborted');
         }
     }
     const pat = await getPAT(publisher, options);
-    const api = await (0, util_2.getGalleryAPI)(pat);
+    const api = await (0, util_1.getGalleryAPI)(pat);
     await api.deleteExtension(publisher, name);
-    util_2.log.done(`Deleted extension: ${fullName}!`);
+    util_1.log.done(`Deleted extension: ${fullName}!`);
 }
 function validateManifestForPublishing(manifest, options) {
     if (manifest.enableProposedApi && !options.allowAllProposedApis && !options.noVerify) {
@@ -260,6 +271,10 @@ function validateManifestForPublishing(manifest, options) {
     return { ...manifest, publisher: (0, validation_1.validatePublisher)(manifest.publisher) };
 }
 async function getPAT(publisher, options) {
+    validateAuthenticationOptions(options);
+    if (options.oidc) {
+        return await (0, oidc_1.getOIDCCredential)(publisher);
+    }
     if (options.pat) {
         return options.pat;
     }
@@ -268,4 +283,15 @@ async function getPAT(publisher, options) {
     }
     return (await (0, store_1.getPublisher)(publisher)).pat;
 }
+function validateAuthenticationOptions(options) {
+    if (!options.oidc) {
+        return;
+    }
+    if (options.pat) {
+        throw new Error(`The '--oidc' and '--pat' options cannot be used together.`);
+    }
+    if (options.azureCredential) {
+        throw new Error(`The '--oidc' and '--azure-credential' options cannot be used together.`);
+    }
+}
 //# sourceMappingURL=publish.js.map

package/out/secretLint.js

@@ -1,4 +1,37 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -8,7 +41,9 @@ exports.lintText = lintText;
 exports.getRuleNameFromRuleId = getRuleNameFromRuleId;
 exports.prettyPrintLintResult = prettyPrintLintResult;
 const chalk_1 = __importDefault(require("chalk"));
-const secret_lint_types_1 = require("./typings/secret-lint-types");
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const url_1 = require("url");
 const util_1 = require("./util");
 const secretsScanningRules = [
     {
@@ -45,100 +80,138 @@ const dotEnvRules = [
         id: "@secretlint/secretlint-rule-no-dotenv"
     }
 ];
-// Helper function to dynamically import the createEngine function
-async function getEngine(scanSecrets, scanDotEnv) {
-    // Use a raw dynamic import that will not be transformed
-    // This is necessary because @secretlint/node is an ESM module
-    const secretlintModule = await eval('import("@secretlint/node")');
+async function getConfig(scanSecrets, scanDotEnv) {
+    const [{ creator: recommend }, { creator: noDotenv }] = await Promise.all([
+        importSecretLintRule("@secretlint/secretlint-rule-preset-recommend"),
+        importSecretLintRule("@secretlint/secretlint-rule-no-dotenv")
+    ]);
     const rules = [];
     if (scanSecrets) {
-        rules.push(...secretsScanningRules);
+        rules.push({
+            ...secretsScanningRules[0],
+            rule: recommend
+        });
     }
     if (scanDotEnv) {
-        rules.push(...dotEnvRules);
+        rules.push({
+            ...dotEnvRules[0],
+            rule: noDotenv
+        });
     }
-    const lintOptions = {
-        configFileJSON: { rules: rules },
-        formatter: "@secretlint/secretlint-formatter-sarif", // checkstyle, compact, jslint-xml, junit, pretty-error, stylish, tap, unix, json, mask-result, table
-        color: true,
-        maskSecrets: false
-    };
-    const engine = await secretlintModule.createEngine(lintOptions);
-    return engine;
+    return { rules };
+}
+function importSecretLintRule(packageName) {
+    return import(packageName);
+}
+async function mapConcurrently(values, mapper) {
+    const results = new Array(values.length);
+    let nextIndex = 0;
+    async function worker() {
+        while (nextIndex < values.length) {
+            const index = nextIndex++;
+            results[index] = await mapper(values[index]);
+        }
+    }
+    const workerCount = Math.min(os.availableParallelism(), values.length);
+    await Promise.all(Array.from({ length: workerCount }, worker));
+    return results;
 }
 async function lintFiles(filePaths, scanSecrets, scanDotEnv) {
-    const engine = await getEngine(scanSecrets, scanDotEnv);
-    let engineResult;
+    let results;
     try {
-        engineResult = await engine.executeOnFiles({
-            filePathList: filePaths
-        });
+        const [{ lintSource }, { createRawSource }, config] = await Promise.all([
+            import("@secretlint/core"),
+            import("@secretlint/source-creator"),
+            getConfig(scanSecrets, scanDotEnv)
+        ]);
+        results = await mapConcurrently(filePaths, async (filePath) => lintSource({
+            source: await createRawSource(filePath),
+            options: {
+                config,
+                maskSecrets: false
+            }
+        }));
     }
     catch (error) {
         util_1.log.error('Error occurred while scanning secrets (files):', error);
         process.exit(1);
     }
-    return parseResult(engineResult);
+    return parseResult(results);
 }
 async function lintText(content, fileName, scanSecrets, scanDotEnv) {
-    const engine = await getEngine(scanSecrets, scanDotEnv);
-    let engineResult;
+    let result;
     try {
-        engineResult = await engine.executeOnContent({
-            content,
-            filePath: fileName
+        const [{ lintSource }, config] = await Promise.all([
+            import("@secretlint/core"),
+            getConfig(scanSecrets, scanDotEnv)
+        ]);
+        result = await lintSource({
+            source: {
+                content,
+                filePath: fileName,
+                ext: path.extname(fileName),
+                contentType: "text"
+            },
+            options: {
+                config,
+                maskSecrets: false
+            }
         });
     }
     catch (error) {
         util_1.log.error('Error occurred while scanning secrets (content):', error);
         process.exit(1);
     }
-    return parseResult(engineResult);
+    return parseResult([result]);
+}
+function parseResult(fileResults) {
+    const results = fileResults.flatMap(fileResult => fileResult.messages.map((message) => ({
+        message: message.message,
+        ruleId: message.ruleParentId ? `${message.ruleParentId} > ${message.ruleId}` : message.ruleId,
+        level: message.severity === "info" ? "note" : message.severity,
+        filePath: process.env.SARIF_URI_ABSOLUTE
+            ? (0, url_1.pathToFileURL)(fileResult.filePath).toString()
+            : path.relative(process.cwd(), fileResult.filePath),
+        startLine: fixLine(message.loc.start.line),
+        startColumn: fixColumn(message.loc.start.column),
+        endLine: fixLine(message.loc.end.line),
+        endColumn: fixColumn(message.loc.end.column)
+    })));
+    return {
+        ok: !fileResults.some(fileResult => fileResult.messages.some(message => message.severity === "error")),
+        results
+    };
 }
-function parseResult(result) {
-    const output = secret_lint_types_1.Convert.toSecretLintOutput(result.output);
-    const results = output.runs.at(0)?.results ?? [];
-    return { ok: result.ok, results };
+function fixLine(value) {
+    return value === null ? undefined : value === 0 ? 1 : value;
+}
+function fixColumn(value) {
+    return value === null ? undefined : value === 0 ? 1 : value + 1;
 }
 function getRuleNameFromRuleId(ruleId) {
     const parts = ruleId.split('-rule-');
     return parts[parts.length - 1];
 }
 function prettyPrintLintResult(result) {
-    if (!result.message.text) {
-        return JSON.stringify(result);
-    }
-    const text = result.message.text;
-    const titleColor = result.level === undefined || result.level === secret_lint_types_1.Level.Error ? chalk_1.default.bold.red : chalk_1.default.bold.yellow;
+    const text = result.message;
+    const titleColor = result.level === "error" ? chalk_1.default.bold.red : chalk_1.default.bold.yellow;
     const title = text.length > 54 ? text.slice(0, 50) + '...' : text;
-    const ruleName = result.ruleId ? getRuleNameFromRuleId(result.ruleId) : 'unknown';
+    const ruleName = getRuleNameFromRuleId(result.ruleId);
     let output = `\t${titleColor(title)} [${ruleName}]\n`;
-    if (result.locations) {
-        result.locations.forEach(location => {
-            output += `\t${prettyPrintLocation(location)}\n`;
-        });
-    }
+    output += `\t${prettyPrintLocation(result)}\n`;
     return output;
 }
-function prettyPrintLocation(location) {
-    if (!location.physicalLocation) {
-        return JSON.stringify(location);
-    }
-    const uri = location.physicalLocation.artifactLocation?.uri;
-    if (!uri) {
-        return JSON.stringify(location);
-    }
-    let output = uri;
-    const region = location.physicalLocation.region;
-    const regionStringified = region ? prettyPrintRegion(region) : undefined;
+function prettyPrintLocation(result) {
+    let output = result.filePath;
+    const regionStringified = prettyPrintRegion(result);
     if (regionStringified) {
         output += `#${regionStringified}`;
     }
     return output;
 }
-function prettyPrintRegion(region) {
-    const startPosition = prettyPrintPosition(region.startLine, region.startColumn);
-    const endPosition = prettyPrintPosition(region.endLine, region.endColumn);
+function prettyPrintRegion(result) {
+    const startPosition = prettyPrintPosition(result.startLine, result.startColumn);
+    const endPosition = prettyPrintPosition(result.endLine, result.endColumn);
     if (!startPosition) {
         return undefined;
     }

package/out/store.js

@@ -49,6 +49,9 @@ const package_1 = require("./package");
 const publish_1 = require("./publish");
 ;
 class FileStore {
+    path;
+    publishers;
+    static DefaultPath = path.join((0, os_1.homedir)(), '.vsce');
     static async open(path = FileStore.DefaultPath) {
         try {
             const rawStore = await fs.promises.readFile(path, 'utf8');
@@ -98,10 +101,12 @@ class FileStore {
     }
 }
 exports.FileStore = FileStore;
-FileStore.DefaultPath = path.join((0, os_1.homedir)(), '.vsce');
 class KeytarStore {
+    keytar;
+    serviceName;
+    publishers;
     static async open(serviceName = 'vscode-vsce') {
-        const keytar = await import('keytar').then(module => module.default);
+        const keytar = require('@napi-rs/keyring/keytar.js');
         const creds = await keytar.findCredentials(serviceName);
         return new KeytarStore(keytar, serviceName, creds.map(({ account, password }) => ({ name: account, pat: password })));
     }

package/out/util.js

@@ -118,10 +118,8 @@ function isCancelledError(error) {
     return error === CancelledError;
 }
 class CancellationToken {
-    constructor() {
-        this.listeners = [];
-        this._cancelled = false;
-    }
+    listeners = [];
+    _cancelled = false;
     get isCancelled() {
         return this._cancelled;
     }

package/out/validation.js

@@ -32,9 +32,6 @@ var __importStar = (this && this.__importStar) || (function () {
         return result;
     };
 })();
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.validatePublisher = validatePublisher;
 exports.validateExtensionName = validateExtensionName;
@@ -43,8 +40,8 @@ exports.validateEngineCompatibility = validateEngineCompatibility;
 exports.validateVSCodeTypesCompatibility = validateVSCodeTypesCompatibility;
 exports.validateExtensionDependencies = validateExtensionDependencies;
 const semver = __importStar(require("semver"));
-const parse_semver_1 = __importDefault(require("parse-semver"));
 const util_1 = require("./util");
+const packageSpec_1 = require("./packageSpec");
 const nameRegex = /^[a-z0-9][a-z0-9\-]*$/i;
 function validatePublisher(publisher) {
     if (!publisher) {
@@ -97,14 +94,14 @@ function validateVSCodeTypesCompatibility(engineVersion, typeVersion) {
     }
     let plainEngineVersion, plainTypeVersion;
     try {
-        const engineSemver = (0, parse_semver_1.default)(`vscode@${engineVersion}`);
+        const engineSemver = (0, packageSpec_1.parsePackageSpec)(`vscode@${engineVersion}`);
         plainEngineVersion = engineSemver.version;
     }
     catch (err) {
         throw new Error('Failed to parse semver of engines.vscode');
     }
     try {
-        const typeSemver = (0, parse_semver_1.default)(`@types/vscode@${typeVersion}`);
+        const typeSemver = (0, packageSpec_1.parsePackageSpec)(`@types/vscode@${typeVersion}`);
         plainTypeVersion = typeSemver.version;
     }
     catch (err) {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@vscode/vsce",
-	"version": "3.9.3-0",
+	"version": "3.9.3-10",
 	"description": "VS Code Extensions Manager",
 	"repository": {
 		"type": "git",
@@ -36,33 +36,32 @@
 		"watch:test": "npm run test -- --watch"
 	},
 	"engines": {
-		"node": ">= 20"
+		"node": ">= 22"
 	},
 	"dependencies": {
 		"@azure/identity": "^4.1.0",
-		"@secretlint/node": "^10.1.2",
-		"@secretlint/secretlint-formatter-sarif": "^10.1.2",
+		"@napi-rs/keyring": "^1.3.0",
+		"@secretlint/core": "^10.1.2",
 		"@secretlint/secretlint-rule-no-dotenv": "^10.1.2",
 		"@secretlint/secretlint-rule-preset-recommend": "^10.1.2",
+		"@secretlint/source-creator": "^10.1.2",
+		"@secretlint/types": "^10.1.2",
 		"@vscode/vsce-sign": "^2.0.0",
 		"azure-devops-node-api": "^12.5.0",
 		"chalk": "^4.1.2",
-		"cheerio": "^1.0.0-rc.9",
 		"cockatiel": "^3.1.2",
 		"commander": "^12.1.0",
 		"form-data": "^4.0.0",
-		"glob": "^13.0.6",
 		"hosted-git-info": "^4.0.2",
 		"jsonc-parser": "^3.2.0",
 		"leven": "^3.1.0",
-		"markdown-it": "^14.1.0",
+		"marked": "^18.0.10",
 		"mime": "^1.3.4",
 		"minimatch": "^10.2.2",
-		"parse-semver": "^1.1.1",
+		"parse5": "^8.0.1",
 		"read": "^1.0.7",
-		"secretlint": "^10.1.2",
 		"semver": "^7.5.2",
-		"tmp": "^0.2.3",
+		"tinyglobby": "^0.2.17",
 		"typed-rest-client": "^1.8.4",
 		"url-join": "^4.0.1",
 		"xml2js": "^0.5.0",
@@ -71,28 +70,21 @@
 	},
 	"devDependencies": {
 		"@microsoft/api-extractor": "^7.33.7",
-		"@types/cheerio": "^0.22.29",
-		"@types/glob": "^8.1.0",
 		"@types/hosted-git-info": "^3.0.2",
-		"@types/markdown-it": "^0.0.2",
 		"@types/mime": "^1",
 		"@types/mocha": "^7.0.2",
-		"@types/node": "^20.0.0",
+		"@types/node": "^22.0.0",
+		"@types/picomatch": "^4.0.3",
 		"@types/read": "^0.0.28",
 		"@types/semver": "^6.0.0",
-		"@types/tmp": "^0.2.2",
 		"@types/url-join": "^4.0.1",
 		"@types/xml2js": "^0.4.4",
 		"@types/yauzl": "^2.9.2",
 		"@types/yazl": "^2.4.2",
 		"mocha": "^11.1.0",
-		"source-map-support": "^0.4.2",
 		"ts-node": "^10.9.1",
 		"typescript": "~5.9.0"
 	},
-	"optionalDependencies": {
-		"keytar": "^7.7.0"
-	},
 	"mocha": {
 		"require": [
 			"ts-node/register"