semantic-release-vsce 4.0.0 → 5.0.2

package/.github/dependabot.yml

@@ -0,0 +1,14 @@
+version: 2
+updates:
+  - package-ecosystem: npm
+    directory: /
+    schedule:
+      interval: daily
+    open-pull-requests-limit: 100
+  - package-ecosystem: github-actions
+    directory: /
+    schedule:
+      interval: daily
+    open-pull-requests-limit: 100
+    commit-message:
+      prefix: ci

package/.github/workflows/ci.yaml

@@ -0,0 +1,43 @@
+name: ci
+
+on:
+  push:
+    branches:
+      - master
+      - next
+  pull_request:
+    branches:
+      - master
+      - next
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+
+    strategy:
+      matrix:
+        node-version:
+          - 14
+          - 16
+
+    steps:
+      - uses: actions/checkout@v2
+      - uses: volta-cli/action@v1
+        with:
+          node-version: ${{ matrix.node-version }}
+      - run: npm ci
+      - run: npm test
+
+  release:
+    runs-on: ubuntu-latest
+
+    needs: test
+
+    steps:
+      - uses: actions/checkout@v2
+      - uses: volta-cli/action@v1
+      - run: npm ci
+      - run: npm run release
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          NPM_TOKEN: ${{ secrets.NPM_TOKEN }}

package/.husky/commit-msg

@@ -0,0 +1,4 @@
+#!/bin/sh
+. "$(dirname "$0")/_/husky.sh"
+
+npx --no-install commitlint --edit "$1"

package/.husky/pre-commit

@@ -0,0 +1,4 @@
+#!/bin/sh
+. "$(dirname "$0")/_/husky.sh"
+
+npm test

package/README.md

@@ -1,15 +1,14 @@
 # semantic-release-vsce
 
+[semantic-release](https://github.com/semantic-release/semantic-release) plugin to package and publish VS Code extensions.
+
 [![npm](https://img.shields.io/npm/v/semantic-release-vsce.svg)](https://www.npmjs.com/package/semantic-release-vsce)
 [![downloads](https://img.shields.io/npm/dt/semantic-release-vsce.svg)](https://www.npmjs.com/package/semantic-release-vsce)
-[![build](https://travis-ci.org/raix/semantic-release-vsce.svg?branch=master)](https://travis-ci.org/raix/semantic-release-vsce)
-[![dependencies](https://david-dm.org/raix/semantic-release-vsce/status.svg)](https://david-dm.org/raix/semantic-release-vsce)
-[![peerDependencies](https://david-dm.org/raix/semantic-release-vsce/peer-status.svg)](https://david-dm.org/raix/semantic-release-vsce?type=peer)
-[![Greenkeeper](https://badges.greenkeeper.io/raix/semantic-release-vsce.svg)](https://greenkeeper.io/)
+[![ci](https://github.com/felipecrs/semantic-release-vsce/workflows/ci/badge.svg)](https://github.com/felipecrs/semantic-release-vsce/actions?query=workflow%3Aci)
+[![dependencies](https://david-dm.org/felipecrs/semantic-release-vsce/status.svg)](https://david-dm.org/felipecrs/semantic-release-vsce)
+[![peerDependencies](https://david-dm.org/felipecrs/semantic-release-vsce/peer-status.svg)](https://david-dm.org/felipecrs/semantic-release-vsce?type=peer)
 [![semantic-release](https://img.shields.io/badge/%20%20%F0%9F%93%A6%F0%9F%9A%80-semantic--release-e10079.svg)](https://github.com/semantic-release/semantic-release)
 
-Semantic release plugin for Visual Studio Code extensions
-
 #### Add config to package.json
 
 Use `semantic-release-vsce` as part of `verifyConditions` and `publish`.
@@ -46,7 +45,15 @@ Use `semantic-release-vsce` as part of `verifyConditions` and `publish`.
 If `packageVsix` is set, will also generate a .vsix file at the set file path after publishing. If is a string, it will be used as value for `--out` of `vsce package`.
 It is recommended to upload this to your GitHub release page so your users can easily rollback to an earlier version if a version ever introduces a bad bug. 
 
-If `yarn` is set to `true`, will use `--yarn`option for `vsce package` and `vsce publish`.
+#### Publishing to OpenVSX
+
+Publishing extensions to OpenVSX using this plugin is easy:
+
+1. Get a valid personal access token with the correct privileges to the publisher namespace in OpenVSX. In order to get the personal access token, check this [page](https://github.com/eclipse/openvsx/wiki).
+
+2. Configure the `OVSX_PAT` environment variable in your CI with the token that you created.
+
+3. Enjoy! The plugin will automatically detect the environment variable and it will publish to OpenVSX, no additional configuration is needed.
 
 #### Working with older versions
 
@@ -56,7 +63,7 @@ Prior to v13, you had to override `getLastRelease` to use `@semantic-release/git
 
 #### Travis example
 
-Secret environment variables: `VSCE_TOKEN`
+Secret environment variables: `VSCE_PAT`
 
 Example:
 

package/index.js

@@ -4,6 +4,7 @@ const vscePrepare = require('./lib/prepare');
 
 let verified = false;
 let prepared = false;
+let packagePath;
 
 async function verifyConditions (pluginConfig, { logger }) {
   await verifyVsce(logger);
@@ -15,7 +16,7 @@ async function prepare (pluginConfig, { nextRelease: { version }, logger }) {
     await verifyVsce(logger);
     verified = true;
   }
-  await vscePrepare(version, pluginConfig.packageVsix, pluginConfig.yarn, logger);
+  packagePath = await vscePrepare(version, pluginConfig.packageVsix, logger);
   prepared = true;
 }
 
@@ -27,9 +28,9 @@ async function publish (pluginConfig, { nextRelease: { version }, logger }) {
 
   if (!prepared) {
     // BC: prior to semantic-release v15 prepare was part of publish
-    await vscePrepare(version, pluginConfig.packageVsix, pluginConfig.yarn, logger);
+    packagePath = await vscePrepare(version, pluginConfig.packageVsix, logger);
   }
-  return vscePublish(version, pluginConfig.yarn, logger);
+  return vscePublish(version, packagePath, logger);
 }
 
 module.exports = {

package/lib/prepare.js

@@ -1,22 +1,29 @@
 const execa = require('execa');
-const updatePackageVersion = require('./update-package-version');
+const { readJson } = require('fs-extra');
+const { isOvsxEnabled } = require('./verify-ovsx-auth');
 
-module.exports = async (version, packageVsix, yarn, logger) => {
-  await updatePackageVersion(version, logger);
-
-  if (packageVsix) {
-    logger.log('Packaging version %s as .vsix', version);
+module.exports = async (version, packageVsix, logger) => {
+  const ovsxEnabled = isOvsxEnabled();
+  if (packageVsix || ovsxEnabled) {
+    if (!packageVsix && ovsxEnabled) {
+      logger.log('Packaging to VSIX even though `packageVsix` is not set as publish to OpenVSX is enabled.');
+    }
 
-    const options = ['package'];
+    let packagePath;
 
     if (typeof packageVsix === 'string') {
-      options.push(...['--out', packageVsix]);
+      packagePath = packageVsix;
+    } else {
+      const { name } = await readJson('./package.json');
+      packagePath = `${name}-${version}.vsix`;
     }
 
-    if (yarn) {
-      options.push('--yarn');
-    }
+    logger.log(`Packaging version ${version} to ${packagePath}`);
+
+    const options = ['package', version, '--no-git-tag-version', '--out', packagePath];
 
     await execa('vsce', options, { stdio: 'inherit' });
+
+    return packagePath;
   }
 };

package/lib/publish.js

@@ -1,25 +1,46 @@
 const execa = require('execa');
 const { readJson } = require('fs-extra');
+const { isOvsxEnabled } = require('./verify-ovsx-auth');
 
-module.exports = async (version, yarn, logger) => {
-  const { VSCE_TOKEN } = process.env;
-
+module.exports = async (version, packagePath, logger) => {
   const { publisher, name } = await readJson('./package.json');
 
-  logger.log('Publishing version %s to vs code marketplace', version);
-
-  const options = ['publish', '--pat', VSCE_TOKEN];
+  const options = ['publish'];
 
-  if (yarn) {
-    options.push('--yarn');
+  if (packagePath) {
+    logger.log(`Publishing version ${version} from ${packagePath} to Visual Studio Marketplace`);
+    options.push(...['--packagePath', packagePath]);
+  } else {
+    logger.log(`Publishing version ${version} to Visual Studio Marketplace`);
+    options.push(...[version, '--no-git-tag-version']);
   }
 
   await execa('vsce', options, { stdio: 'inherit' });
 
-  const url = `https://marketplace.visualstudio.com/items?itemName=${publisher}.${name}`;
-  logger.log(`New version is available at ${url}`);
-  return {
+  const vsceUrl = `https://marketplace.visualstudio.com/items?itemName=${publisher}.${name}`;
+  logger.log(`The new version is available at ${vsceUrl}.`);
+
+  const vsceRelease = {
     name: 'Visual Studio Marketplace',
-    url
+    url: vsceUrl
   };
+
+  if (isOvsxEnabled()) {
+    logger.log('Now publishing to OpenVSX');
+
+    await execa('ovsx', ['publish', packagePath], { stdio: 'inherit' });
+
+    // TODO: uncomment after https://github.com/semantic-release/semantic-release/issues/2123
+    // const ovsxUrl = `https://open-vsx.org/extension/${publisher}/${name}/${version}`;
+    // const ovsxRelease = {
+    //   name: 'Open VSX Registry',
+    //   url: ovsxUrl
+    // };
+
+    // const releases = [vsceRelease, ovsxRelease];
+
+    // return releases;
+  }
+
+  return vsceRelease;
 };

package/lib/verify-auth.js

@@ -0,0 +1,16 @@
+const execa = require('execa');
+const SemanticReleaseError = require('@semantic-release/error');
+
+module.exports = async (logger) => {
+  logger.log('Verifying authentication for vsce');
+
+  if (!process.env.VSCE_PAT) {
+    throw new SemanticReleaseError('No vsce personal access token specified (set the `VSCE_PAT` environment variable).', 'ENOVSCEPAT');
+  }
+
+  try {
+    await execa('vsce', ['verify-pat']);
+  } catch (e) {
+    throw new SemanticReleaseError(`Invalid vsce token. Additional information:\n\n${e}`, 'EINVALIDVSCETOKEN');
+  }
+};

package/lib/verify-ovsx-auth.js

@@ -0,0 +1,27 @@
+const SemanticReleaseError = require('@semantic-release/error');
+
+const isOvsxEnabled = () => {
+  return 'OVSX_PAT' in process.env;
+};
+
+module.exports = async (logger) => {
+  logger.log('Verifying authentication for ovsx');
+
+  if (!isOvsxEnabled()) {
+    logger.log('Skipping verification of ovsx personal token because the `OVSX_PAT` environment variable is not set.\n\nDid you know you can easily start publishing to OpenVSX with `semantic-release-vsce`?\nLearn more at https://github.com/felipecrs/semantic-release-vsce#publishing-to-openvsx');
+    return;
+  }
+
+  if (!process.env.OVSX_PAT) {
+    throw new SemanticReleaseError('Empty ovsx personal access token specified.', 'EINVALIDOVSXPAT');
+  }
+
+  // TODO: waiting for https://github.com/eclipse/openvsx/issues/313
+  // try {
+  //   await execa('ovsx', ['verify-pat']);
+  // } catch (e) {
+  //   throw new SemanticReleaseError(`Invalid ovsx personal access token. Additional information:\n\n${e}`, 'EINVALIDOVSXPAT');
+  // }
+};
+
+module.exports.isOvsxEnabled = isOvsxEnabled;

package/lib/verify-pkg.js

@@ -1,10 +1,29 @@
 const SemanticReleaseError = require('@semantic-release/error');
+const { readJson } = require('fs-extra');
+const fs = require('fs');
+
+module.exports = async () => {
+  if (!fs.existsSync('./package.json')) {
+    throw new SemanticReleaseError(
+      'The `package.json` was not found. A `package.json` is required to release with vsce.',
+      'ENOPKG'
+    );
+  }
+
+  let packageJson;
+
+  try {
+    packageJson = await readJson('./package.json');
+  } catch (error) {
+    throw new SemanticReleaseError('The `package.json` seems to be invalid.', 'EINVALIDPKG');
+  }
+
+  const { name, publisher } = packageJson;
 
-module.exports = ({ name, publisher }) => {
   if (!name) {
-    throw new SemanticReleaseError('No "name" found in package.json.', 'ENOPKGNAME');
+    throw new SemanticReleaseError('No `name` found in `package.json`.', 'ENOPKGNAME');
   }
   if (!publisher) {
-    throw new SemanticReleaseError('No "publisher" found in package.json.', 'ENOPUBLISHER');
+    throw new SemanticReleaseError('No `publisher` found in `package.json`.', 'ENOPUBLISHER');
   }
 };

package/lib/verify.js

@@ -1,21 +1,11 @@
 const verifyPkg = require('./verify-pkg');
-const setAuth = require('./set-auth');
-const getPkg = require('read-pkg-up');
-const SemanticReleaseError = require('@semantic-release/error');
+const verifyAuth = require('./verify-auth');
+const verifyOvsxAuth = require('./verify-ovsx-auth');
 
 module.exports = async logger => {
-  const { packageJson } = await getPkg();
-  if (!packageJson) {
-    throw new SemanticReleaseError(
-      'package.json not found. A package.json is required to release with vsce.',
-      'ENOPKG'
-    );
-  }
-  verifyPkg(packageJson);
-  await setAuth(logger);
-  try {
-    // TODO: Verify output
-  } catch (err) {
-    throw new SemanticReleaseError('Invalid vsce token.', 'EINVALIDVSCETOKEN');
-  }
+  await verifyPkg();
+
+  await verifyAuth(logger);
+
+  await verifyOvsxAuth(logger);
 };

package/package.json

@@ -1,81 +1,80 @@
 {
   "name": "semantic-release-vsce",
-  "description": "Semantic release plugin for vs code extensions",
-  "version": "4.0.0",
-  "main": "index.js",
-  "repository": "https://github.com/raix/semantic-release-vsce.git",
-  "author": "Morten Henriksen <mh@gi2.dk>",
+  "version": "5.0.2",
+  "description": "semantic-release plugin to package and publish VS Code extensions",
   "license": "MIT",
+  "engines": {
+    "node": ">=14"
+  },
+  "repository": "https://github.com/felipecrs/semantic-release-vsce.git",
+  "bugs": "https://github.com/felipecrs/semantic-release-vsce/issues",
+  "homepage": "https://github.com/felipecrs/semantic-release-vsce#readme",
+  "author": "Morten Henriksen <mh@gi2.dk>",
+  "keywords": [
+    "semantic-release",
+    "semantic-release-plugin",
+    "vscode",
+    "vsce"
+  ],
+  "main": "index.js",
   "scripts": {
     "lint": "eslint .",
+    "release": "semantic-release",
     "test": "nyc ava",
     "posttest": "npm run lint",
-    "release": "semantic-release"
-  },
-  "engines": {
-    "node": ">=10.18"
-  },
-  "dependencies": {
-    "@semantic-release/error": "^2.2.0",
-    "commander": "^4.1.1",
-    "detect-indent": "^6.0.0",
-    "execa": "^4.0.0",
-    "fs-extra": "^8.1.0",
-    "node-fetch": "^2.6.0",
-    "read-pkg-up": "^7.0.1",
-    "semver": "^7.1.3"
-  },
-  "devDependencies": {
-    "@commitlint/cli": "^8.0.0",
-    "@commitlint/config-conventional": "^8.0.0",
-    "ava": "^3.9.0",
-    "conventional-changelog-conventionalcommits": "^4.2.1",
-    "eslint": "^6.8.0",
-    "eslint-config-standard": "^14.1.0",
-    "eslint-plugin-import": "^2.20.1",
-    "eslint-plugin-node": "^11.0.0",
-    "eslint-plugin-promise": "^4.2.1",
-    "eslint-plugin-standard": "^4.0.1",
-    "husky": "^4.2.3",
-    "nyc": "^15.1.0",
-    "proxyquire": "^2.1.3",
-    "semantic-release": "^17.0.3",
-    "sinon": "^9.0.2"
-  },
-  "peerDependencies": {
-    "semantic-release": ">=16.0.0",
-    "vsce": ">=1.73.0 < 2"
-  },
-  "volta": {
-    "node": "14.15.4",
-    "npm": "7.4.2"
+    "prepare": "husky install"
   },
   "ava": {
     "files": [
       "test/**/*.test.js"
     ]
   },
+  "commitlint": {
+    "extends": [
+      "@commitlint/config-conventional"
+    ]
+  },
   "nyc": {
     "all": true,
+    "exclude": [
+      "lib/die.js"
+    ],
     "include": [
       "index.js",
       "lib/**/*.js"
-    ],
-    "exclude": [
-      "lib/die.js"
     ]
   },
-  "commitlint": {
-    "extends": [
-      "@commitlint/config-conventional"
-    ]
-  },
-  "husky": {
-    "hooks": {
-      "commit-msg": "commitlint -E HUSKY_GIT_PARAMS"
-    }
-  },
   "release": {
     "preset": "conventionalcommits"
+  },
+  "volta": {
+    "node": "16.13.2",
+    "npm": "8.3.2"
+  },
+  "dependencies": {
+    "@semantic-release/error": "^3.0.0",
+    "execa": "^5.0.0",
+    "fs-extra": "^10.0.0",
+    "ovsx": "^0.3.0",
+    "vsce": "^2.6.3"
+  },
+  "peerDependencies": {
+    "semantic-release": ">=18"
+  },
+  "devDependencies": {
+    "@commitlint/cli": "^16.0.2",
+    "@commitlint/config-conventional": "^16.0.0",
+    "ava": "^4.0.1",
+    "conventional-changelog-conventionalcommits": "^4.2.1",
+    "eslint": "^8.7.0",
+    "eslint-config-standard": "^17.0.0-0",
+    "eslint-plugin-import": "^2.20.1",
+    "eslint-plugin-n": "^14.0.0",
+    "eslint-plugin-promise": "^6.0.0",
+    "husky": "^7.0.4",
+    "nyc": "^15.1.0",
+    "proxyquire": "^2.1.3",
+    "semantic-release": "^19.0.2",
+    "sinon": "^12.0.1"
   }
 }

package/test/index.test.js

@@ -12,8 +12,7 @@ const semanticReleasePayload = {
 };
 
 const pluginConfig = {
-  packageVsix: 'test.vsix',
-  yarn: undefined
+  packageVsix: 'test.vsix'
 };
 
 test.beforeEach(t => {
@@ -58,7 +57,6 @@ test('prepare and unverified', async t => {
   t.deepEqual(vscePrepareStub.getCall(0).args, [
     semanticReleasePayload.nextRelease.version,
     pluginConfig.packageVsix,
-    pluginConfig.yarn,
     semanticReleasePayload.logger
   ]);
 });
@@ -78,7 +76,6 @@ test('prepare and verified', async t => {
   t.deepEqual(vscePrepareStub.getCall(0).args, [
     semanticReleasePayload.nextRelease.version,
     pluginConfig.packageVsix,
-    pluginConfig.yarn,
     semanticReleasePayload.logger
   ]);
 });
@@ -97,7 +94,7 @@ test('publish that is unverified and unprepared', async t => {
   t.true(vscePrepareStub.calledOnce);
   t.deepEqual(vscePublishStub.getCall(0).args, [
     semanticReleasePayload.nextRelease.version,
-    pluginConfig.yarn,
+    undefined,
     semanticReleasePayload.logger
   ]);
 });
@@ -117,7 +114,7 @@ test('publish that is verified but unprepared', async t => {
   t.true(vscePrepareStub.calledOnce);
   t.deepEqual(vscePublishStub.getCall(0).args, [
     semanticReleasePayload.nextRelease.version,
-    pluginConfig.yarn,
+    undefined,
     semanticReleasePayload.logger
   ]);
 });
@@ -131,14 +128,14 @@ test('publish that is already verified & prepared', async t => {
   });
 
   await verifyConditions(pluginConfig, semanticReleasePayload);
-  await prepare(pluginConfig, semanticReleasePayload);
+  const packagePath = await prepare(pluginConfig, semanticReleasePayload);
   await publish(pluginConfig, semanticReleasePayload);
 
   t.true(verifyVsceStub.calledOnce);
   t.true(vscePrepareStub.calledOnce);
   t.deepEqual(vscePublishStub.getCall(0).args, [
     semanticReleasePayload.nextRelease.version,
-    pluginConfig.yarn,
+    packagePath,
     semanticReleasePayload.logger
   ]);
 });

package/test/prepare.test.js

@@ -8,82 +8,87 @@ const logger = {
 
 test.beforeEach(t => {
   t.context.stubs = {
-    execaStub: sinon.stub(),
-    updatePackageVersionStub: sinon.stub().resolves()
+    execaStub: sinon.stub()
   };
 });
 
 test.afterEach(t => {
   t.context.stubs.execaStub.resetHistory();
-  t.context.stubs.updatePackageVersionStub.resetHistory();
 });
 
 test('packageVsix is not specified', async t => {
-  const { updatePackageVersionStub, execaStub } = t.context.stubs;
+  const { execaStub } = t.context.stubs;
   const prepare = proxyquire('../lib/prepare', {
-    execa: execaStub,
-    './update-package-version': updatePackageVersionStub
-  });
-
-  await prepare('1.0.0', undefined, undefined, logger);
-
-  t.true(updatePackageVersionStub.calledOnce);
-  t.true(execaStub.notCalled);
-});
-
-test('packageVsix is not specified but yarn is true', async t => {
-  const { updatePackageVersionStub, execaStub } = t.context.stubs;
-  const prepare = proxyquire('../lib/prepare', {
-    execa: execaStub,
-    './update-package-version': updatePackageVersionStub
+    execa: execaStub
   });
 
-  const yarn = true;
-  await prepare('1.0.0', undefined, yarn, logger);
+  const version = '1.0.0';
+  await prepare(version, undefined, logger);
 
-  t.true(updatePackageVersionStub.calledOnce);
   t.true(execaStub.notCalled);
 });
 
 test('packageVsix is a string', async t => {
-  const { updatePackageVersionStub, execaStub } = t.context.stubs;
+  const { execaStub } = t.context.stubs;
   const prepare = proxyquire('../lib/prepare', {
-    execa: execaStub,
-    './update-package-version': updatePackageVersionStub
+    execa: execaStub
   });
 
+  const version = '1.0.0';
   const packageVsix = 'test.vsix';
-  await prepare('1.0.0', packageVsix, undefined, logger);
+  const packagePath = packageVsix;
+  const result = await prepare(version, packageVsix, logger);
 
-  t.true(updatePackageVersionStub.calledOnce);
-  t.deepEqual(execaStub.getCall(0).args, ['vsce', ['package', '--out', packageVsix], { stdio: 'inherit' }]);
+  t.deepEqual(result, packagePath);
+  t.deepEqual(execaStub.getCall(0).args, ['vsce', ['package', version, '--no-git-tag-version', '--out', packagePath], { stdio: 'inherit' }]);
 });
 
 test('packageVsix is true', async t => {
-  const { updatePackageVersionStub, execaStub } = t.context.stubs;
+  const { execaStub } = t.context.stubs;
+  const name = 'test';
+
   const prepare = proxyquire('../lib/prepare', {
     execa: execaStub,
-    './update-package-version': updatePackageVersionStub
+    'fs-extra': {
+      readJson: sinon.stub().returns({
+        name
+      })
+    }
   });
 
+  const version = '1.0.0';
   const packageVsix = true;
-  await prepare('1.0.0', packageVsix, undefined, logger);
+  const packagePath = `${name}-${version}.vsix`;
 
-  t.true(updatePackageVersionStub.calledOnce);
-  t.deepEqual(execaStub.getCall(0).args, ['vsce', ['package'], { stdio: 'inherit' }]);
+  const result = await prepare(version, packageVsix, logger);
+
+  t.deepEqual(result, packagePath);
+  t.deepEqual(execaStub.getCall(0).args, ['vsce', ['package', version, '--no-git-tag-version', '--out', packagePath], { stdio: 'inherit' }]);
 });
 
-test('packageVsix is true and yarn is true', async t => {
-  const { updatePackageVersionStub, execaStub } = t.context.stubs;
+test('packageVsix is not set but OVSX_PAT is', async t => {
+  const { execaStub } = t.context.stubs;
+  const name = 'test';
+
   const prepare = proxyquire('../lib/prepare', {
     execa: execaStub,
-    './update-package-version': updatePackageVersionStub
+    'fs-extra': {
+      readJson: sinon.stub().returns({
+        name
+      })
+    }
   });
 
-  const packageVsix = true;
-  const yarn = true;
-  await prepare('1.0.0', packageVsix, yarn, logger);
+  sinon.stub(process, 'env').value({
+    OVSX_PAT: 'abc123'
+  });
+
+  const version = '1.0.0';
+  const packageVsix = undefined;
+  const packagePath = `${name}-${version}.vsix`;
+
+  const result = await prepare(version, packageVsix, logger);
 
-  t.true(updatePackageVersionStub.calledOnce);
-  t.deepEqual(execaStub.getCall(0).args, ['vsce', ['package', '--yarn'], { stdio: 'inherit' }]);
+  t.deepEqual(result, packagePath);
+  t.deepEqual(execaStub.getCall(0).args, ['vsce', ['package', version, '--no-git-tag-version', '--out', packagePath], { stdio: 'inherit' }]);
 });

package/test/publish.test.js

@@ -30,18 +30,21 @@ test('publish', async t => {
     }
   });
 
+  const version = '1.0.0';
   const token = 'abc123';
-  process.env.VSCE_TOKEN = token;
-  const result = await publish('1.0.0', undefined, logger);
+  sinon.stub(process, 'env').value({
+    VSCE_PAT: token
+  });
+  const result = await publish(version, undefined, logger);
 
   t.deepEqual(result, {
     name: 'Visual Studio Marketplace',
     url: `https://marketplace.visualstudio.com/items?itemName=${publisher}.${name}`
   });
-  t.deepEqual(execaStub.getCall(0).args, ['vsce', ['publish', '--pat', token], { stdio: 'inherit' }]);
+  t.deepEqual(execaStub.getCall(0).args, ['vsce', ['publish', version, '--no-git-tag-version'], { stdio: 'inherit' }]);
 });
 
-test('publish when yarn is true', async t => {
+test('publish with packagePath', async t => {
   const { execaStub } = t.context.stubs;
   const publisher = 'semantic-release-vsce';
   const name = 'Semantice Release VSCE';
@@ -55,14 +58,53 @@ test('publish when yarn is true', async t => {
     }
   });
 
+  const version = '1.0.0';
+  const packagePath = 'test.vsix';
   const token = 'abc123';
-  process.env.VSCE_TOKEN = token;
-  const yarn = true;
-  const result = await publish('1.0.0', yarn, logger);
+  sinon.stub(process, 'env').value({
+    VSCE_PAT: token
+  });
+  const result = await publish(version, packagePath, logger);
 
   t.deepEqual(result, {
     name: 'Visual Studio Marketplace',
     url: `https://marketplace.visualstudio.com/items?itemName=${publisher}.${name}`
   });
-  t.deepEqual(execaStub.getCall(0).args, ['vsce', ['publish', '--pat', token, '--yarn'], { stdio: 'inherit' }]);
+  t.deepEqual(execaStub.getCall(0).args, ['vsce', ['publish', '--packagePath', packagePath], { stdio: 'inherit' }]);
+});
+
+test('publish to OpenVSX', async t => {
+  const { execaStub } = t.context.stubs;
+  const publisher = 'semantic-release-vsce';
+  const name = 'Semantice Release VSCE';
+  const publish = proxyquire('../lib/publish', {
+    execa: execaStub,
+    'fs-extra': {
+      readJson: sinon.stub().returns({
+        publisher,
+        name
+      })
+    }
+  });
+
+  const version = '1.0.0';
+  const packagePath = 'test.vsix';
+  const token = 'abc123';
+  sinon.stub(process, 'env').value({
+    OVSX_PAT: token,
+    VSCE_PAT: token
+  });
+  const result = await publish(version, packagePath, logger);
+
+  t.deepEqual(result, {
+    name: 'Visual Studio Marketplace',
+    url: `https://marketplace.visualstudio.com/items?itemName=${publisher}.${name}`
+  });
+  t.deepEqual(execaStub.getCall(0).args, ['vsce', ['publish', '--packagePath', packagePath], { stdio: 'inherit' }]);
+
+  // t.deepEqual(result[1], {
+  //   name: 'Open VSX Registry',
+  //   url: `https://open-vsx.org/extension/${publisher}/${name}/${version}`
+  // });
+  t.deepEqual(execaStub.getCall(1).args, ['ovsx', ['publish', packagePath], { stdio: 'inherit' }]);
 });

package/test/verify-auth.test.js

@@ -0,0 +1,54 @@
+const test = require('ava');
+const sinon = require('sinon');
+const proxyquire = require('proxyquire');
+const SemanticReleaseError = require('@semantic-release/error');
+
+const logger = {
+  log: sinon.fake()
+};
+
+test('VSCE_PAT is set', async t => {
+  sinon.stub(process, 'env').value({
+    VSCE_PAT: 'abc123'
+  });
+
+  const verifyAuth = proxyquire('../lib/verify-auth', {
+    execa: sinon.stub().withArgs('vsce', ['verify-pat']).resolves()
+  });
+
+  await t.notThrowsAsync(() => verifyAuth(logger));
+});
+
+test('VSCE_PAT is not set', async t => {
+  sinon.stub(process, 'env').value({});
+
+  const verifyAuth = proxyquire('../lib/verify-auth', {
+    execa: sinon.stub().withArgs('vsce', ['verify-pat']).resolves()
+  });
+
+  await t.throwsAsync(() => verifyAuth(logger), { instanceOf: SemanticReleaseError, code: 'ENOVSCEPAT' });
+});
+
+test('VSCE_PAT is valid', async t => {
+  sinon.stub(process, 'env').value({
+    VSCE_PAT: 'abc123'
+  });
+
+  const verifyAuth = proxyquire('../lib/verify-auth', {
+    execa: sinon.stub().withArgs('vsce', ['verify-pat']).resolves()
+  });
+
+  await t.notThrowsAsync(() => verifyAuth(logger));
+});
+
+test('VSCE_PAT is invalid', async t => {
+  sinon.stub(process, 'env').value({
+    VSCE_PAT: 'abc123'
+  });
+
+  const verifyAuth = proxyquire('../lib/verify-auth', {
+    execa: sinon.stub().withArgs('vsce', ['verify-pat']).rejects()
+  });
+
+  await t.throwsAsync(() => verifyAuth(logger), { instanceOf: SemanticReleaseError, code: 'EINVALIDVSCETOKEN' });
+});

package/test/verify-ovsx-auth.test.js

@@ -0,0 +1,27 @@
+const test = require('ava');
+const sinon = require('sinon');
+const SemanticReleaseError = require('@semantic-release/error');
+
+const logger = {
+  log: sinon.fake()
+};
+
+test('OVSX_PAT is set', async t => {
+  sinon.stub(process, 'env').value({
+    OVSX_PAT: 'abc123'
+  });
+
+  const verifyOvsxAuth = require('../lib/verify-ovsx-auth');
+
+  await t.notThrowsAsync(() => verifyOvsxAuth(logger));
+});
+
+test('OVSX_PAT is invalid', async t => {
+  sinon.stub(process, 'env').value({
+    OVSX_PAT: ''
+  });
+
+  const verifyOvsxAuth = require('../lib/verify-ovsx-auth');
+
+  await t.throwsAsync(() => verifyOvsxAuth(logger), { instanceOf: SemanticReleaseError, code: 'EINVALIDOVSXPAT' });
+});

package/test/verify-pkg.test.js

@@ -1,15 +1,105 @@
+const sinon = require('sinon');
 const test = require('ava');
+const proxyquire = require('proxyquire');
 const SemanticReleaseError = require('@semantic-release/error');
-const verifyPkg = require('../lib/verify-pkg');
 
-test('package is valid', t => {
-  t.notThrows(() => verifyPkg({ name: 'test', publisher: 'tester' }));
+test('package.json is found', async t => {
+  const name = 'test';
+  const publisher = 'tester';
+
+  const verifyPkg = proxyquire('../lib/verify-pkg', {
+    fs: {
+      existsSync: sinon.stub().returns(true)
+    },
+    'fs-extra': {
+      readJson: sinon.stub().returns({
+        name,
+        publisher
+      })
+    }
+  });
+
+  await t.notThrowsAsync(() => verifyPkg());
+});
+
+test('package.json is not found', async t => {
+  const name = 'test';
+  const publisher = 'tester';
+
+  const verifyPkg = proxyquire('../lib/verify-pkg', {
+    fs: {
+      existsSync: sinon.stub().returns(false)
+    },
+    'fs-extra': {
+      readJson: sinon.stub().returns({
+        name,
+        publisher
+      })
+    }
+  });
+
+  await t.throwsAsync(() => verifyPkg(), { instanceOf: SemanticReleaseError, code: 'ENOPKG' });
+});
+
+test('package is valid', async t => {
+  const name = 'test';
+  const publisher = 'tester';
+  const verifyPkg = proxyquire('../lib/verify-pkg', {
+    fs: {
+      existsSync: sinon.stub().returns(true)
+    },
+    'fs-extra': {
+      readJson: sinon.stub().returns({
+        publisher,
+        name
+      })
+    }
+  });
+
+  await t.notThrowsAsync(() => verifyPkg());
 });
 
-test('package is missing name', t => {
-  t.throws(() => verifyPkg({ publisher: 'tester' }), { instanceOf: SemanticReleaseError });
+test('package is invalid', async t => {
+  const verifyPkg = proxyquire('../lib/verify-pkg', {
+    fs: {
+      existsSync: sinon.stub().returns(true)
+    },
+    'fs-extra': {
+      readJson: sinon.stub().rejects()
+    }
+  });
+
+  await t.throwsAsync(() => verifyPkg(), { instanceOf: SemanticReleaseError, code: 'EINVALIDPKG' });
 });
 
-test('package is missing publisher', t => {
-  t.throws(() => verifyPkg({ name: 'test' }), { instanceOf: SemanticReleaseError });
+test('package is missing name', async t => {
+  const publisher = 'tester';
+  const verifyPkg = proxyquire('../lib/verify-pkg', {
+    fs: {
+      existsSync: sinon.stub().returns(true)
+    },
+    'fs-extra': {
+      readJson: sinon.stub().returns({
+        publisher
+      })
+    }
+  });
+
+  await t.throwsAsync(() => verifyPkg(), { instanceOf: SemanticReleaseError, code: 'ENOPKGNAME' });
+});
+
+test('package is missing publisher', async t => {
+  const name = 'test';
+  const verifyPkg = proxyquire('../lib/verify-pkg', {
+    fs: {
+      existsSync: sinon.stub().returns(true)
+    },
+    'fs-extra': {
+      readJson: sinon.stub().returns({
+        name
+      })
+    }
+  });
+
+  await t.throwsAsync(() => verifyPkg(), { instanceOf: SemanticReleaseError, code: 'ENOPUBLISHER' });
 });

package/test/verify.test.js

@@ -1,28 +1,34 @@
 const test = require('ava');
 const sinon = require('sinon');
 const proxyquire = require('proxyquire');
-const SemanticReleaseError = require('@semantic-release/error');
 
 const logger = {
   log: sinon.fake()
 };
 
-test('package.json is found', async t => {
+test('resolves', async t => {
   const verify = proxyquire('../lib/verify', {
-    './set-auth': sinon.stub().resolves(),
-    './verify-pkg': sinon.stub(),
-    'read-pkg-up': sinon.stub().returns({ packageJson: {} })
+    './verify-auth': sinon.stub().resolves(),
+    './verify-pkg': sinon.stub().resolves()
   });
 
   await t.notThrowsAsync(() => verify(logger));
 });
 
-test('package.json is not found', async t => {
+test('rejects with verify-auth', async t => {
   const verify = proxyquire('../lib/verify', {
-    './set-auth': sinon.stub().resolves(),
-    './verify-pkg': sinon.stub(),
-    'read-pkg-up': sinon.stub().returns({ })
+    './verify-auth': sinon.stub().rejects(),
+    './verify-pkg': sinon.stub().resolves()
   });
 
-  await t.throwsAsync(() => verify(logger), { instanceOf: SemanticReleaseError });
+  await t.throwsAsync(() => verify(logger));
+});
+
+test('rejects with verify-pkg', async t => {
+  const verify = proxyquire('../lib/verify', {
+    './verify-auth': sinon.stub().resolves(),
+    './verify-pkg': sinon.stub().rejects()
+  });
+
+  await t.throwsAsync(() => verify(logger));
 });

package/.travis.yml

@@ -1,32 +0,0 @@
-language: node_js
-
-node_js:
-  - '14'
-
-cache:
-  directories:
-    - ~/.npm
-
-notifications:
-  email: false
-
-install:
-  - travis_retry npm install
-
-script:
-  - npm test
-
-jobs:
-  include:
-    - stage: test
-    - stage: release
-      script: npm run release
-
-stages:
-  - test
-  - name: release
-    if: branch = master AND type = push AND fork = false
-
-branches:
-  except:
-    - /^v\d+\.\d+\.\d+$/

package/lib/die.js

@@ -1 +0,0 @@
-module.exports = (...args) => { console.error(...args); process.exit(1); };

package/lib/set-auth.js

@@ -1,10 +0,0 @@
-const SemanticReleaseError = require('@semantic-release/error');
-
-module.exports = async (logger) => {
-  logger.log('Verify authentication for vsce');
-  const { VSCE_TOKEN } = process.env;
-
-  if (!VSCE_TOKEN) {
-    throw new SemanticReleaseError('No vsce personal access token specified. (set env "VSCE_TOKEN")', 'ENOVSCEPAT');
-  }
-};

package/lib/update-package-version.js

@@ -1,20 +0,0 @@
-const { readFile, writeJson, pathExists } = require('fs-extra');
-const detectIndent = require('detect-indent');
-
-module.exports = async (version, logger) => {
-  const pkgRaw = (await readFile('./package.json')).toString();
-  const pkg = JSON.parse(pkgRaw);
-  const pkgIndent = detectIndent(pkgRaw).indent || '  ';
-
-  await writeJson('./package.json', Object.assign(pkg, { version }), { spaces: pkgIndent });
-  logger.log('Wrote version %s to package.json', version);
-
-  if (await pathExists('./npm-shrinkwrap.json')) {
-    const shrinkWrapRaw = (await readFile('./npm-shrinkwrap.json')).toString();
-    const shrinkwrap = JSON.parse(shrinkWrapRaw);
-    const shrinkWrapIndent = detectIndent(shrinkWrapRaw).indent || '  ';
-    shrinkwrap.version = version;
-    await writeJson('./npm-shrinkwrap.json', shrinkwrap, { spaces: shrinkWrapIndent });
-    logger.log('Wrote version %s to npm-shrinkwrap.json', version);
-  }
-};

package/test/set-auth.test.js

@@ -1,18 +0,0 @@
-const test = require('ava');
-const sinon = require('sinon');
-const SemanticReleaseError = require('@semantic-release/error');
-const setAuth = require('../lib/set-auth');
-
-const logger = {
-  log: sinon.fake()
-};
-
-test('VSCE_TOKEN is set', async t => {
-  process.env.VSCE_TOKEN = 'abc123';
-  await t.notThrowsAsync(() => setAuth(logger));
-});
-
-test('VSCE_TOKEN is not set', async t => {
-  delete process.env.VSCE_TOKEN;
-  await t.throwsAsync(() => setAuth(logger), { instanceOf: SemanticReleaseError });
-});

package/test/update-package-version.test.js

@@ -1,115 +0,0 @@
-const sinon = require('sinon');
-const test = require('ava');
-const proxyquire = require('proxyquire');
-
-const logger = {
-  log: sinon.fake()
-};
-
-test.beforeEach(t => {
-  t.context.stubs = {
-    writeJsonStub: sinon.stub()
-  };
-});
-
-test.afterEach(t => {
-  t.context.stubs.writeJsonStub.resetHistory();
-});
-
-test('package.json indentation uses spaces', async t => {
-  const { writeJsonStub } = t.context.stubs;
-  const updatePackageVersion = proxyquire('../lib/update-package-version', {
-    'fs-extra': {
-      // test with 3 spaces so we don't hit the default
-      readFile: sinon.stub().returns('{\n   "name":"test"\n}'),
-      writeJson: writeJsonStub,
-      pathExists: sinon.stub().returns(false)
-    }
-  });
-
-  await updatePackageVersion('1.0.0', logger);
-  t.deepEqual(writeJsonStub.getCall(0).args,
-    ['./package.json', { name: 'test', version: '1.0.0' }, { spaces: '   ' }]
-  );
-});
-
-test('package.json indentation uses tabs', async t => {
-  const { writeJsonStub } = t.context.stubs;
-  const updatePackageVersion = proxyquire('../lib/update-package-version', {
-    'fs-extra': {
-      readFile: sinon.stub().returns('{\n\t"name":"test"\n}'),
-      writeJson: writeJsonStub,
-      pathExists: sinon.stub().returns(false)
-    }
-  });
-
-  await updatePackageVersion('1.0.0', logger);
-  t.deepEqual(writeJsonStub.getCall(0).args,
-    ['./package.json', { name: 'test', version: '1.0.0' }, { spaces: '\t' }]
-  );
-});
-
-test('package.json indentation is undetermined', async t => {
-  const { writeJsonStub } = t.context.stubs;
-  const updatePackageVersion = proxyquire('../lib/update-package-version', {
-    'fs-extra': {
-      readFile: sinon.stub().returns('{"name":"test"}'),
-      writeJson: writeJsonStub,
-      pathExists: sinon.stub().returns(false)
-    }
-  });
-
-  await updatePackageVersion('1.0.0', logger);
-  t.deepEqual(writeJsonStub.getCall(0).args,
-    ['./package.json', { name: 'test', version: '1.0.0' }, { spaces: '  ' }]
-  );
-});
-
-test('npm-shrinkwrap.json indentation uses spaces', async t => {
-  const { writeJsonStub } = t.context.stubs;
-  const updatePackageVersion = proxyquire('../lib/update-package-version', {
-    'fs-extra': {
-      // test with 3 spaces so we don't hit the default
-      readFile: sinon.stub().returns('{\n   "version":"0.0.0"\n}'),
-      writeJson: writeJsonStub,
-      pathExists: sinon.stub().returns(true)
-    }
-  });
-
-  await updatePackageVersion('1.0.0', logger);
-  t.deepEqual(writeJsonStub.getCall(1).args,
-    ['./npm-shrinkwrap.json', { version: '1.0.0' }, { spaces: '   ' }]
-  );
-});
-
-test('npm-shrinkwrap.json indentation uses tabs', async t => {
-  const { writeJsonStub } = t.context.stubs;
-  const updatePackageVersion = proxyquire('../lib/update-package-version', {
-    'fs-extra': {
-      readFile: sinon.stub().returns('{\n\t"version":"0.0.0"\n}'),
-      writeJson: writeJsonStub,
-      pathExists: sinon.stub().returns(true)
-    }
-  });
-
-  await updatePackageVersion('1.0.0', logger);
-  t.deepEqual(writeJsonStub.getCall(1).args,
-    ['./npm-shrinkwrap.json', { version: '1.0.0' }, { spaces: '\t' }]
-  );
-});
-
-test('npm-shrinkwrap.json indentation is undetermined', async t => {
-  const { writeJsonStub } = t.context.stubs;
-  const updatePackageVersion = proxyquire('../lib/update-package-version', {
-    'fs-extra': {
-      readFile: sinon.stub().returns('{"version":"0.0.0"}'),
-      writeJson: writeJsonStub,
-      pathExists: sinon.stub().returns(true)
-    }
-  });
-
-  await updatePackageVersion('1.0.0', logger);
-  t.deepEqual(writeJsonStub.getCall(1).args,
-    ['./npm-shrinkwrap.json', { version: '1.0.0' }, { spaces: '  ' }]
-  );
-});