release-it 18.1.1 → 19.0.0-next.0

package/test/git.js

@@ -1,50 +1,53 @@
 import { EOL } from 'node:os';
+import childProcess from 'node:child_process';
+import { appendFileSync } from 'node:fs';
 import test from 'ava';
 import sinon from 'sinon';
-import sh from 'shelljs';
 import Git from '../lib/plugin/git/Git.js';
+import { execOpts, touch } from '../lib/util.js';
+import sh from './util/sh.js';
 import { factory } from './util/index.js';
 import { mkTmpDir, readFile, gitAdd } from './util/helpers.js';
 
 test.beforeEach(() => {
   const tmp = mkTmpDir();
-  sh.pushd('-q', tmp);
+  process.chdir(tmp);
 });
 
 test.serial('should return whether repo has upstream branch', async t => {
   const gitClient = factory(Git);
-  sh.exec('git init');
+  childProcess.execSync('git init', execOpts);
   gitAdd('line', 'file', 'Add file');
   t.false(await gitClient.hasUpstreamBranch());
 });
 
 test.serial('should return branch name', async t => {
   const gitClient = factory(Git);
-  sh.exec('git init');
+  childProcess.execSync('git init', execOpts);
   t.is(await gitClient.getBranchName(), null);
-  sh.exec('git checkout -b feat');
+  childProcess.execSync('git checkout -b feat', execOpts);
   gitAdd('line', 'file', 'Add file');
   t.is(await gitClient.getBranchName(), 'feat');
 });
 
 test.serial('should return whether tag exists and if working dir is clean', async t => {
   const gitClient = factory(Git);
-  sh.exec('git init');
+  childProcess.execSync('git init', execOpts);
   t.false(await gitClient.tagExists('1.0.0'));
-  sh.touch('file');
+  touch('file');
   t.false(await gitClient.isWorkingDirClean());
   gitAdd('line', 'file', 'Add file');
-  sh.exec('git tag 1.0.0');
+  childProcess.execSync('git tag 1.0.0', execOpts);
   t.true(await gitClient.tagExists('1.0.0'));
   t.true(await gitClient.isWorkingDirClean());
 });
 
 test.serial('should throw if tag exists', async t => {
   const gitClient = factory(Git);
-  sh.exec('git init');
-  sh.touch('file');
+  childProcess.execSync('git init', execOpts);
+  touch('file');
   gitAdd('line', 'file', 'Add file');
-  sh.exec('git tag 0.0.2');
+  childProcess.execSync('git tag 0.0.2', execOpts);
   gitClient.config.setContext({ latestTag: '0.0.1', tagName: '0.0.2' });
   const expected = { instanceOf: Error, message: /fatal: tag '0\.0\.2' already exists/ };
   await t.throwsAsync(gitClient.tag({ name: '0.0.2' }), expected);
@@ -53,10 +56,10 @@ test.serial('should throw if tag exists', async t => {
 test.serial('should only warn if tag exists intentionally', async t => {
   const gitClient = factory(Git);
   const { warn } = gitClient.log;
-  sh.exec('git init');
-  sh.touch('file');
+  childProcess.execSync('git init', execOpts);
+  touch('file');
   gitAdd('line', 'file', 'Add file');
-  sh.exec('git tag 1.0.0');
+  childProcess.execSync('git tag 1.0.0', execOpts);
   gitClient.config.setContext({ latestTag: '1.0.0', tagName: '1.0.0' });
   await t.notThrowsAsync(gitClient.tag());
   t.is(warn.callCount, 1);
@@ -64,19 +67,19 @@ test.serial('should only warn if tag exists intentionally', async t => {
 });
 
 test.serial('should return the remote url', async t => {
-  sh.exec(`git init`);
+  childProcess.execSync(`git init`, execOpts);
   {
     const options = { git: { pushRepo: 'origin' } };
     const gitClient = factory(Git, { options });
     t.is(await gitClient.getRemoteUrl(), null);
-    sh.exec(`git remote add origin foo`);
+    childProcess.execSync(`git remote add origin foo`, execOpts);
     t.is(await gitClient.getRemoteUrl(), 'foo');
   }
   {
     const options = { git: { pushRepo: 'another' } };
     const gitClient = factory(Git, { options });
     t.is(await gitClient.getRemoteUrl(), null);
-    sh.exec(`git remote add another bar`);
+    childProcess.execSync(`git remote add another bar`, execOpts);
     t.is(await gitClient.getRemoteUrl(), 'bar');
   }
   {
@@ -88,43 +91,44 @@ test.serial('should return the remote url', async t => {
 
 test.serial('should return the non-origin remote', async t => {
   const bare = mkTmpDir();
-  sh.exec(`git init --bare ${bare}`);
-  sh.exec(`git clone ${bare} .`);
+  childProcess.execSync(`git init --bare ${bare}`, execOpts);
+  childProcess.execSync(`git clone ${bare} .`, execOpts);
   gitAdd('line', 'file', 'Add file');
-  sh.exec('git remote rename origin upstream');
+  childProcess.execSync('git remote rename origin upstream', execOpts);
   const gitClient = factory(Git);
   t.is(await gitClient.getRemoteUrl(), bare);
 });
 
 test.serial('should stage, commit, tag and push', async t => {
   const bare = mkTmpDir();
-  sh.exec(`git init --bare ${bare}`);
-  sh.exec(`git clone ${bare} .`);
+  childProcess.execSync(`git init --bare ${bare}`, execOpts);
+  childProcess.execSync(`git clone ${bare} .`, execOpts);
   const version = '1.2.3';
   gitAdd(`{"version":"${version}"}`, 'package.json', 'Add package.json');
   {
     const gitClient = factory(Git);
-    sh.exec(`git tag ${version}`);
+    childProcess.execSync(`git tag ${version}`, execOpts);
     t.is(await gitClient.getLatestTagName(), version);
   }
   {
     const gitClient = factory(Git);
     gitAdd('line', 'file', 'Add file');
-    sh.exec('npm --no-git-tag-version version patch');
+    childProcess.execSync('npm --no-git-tag-version version patch', execOpts);
     await gitClient.stage('package.json');
     await gitClient.commit({ message: `Release v1.2.4` });
     await gitClient.tag({ name: 'v1.2.4', annotation: 'Release v1.2.4' });
     t.is(await gitClient.getLatestTagName(), 'v1.2.4');
     await gitClient.push();
-    const status = sh.exec('git status -uno');
-    t.true(status.includes('nothing to commit'));
+    const stdout = childProcess.execSync('git status -uno', { encoding: 'utf-8' });
+
+    t.true(stdout.includes('nothing to commit'));
   }
 });
 
 test.serial('should commit, tag and push with extra args', async t => {
   const bare = mkTmpDir();
-  sh.exec(`git init --bare ${bare}`);
-  sh.exec(`git clone ${bare} .`);
+  childProcess.execSync(`git init --bare ${bare}`, execOpts);
+  childProcess.execSync(`git clone ${bare} .`, execOpts);
   gitAdd('line', 'file', 'Add file');
   const options = { git: { commitArgs: '-S', tagArgs: ['-T', 'foo'], pushArgs: ['-U', 'bar', '-V'] } };
   const gitClient = factory(Git, { options });
@@ -142,8 +146,8 @@ test.serial('should commit, tag and push with extra args', async t => {
 
 test.serial('should amend commit without message if not provided', async t => {
   const bare = mkTmpDir();
-  sh.exec(`git init --bare ${bare}`);
-  sh.exec(`git clone ${bare} .`);
+  childProcess.execSync(`git init --bare ${bare}`, execOpts);
+  childProcess.execSync(`git clone ${bare} .`, execOpts);
   gitAdd('line', 'file', 'Add file');
   const options = { git: { commitArgs: ['--amend', '--no-edit', '--no-verify'] } };
   const gitClient = factory(Git, { options });
@@ -156,12 +160,12 @@ test.serial('should amend commit without message if not provided', async t => {
 
 test.serial('should commit and tag with quoted characters', async t => {
   const bare = mkTmpDir();
-  sh.exec(`git init --bare ${bare}`);
-  sh.exec(`git clone ${bare} .`);
+  childProcess.execSync(`git init --bare ${bare}`, execOpts);
+  childProcess.execSync(`git clone ${bare} .`, execOpts);
   const gitClient = factory(Git, {
     options: { git: { commitMessage: 'Release ${version}', tagAnnotation: 'Release ${version}\n\n${changelog}' } }
   });
-  sh.touch('file');
+  touch('file');
   const changelog = `- Foo's${EOL}- "$bar"${EOL}- '$baz'${EOL}- foo`;
   gitClient.config.setContext({ version: '1.0.0', changelog });
 
@@ -170,48 +174,56 @@ test.serial('should commit and tag with quoted characters', async t => {
   await gitClient.tag({ name: '1.0.0' });
   await gitClient.push();
   {
-    const { stdout } = sh.exec('git log -1 --format=%s');
+    const stdout = childProcess.execSync('git log -1 --format=%s', { encoding: 'utf-8' });
     t.is(stdout.trim(), 'Release 1.0.0');
   }
   {
-    const { stdout } = sh.exec('git tag -n99');
+    const stdout = childProcess.execSync('git tag -n99', { encoding: 'utf-8' });
     t.is(stdout.trim(), `1.0.0           Release 1.0.0\n    \n    - Foo's\n    - "$bar"\n    - '$baz'\n    - foo`);
   }
 });
 
 test.serial('should push to origin', async t => {
   const bare = mkTmpDir();
-  sh.exec(`git init --bare ${bare}`);
-  sh.exec(`git clone ${bare} .`);
+  childProcess.execSync(`git init --bare ${bare}`, execOpts);
+  childProcess.execSync(`git clone ${bare} .`, execOpts);
   gitAdd('line', 'file', 'Add file');
   const gitClient = factory(Git);
   const spy = sinon.spy(gitClient.shell, 'exec');
   await gitClient.push();
   t.deepEqual(spy.lastCall.args[0], ['git', 'push']);
-  const actual = sh.exec('git ls-tree -r HEAD --name-only', { cwd: bare });
-  t.is(actual.trim(), 'file');
+  const stdout = childProcess.execSync('git ls-tree -r HEAD --name-only', {
+    cwd: bare,
+    encoding: 'utf-8'
+  });
+  t.is(stdout.trim(), 'file');
+
   spy.restore();
 });
 
 test.serial('should push to tracked upstream branch', async t => {
   const bare = mkTmpDir();
-  sh.exec(`git init --bare ${bare}`);
-  sh.exec(`git clone ${bare} .`);
-  sh.exec(`git remote rename origin upstream`);
+  childProcess.execSync(`git init --bare ${bare}`, execOpts);
+  childProcess.execSync(`git clone ${bare} .`, execOpts);
+  childProcess.execSync(`git remote rename origin upstream`, execOpts);
   gitAdd('line', 'file', 'Add file');
   const gitClient = factory(Git);
   const spy = sinon.spy(gitClient.shell, 'exec');
   await gitClient.push();
   t.deepEqual(spy.lastCall.args[0], ['git', 'push']);
-  const actual = sh.exec('git ls-tree -r HEAD --name-only', { cwd: bare });
-  t.is(actual.trim(), 'file');
+  const stdout = childProcess.execSync('git ls-tree -r HEAD --name-only', {
+    cwd: bare,
+    encoding: 'utf-8'
+  });
+  t.is(stdout.trim(), 'file');
+
   spy.restore();
 });
 
 test.serial('should push to repo url', async t => {
   const bare = mkTmpDir();
-  sh.exec(`git init --bare ${bare}`);
-  sh.exec(`git clone ${bare} .`);
+  childProcess.execSync(`git init --bare ${bare}`, execOpts);
+  childProcess.execSync(`git clone ${bare} .`, execOpts);
   gitAdd('line', 'file', 'Add file');
   const options = { git: { pushRepo: 'https://host/repo.git' } };
   const gitClient = factory(Git, { options });
@@ -226,19 +238,28 @@ test.serial('should push to repo url', async t => {
 
 test.serial('should push to remote name (not "origin")', async t => {
   const bare = mkTmpDir();
-  sh.exec(`git init --bare ${bare}`);
-  sh.exec(`git clone ${bare} .`);
+  childProcess.execSync(`git init --bare ${bare}`, execOpts);
+  childProcess.execSync(`git clone ${bare} .`, execOpts);
   gitAdd('line', 'file', 'Add file');
-  sh.exec(`git remote add upstream ${sh.exec('git config --get remote.origin.url')}`);
+  childProcess.execSync(
+    `git remote add upstream ${childProcess.execSync('git config --get remote.origin.url', {
+      encoding: 'utf-8'
+    })}`,
+    execOpts
+  );
   const options = { git: { pushRepo: 'upstream' } };
   const gitClient = factory(Git, { options });
   const spy = sinon.spy(gitClient.shell, 'exec');
   await gitClient.push();
   t.deepEqual(spy.lastCall.args[0], ['git', 'push', 'upstream']);
-  const actual = sh.exec('git ls-tree -r HEAD --name-only', { cwd: bare });
-  t.is(actual.trim(), 'file');
+  const stdout = childProcess.execSync('git ls-tree -r HEAD --name-only', {
+    cwd: bare,
+    encoding: 'utf-8'
+  });
+  t.is(stdout.trim(), 'file');
+
   {
-    sh.exec(`git checkout -b foo`);
+    childProcess.execSync(`git checkout -b foo`, execOpts);
     gitAdd('line', 'file', 'Add file');
     await gitClient.push();
     t.deepEqual(spy.lastCall.args[0], ['git', 'push', '--set-upstream', 'upstream', 'foo']);
@@ -252,19 +273,22 @@ test.serial('should push to remote name (not "origin")', async t => {
 
 test.serial('should return repo status', async t => {
   const gitClient = factory(Git);
-  sh.exec('git init');
+  childProcess.execSync('git init', execOpts);
   gitAdd('line', 'file1', 'Add file');
-  sh.ShellString('line').toEnd('file1');
-  sh.ShellString('line').toEnd('file2');
-  sh.exec('git add file2');
+
+  appendFileSync('file1', 'line');
+
+  appendFileSync('file2', 'line');
+  childProcess.execSync('git add file2', execOpts);
   t.is(await gitClient.status(), ' M file1\nA  file2');
 });
 
 test.serial('should reset files', async t => {
   const gitClient = factory(Git);
-  sh.exec('git init');
+  childProcess.execSync('git init', execOpts);
   gitAdd('line', 'file', 'Add file');
-  sh.ShellString('line').toEnd('file');
+
+  appendFileSync('file', 'line');
   t.regex(await readFile('file'), /^line\s*line\s*$/);
   await gitClient.reset('file');
   t.regex(await readFile('file'), /^line\s*$/);
@@ -273,19 +297,19 @@ test.serial('should reset files', async t => {
 });
 
 test.serial('should roll back when cancelled', async t => {
-  sh.exec('git init');
-  sh.exec(`git remote add origin file://foo`);
+  childProcess.execSync('git init', execOpts);
+  childProcess.execSync(`git remote add origin file://foo`, execOpts);
   const version = '1.2.3';
   gitAdd(`{"version":"${version}"}`, 'package.json', 'Add package.json');
   const options = { git: { requireCleanWorkingDir: true, commit: true, tag: true, tagName: 'v${version}' } };
   const gitClient = factory(Git, { options });
   const exec = sinon.spy(gitClient.shell, 'execFormattedCommand');
-  sh.exec(`git tag ${version}`);
+  childProcess.execSync(`git tag ${version}`, execOpts);
   gitAdd('line', 'file', 'Add file');
 
   await gitClient.init();
 
-  sh.exec('npm --no-git-tag-version version patch');
+  childProcess.execSync('npm --no-git-tag-version version patch', execOpts);
 
   gitClient.bump('1.2.4');
   await gitClient.beforeRelease();
@@ -298,21 +322,23 @@ test.serial('should roll back when cancelled', async t => {
   t.is(exec.args[12][0], 'git reset --hard HEAD~1');
 });
 
+// To get this test to pass, I had to switch between spawnsync and execsync somehow
 test.serial('should remove remote tag when push to branch failed', async t => {
-  sh.exec('git init');
-  sh.exec(`git remote add origin file://foo`);
+  childProcess.execSync('git init', execOpts);
+  childProcess.execSync(`git remote add origin file://foo`, execOpts);
+  sh.exec(`git remote update`, execOpts);
   const version = '1.2.3';
   gitAdd(`{"version":"${version}"}`, 'package.json', 'Add package.json');
   const options = { git: { requireCleanWorkingDir: true, commit: true, tag: true, tagName: 'v${version}' } };
   const gitClient = factory(Git, { options });
   const exec = sinon.spy(gitClient.shell, 'execFormattedCommand');
-  sh.exec(`git push`);
-  sh.exec(`git checkout HEAD~1`);
+  sh.exec(`git push`, execOpts);
+  sh.exec(`git checkout HEAD~1`, execOpts);
   gitAdd('line', 'file', 'Add file');
 
   await gitClient.init();
 
-  sh.exec('npm --no-git-tag-version version patch');
+  childProcess.execSync('npm --no-git-tag-version version patch', execOpts);
 
   gitClient.bump('1.2.4');
   await gitClient.beforeRelease();
@@ -328,12 +354,12 @@ test.serial('should remove remote tag when push to branch failed', async t => {
 });
 
 test.serial('should not touch existing history when rolling back', async t => {
-  sh.exec('git init');
+  childProcess.execSync('git init', execOpts);
   const version = '1.2.3';
   gitAdd(`{"version":"${version}"}`, 'package.json', 'Add package.json');
   const options = { git: { requireCleanWorkingDir: true, commit: true, tag: true } };
   const gitClient = factory(Git, { options });
-  sh.exec(`git tag ${version}`);
+  childProcess.execSync(`git tag ${version}`, execOpts);
 
   const exec = sinon.spy(gitClient.shell, 'execFormattedCommand');
   gitClient.config.setContext({ version: '1.2.4' });
@@ -346,7 +372,7 @@ test.serial('should not touch existing history when rolling back', async t => {
 
 // eslint-disable-next-line ava/no-skip-test
 test.serial.skip('should not roll back with risky config', async t => {
-  sh.exec('git init');
+  childProcess.execSync('git init', execOpts);
   const options = { git: { requireCleanWorkingDir: false, commit: true, tag: true } };
   const gitClient = factory(Git, { options });
   await gitClient.beforeRelease();
@@ -354,7 +380,7 @@ test.serial.skip('should not roll back with risky config', async t => {
 });
 
 test.serial('should return latest tag from default branch (not parent commit)', async t => {
-  sh.exec('git init');
+  childProcess.execSync('git init', execOpts);
 
   {
     const options = { git: { getLatestTagFromAllRefs: true } };
@@ -364,19 +390,19 @@ test.serial('should return latest tag from default branch (not parent commit)',
     const developBranchName = 'develop';
     const featureBranchPrefix = 'feature';
     await gitClient.tag({ name: '1.0.0' });
-    sh.exec(`git branch ${developBranchName} ${defaultBranchName}`);
-    sh.exec(`git checkout -b ${featureBranchPrefix}/first ${developBranchName}`);
+    childProcess.execSync(`git branch ${developBranchName} ${defaultBranchName}`, execOpts);
+    childProcess.execSync(`git checkout -b ${featureBranchPrefix}/first ${developBranchName}`, execOpts);
     gitAdd('feature/1', 'file', 'Update file in feature branch (1)');
-    sh.exec(`git checkout ${developBranchName}`);
-    sh.exec(`git merge --no-ff ${featureBranchPrefix}/first`);
+    childProcess.execSync(`git checkout ${developBranchName}`, execOpts);
+    childProcess.execSync(`git merge --no-ff ${featureBranchPrefix}/first`, execOpts);
     await gitClient.tag({ name: '1.1.0-rc.1' });
-    sh.exec(`git checkout ${defaultBranchName}`);
-    sh.exec(`git merge --no-ff ${developBranchName}`);
+    childProcess.execSync(`git checkout ${defaultBranchName}`, execOpts);
+    childProcess.execSync(`git merge --no-ff ${developBranchName}`, execOpts);
     await gitClient.tag({ name: '1.1.0' });
-    sh.exec(`git checkout -b ${featureBranchPrefix}/second ${developBranchName}`);
+    childProcess.execSync(`git checkout -b ${featureBranchPrefix}/second ${developBranchName}`, execOpts);
     gitAdd('feature/2', 'file', 'Update file again, in feature branch (2)');
-    sh.exec(`git checkout ${developBranchName}`);
-    sh.exec(`git merge --no-ff ${featureBranchPrefix}/second`);
+    childProcess.execSync(`git checkout ${developBranchName}`, execOpts);
+    childProcess.execSync(`git merge --no-ff ${featureBranchPrefix}/second`, execOpts);
     t.is(await gitClient.getLatestTagName(), '1.1.0');
   }
 

package/test/npm.js

@@ -372,6 +372,7 @@ test('should not publish when `npm version` fails', async t => {
   const options = { npm };
   const npmClient = factory(npm, { options });
   const exec = sinon.stub(npmClient.shell, 'exec').resolves();
+
   exec.withArgs('npm whoami').resolves('john');
   exec
     .withArgs(/npm access (list collaborators --json|ls-collaborators) @my-scope\/my-pkg/)

package/test/plugins.js

@@ -1,11 +1,12 @@
-import { join } from 'node:path';
+import { resolve, join } from 'node:path';
+import childProcess from 'node:child_process';
+import fs, { appendFileSync, mkdirSync } from 'node:fs';
 import test from 'ava';
-import sh from 'shelljs';
 import sinon from 'sinon';
 import Log from '../lib/log.js';
 import Spinner from '../lib/spinner.js';
 import Config from '../lib/config.js';
-import { parseGitUrl } from '../lib/util.js';
+import { execOpts, parseGitUrl } from '../lib/util.js';
 import runTasks from '../lib/index.js';
 import MyPlugin from './stub/plugin.js';
 import ReplacePlugin from './stub/plugin-replace.js';
@@ -39,12 +40,12 @@ const getContainer = options => {
 
 test.before(t => {
   t.timeout(60 * 1000);
-  sh.exec('npm link');
+  childProcess.execSync('npm link', execOpts);
 });
 
 test.serial.beforeEach(t => {
   const dir = mkTmpDir();
-  sh.pushd('-q', dir);
+  process.chdir(dir);
   t.context = { dir };
 });
 
@@ -56,25 +57,26 @@ test.serial('should instantiate plugins and execute all release-cycle methods',
   const { dir } = t.context;
 
   const pluginDir = mkTmpDir();
-  sh.pushd('-q', pluginDir);
-  sh.ShellString(JSON.stringify({ name: 'my-plugin', version: '1.0.0', type: 'module' })).toEnd(
-    join(pluginDir, 'package.json')
+  process.chdir(pluginDir);
+
+  appendFileSync(
+    join(pluginDir, 'package.json'),
+    JSON.stringify({ name: 'my-plugin', version: '1.0.0', type: 'module' })
   );
-  sh.exec(`npm link release-it`);
+  childProcess.execSync(`npm link release-it`, execOpts);
   const content = "import { Plugin } from 'release-it'; " + MyPlugin.toString() + '; export default MyPlugin;';
-  sh.ShellString(content).toEnd(join(pluginDir, 'index.js'));
 
-  sh.pushd('-q', dir);
-  sh.mkdir('-p', 'my/plugin');
-  sh.pushd('-q', 'my/plugin');
-  sh.ShellString(content).toEnd(join(dir, 'my', 'plugin', 'index.js'));
+  appendFileSync(join(pluginDir, 'index.js'), content);
+  process.chdir(dir);
+  mkdirSync(resolve('my/plugin'), { recursive: true });
+  process.chdir('my/plugin');
 
-  sh.pushd('-q', dir);
-  sh.ShellString(JSON.stringify({ name: 'project', version: '1.0.0', type: 'module' })).toEnd(
-    join(dir, 'package.json')
-  );
-  sh.exec(`npm install ${pluginDir}`);
-  sh.exec(`npm link release-it`);
+  appendFileSync(join(dir, 'my', 'plugin', 'index.js'), content);
+  process.chdir(dir);
+
+  appendFileSync(join(dir, 'package.json'), JSON.stringify({ name: 'project', version: '1.0.0', type: 'module' }));
+  childProcess.execSync(`npm install ${pluginDir}`, execOpts);
+  childProcess.execSync(`npm link release-it`, execOpts);
 
   const config = {
     plugins: {
@@ -125,20 +127,21 @@ test.serial('should instantiate plugins and execute all release-cycle methods fo
   const { dir } = t.context;
 
   const pluginDir = mkTmpDir();
-  sh.pushd('-q', pluginDir);
-  sh.ShellString(JSON.stringify({ name: '@scoped/my-plugin', version: '1.0.0', type: 'module' })).toEnd(
-    join(pluginDir, 'package.json')
+  process.chdir(pluginDir);
+
+  fs.writeFileSync(
+    join(pluginDir, 'package.json'),
+    JSON.stringify({ name: '@scoped/my-plugin', version: '1.0.0', type: 'module' })
   );
-  sh.exec(`npm link release-it`);
+  childProcess.execSync(`npm link release-it`, execOpts);
   const content = "import { Plugin } from 'release-it'; " + MyPlugin.toString() + '; export default MyPlugin;';
-  sh.ShellString(content).toEnd(join(pluginDir, 'index.js'));
 
-  sh.pushd('-q', dir);
-  sh.ShellString(JSON.stringify({ name: 'project', version: '1.0.0', type: 'module' })).toEnd(
-    join(dir, 'package.json')
-  );
-  sh.exec(`npm install ${pluginDir}`);
-  sh.exec(`npm link release-it`);
+  fs.writeFileSync(join(pluginDir, 'index.js'), content);
+  process.chdir(dir);
+
+  fs.writeFileSync(join(dir, 'package.json'), JSON.stringify({ name: 'project', version: '1.0.0', type: 'module' }));
+  childProcess.execSync(`npm install ${pluginDir}`, execOpts);
+  childProcess.execSync(`npm link release-it`, execOpts);
 
   const config = {
     plugins: {
@@ -174,11 +177,13 @@ test.serial('should instantiate plugins and execute all release-cycle methods fo
 
 test.serial('should disable core plugins', async t => {
   const { dir } = t.context;
-  sh.ShellString(JSON.stringify({ name: 'project', version: '1.0.0' })).toEnd(join(dir, 'package.json'));
+
+  fs.appendFileSync(join(dir, 'package.json'), JSON.stringify({ name: 'project', version: '1.0.0' }));
   const content =
     "import { Plugin } from 'release-it'; " + ReplacePlugin.toString() + '; export default ReplacePlugin;';
-  sh.ShellString(content).toEnd(join(dir, 'replace-plugin.mjs'));
-  sh.exec(`npm link release-it`);
+
+  fs.appendFileSync(join(dir, 'replace-plugin.mjs'), content);
+  childProcess.execSync(`npm link release-it`, execOpts);
 
   const config = {
     plugins: {
@@ -199,13 +204,13 @@ test.serial('should disable core plugins', async t => {
 
 test.serial('should expose context to execute commands', async t => {
   const { dir } = t.context;
-  sh.ShellString(JSON.stringify({ name: 'pkg-name', version: '1.0.0', type: 'module' })).toEnd(
-    join(dir, 'package.json')
-  );
+
+  fs.appendFileSync(join(dir, 'package.json'), JSON.stringify({ name: 'pkg-name', version: '1.0.0', type: 'module' }));
   const content =
     "import { Plugin } from 'release-it'; " + ContextPlugin.toString() + '; export default ContextPlugin;';
-  sh.ShellString(content).toEnd(join(dir, 'context-plugin.js'));
-  sh.exec(`npm link release-it`);
+
+  fs.appendFileSync(join(dir, 'context-plugin.js'), content);
+  childProcess.execSync(`npm link release-it`, execOpts);
 
   const repo = parseGitUrl('https://github.com/user/pkg');
 

package/test/shell.js

@@ -1,12 +1,11 @@
+import childProcess from 'node:child_process';
 import test from 'ava';
-import sh from 'shelljs';
 import sinon from 'sinon';
 import Shell from '../lib/shell.js';
 import Log from '../lib/log.js';
 import { factory } from './util/index.js';
 
-const { stdout } = sh.exec('pwd');
-const cwd = stdout.trim();
+const cwd = childProcess.execSync('pwd', { encoding: 'utf8' }).trim();
 
 const shell = factory(Shell);