@aikidosec/safe-chain 1.0.10 → 1.0.12

package/README.md

@@ -6,50 +6,52 @@ The Aikido Safe Chain wraps around the [npm cli](https://github.com/npm/cli), [n
 
 ## Installation
 
-To install the Aikido Safe Chain, you can use the following command:
+Installing the Aikido Safe Chain is easy. You just need 3 simple steps:
 
-```shell
-npm i -g @aikidosec/safe-chain
-```
+1. **Install the Aikido Safe Chain package globally** using npm:
+   ```shell
+   npm install -g @aikidosec/safe-chain
+   ```
+2. **Setup the shell integration** by running:
+   ```shell
+   safe-chain setup
+   ```
+3. **Restart your terminal** to start using the Aikido Safe Chain.
 
-Now you should be able to use the `aikido-npm`, `aikido-npx`, or `aikido-yarn` command instead of `npm`, `npx`, or `yarn`. Example: `aikido-npm install axios`, `aikido-yarn add lodash`.
+When running `npm`, `npx`, or `yarn` commands, the Aikido Safe Chain will automatically check for malware in the packages you are trying to install. If any malware is detected, it will prompt you to exit the command.
 
 ## Aliases in shell
 
-It is possible to create aliases in your shell startup script to make it easier to use the Aikido Safe Chain. This is useful if you want to use the Aikido Safe Chain as a drop-in replacement for **npm**, **npx**, or **yarn**. The aikido-npm, aikido-npx, and aikido-yarn commands will scan for malware and prompt you to exit if any is found. If not, they will run the original **npm**, **npx**, or **yarn** command.
+The Aikido Safe Chain will setup aliases in your shell for the commands **npm**, **npx**, and **yarn**. This means that when you run these commands, they will be replaced with the Aikido Safe Chain commands **aikido-npm**, **aikido-npx**, and **aikido-yarn** respectively. The Aikido Safe Chain will do a pre-install check for malware before running the original command.
 
-### Creating an alias
+### Creating shell aliases
 
-The `add-aikido-aliases` command will add the aliases for **npm**, **npx**, and **yarn** to your shell startup script.
+The `setup` command will detect which shells are installed and add the aliases for **npm**, **npx**, and **yarn** to your shell startup scripts.
 
-To add aliases to your shell startup script, you can use the built-in command `aikido-npm add-aikido-aliases`:
+Supported shells include:
 
-```shell
-# Example for bash
-aikido-npm add-aikido-aliases ~/.bashrc
+- ✅ **Bash**: `~/.bashrc`
+- ✅ **Zsh**: `~/.zshrc`
+- ✅ **Fish**: `~/.config/fish/config.fish`
+- ✅ **Powershell**: `$PROFILE`
+- ✅ **PowerShell Core**: `$PROFILE`
 
-# Example for zsh
-aikido-npm add-aikido-aliases ~/.zshrc
-
-# Example for powershell
-aikido-npm add-aikido-aliases $PROFILE
-```
-
-This will create the aliases. The following table shows the aliases that will be created in the shell startup script:
+After adding the alias, **the shell needs to restart in order to load the alias**.
 
-| Shell          | Startup script             | Npm Alias                               | Npx Alias                               | Yarn Alias                                |
-| -------------- | -------------------------- | --------------------------------------- | --------------------------------------- | ----------------------------------------- |
-| **Bash**       | ~/.bashrc                  | `alias npm='aikido-npm'`                | `alias npx='aikido-npx'`                | `alias yarn='aikido-yarn'`                |
-| **Zsh**        | ~/.zshrc                   | `alias npm='aikido-npm'`                | `alias npx='aikido-npx'`                | `alias yarn='aikido-yarn'`                |
-| **Ash**        | ~/.profile, ~/.ashrc       | `alias npm='aikido-npm'`                | `alias npx='aikido-npx'`                | `alias yarn='aikido-yarn'`                |
-| **Fish**       | ~/.config/fish/config.fish | `alias npm "aikido-npm"`                | `alias npx "aikido-npx"`                | `alias yarn "aikido-yarn"`                |
-| **Powershell** | $PROFILE                   | `Set-Alias -Name npm -Value aikido-npm` | `Set-Alias -Name npx -Value aikido-npx` | `Set-Alias -Name yarn -Value aikido-yarn` |
+### Removing shell aliases
 
-After adding the alias, **the shell needs to restart in order to load the alias**.
+The `teardown` command will remove the aliases for **npm**, **npx**, and **yarn** from your shell startup scripts. This is useful if you want to stop using the Aikido Safe Chain or if you want to switch to a different package manager.
 
-### Removing the alias
+## Uninstallation
 
-To remove the added aliases, you can use the built-in commands of `aikido-npm`:
+To uninstall the Aikido Safe Chain, you can run the following command:
 
-- `aikido-npm remove-aikido-aliases file_name` (eg `~/.bashrc`, `~/.zshrc`, etc.)
-  This will remove the aliases if they are present in the file.
+1. **Remove all aliases from your shell** by running:
+   ```shell
+   safe-chain teardown
+   ```
+2. **Uninstall the Aikido Safe Chain package** using npm:
+   ```shell
+   npm uninstall -g @aikidosec/safe-chain
+   ```
+3. **Restart your terminal** to remove the aliases.

package/bin/safe-chain.js

@@ -0,0 +1,57 @@
+#!/usr/bin/env node
+
+import chalk from "chalk";
+import { ui } from "../src/environment/userInteraction.js";
+import { setup } from "../src/shell-integration/setup.js";
+import { teardown } from "../src/shell-integration/teardown.js";
+
+if (process.argv.length < 3) {
+  ui.writeError("No command provided. Please provide a command to execute.");
+  ui.emptyLine();
+  writeHelp();
+  process.exit(1);
+}
+
+const command = process.argv[2];
+
+if (command === "help" || command === "--help" || command === "-h") {
+  writeHelp();
+  process.exit(0);
+}
+
+if (command === "setup") {
+  setup();
+} else if (command === "teardown") {
+  teardown();
+} else {
+  ui.writeError(`Unknown command: ${command}.`);
+  ui.emptyLine();
+
+  writeHelp();
+
+  process.exit(1);
+}
+
+function writeHelp() {
+  ui.writeInformation(
+    chalk.bold("Usage: ") + chalk.cyan("safe-chain <command>")
+  );
+  ui.emptyLine();
+  ui.writeInformation(
+    `Available commands: ${chalk.cyan("setup")}, ${chalk.cyan(
+      "teardown"
+    )}, ${chalk.cyan("help")}`
+  );
+  ui.emptyLine();
+  ui.writeInformation(
+    `- ${chalk.cyan(
+      "safe-chain setup"
+    )}: This will setup your shell to wrap safe-chain around npm, npx and yarn.`
+  );
+  ui.writeInformation(
+    `- ${chalk.cyan(
+      "safe-chain teardown"
+    )}: This will remove safe-chain aliases from your shell configuration.`
+  );
+  ui.emptyLine();
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aikidosec/safe-chain",
-  "version": "1.0.10",
+  "version": "1.0.12",
   "scripts": {
     "test": "node --test --experimental-test-module-mocks **/*.spec.js",
     "test:watch": "node --test --watch --experimental-test-module-mocks **/*.spec.js",
@@ -13,7 +13,8 @@
   "bin": {
     "aikido-npm": "bin/aikido-npm.js",
     "aikido-npx": "bin/aikido-npx.js",
-    "aikido-yarn": "bin/aikido-yarn.js"
+    "aikido-yarn": "bin/aikido-yarn.js",
+    "safe-chain": "bin/safe-chain.js"
   },
   "type": "module",
   "keywords": [],

package/src/main.js

@@ -1,24 +1,11 @@
 #!/usr/bin/env node
 
 import { scanCommand, shouldScanCommand } from "./scanning/index.js";
-import { isAddAliasCommand, addAlias } from "./shell-integration/addAlias.js";
-import {
-  removeAlias,
-  isRemoveAliasCommand,
-} from "./shell-integration/removeAlias.js";
 import { ui } from "./environment/userInteraction.js";
 import { getPackageManager } from "./packagemanager/currentPackageManager.js";
 
 export async function main(args) {
   try {
-    if (isAddAliasCommand(args)) {
-      addAlias(args);
-      return;
-    }
-    if (isRemoveAliasCommand(args)) {
-      removeAlias(args);
-      return;
-    }
     if (shouldScanCommand(args)) {
       await scanCommand(args);
     }

package/src/scanning/index.js

@@ -86,9 +86,7 @@ async function acceptRiskOrExit(message, defaultValue) {
     return;
   }
 
-  ui.writeInformation(
-    "Exiting without installing packages. Please check the output."
-  );
+  ui.writeInformation("Exiting without installing packages.");
   ui.emptyLine();
   process.exit(1);
 }

package/src/shell-integration/setup.js

@@ -0,0 +1,151 @@
+import chalk from "chalk";
+import { ui } from "../environment/userInteraction.js";
+import { detectShells } from "./shellDetection.js";
+import { getAliases } from "./helpers.js";
+import fs from "fs";
+import { EOL } from "os";
+
+export async function setup() {
+  ui.writeInformation(
+    chalk.bold("Setting up shell aliases.") +
+      " This will wrap safe-chain around npm, npx, and yarn commands."
+  );
+  ui.emptyLine();
+
+  try {
+    const shells = detectShells();
+    if (shells.length === 0) {
+      ui.writeError("No supported shells detected. Cannot set up aliases.");
+      return;
+    }
+
+    ui.writeInformation(
+      `Detected ${shells.length} supported shell(s): ${shells
+        .map((shell) => chalk.bold(shell.name))
+        .join(", ")}.`
+    );
+
+    let updatedCount = 0;
+    for (const shell of shells) {
+      if (setupAliasesForShell(shell)) {
+        updatedCount++;
+      }
+    }
+
+    if (updatedCount > 0) {
+      ui.emptyLine();
+      ui.writeInformation(`Please restart your terminal to apply the changes.`);
+    }
+  } catch (error) {
+    ui.writeError(
+      `Failed to set up shell aliases: ${error.message}. Please check your shell configuration.`
+    );
+    return;
+  }
+}
+
+/**
+ * This function sets up aliases for the given shell.
+ * It reads the shell's startup file (eg ~/.bashrc, ~/.zshrc, etc.),
+ * and then appends the aliases for npm, npx, and yarn commands.
+ * If the aliases already exist, it will not add them again.
+ * If the startup file does not exist, it will create it.
+ *
+ * The shell startup script is loaded by the respective shell when it starts.
+ * This means that the aliases will be available in the shell after it is restarted.
+ */
+function setupAliasesForShell(shell) {
+  if (!shell.startupFile) {
+    ui.writeError(
+      `- ${chalk.bold(
+        shell.name
+      )}: no startup file found. Cannot set up aliases.`
+    );
+    return false;
+  }
+
+  const aliases = getAliases(shell.startupFile);
+
+  if (aliases.length === 0) {
+    ui.writeError(`- ${chalk.bold(shell.name)}: could not generate aliases.`);
+    return false;
+  }
+
+  const fileContent = readOrCreateStartupFile(shell.startupFile);
+  const { addedCount, existingCount, failedCount } = appendAliasesToFile(
+    aliases,
+    fileContent,
+    shell.startupFile
+  );
+
+  let summary = "- " + chalk.bold(shell.name) + ": ";
+
+  if (addedCount > 0) {
+    summary += chalk.green(`${addedCount} aliases were added`);
+  }
+  if (existingCount > 0) {
+    if (addedCount > 0) {
+      summary += ", ";
+    }
+    summary += chalk.yellow(`${existingCount} aliases were already present`);
+  }
+  if (failedCount > 0) {
+    if (addedCount > 0 || existingCount > 0) {
+      summary += ", ";
+    }
+    summary += chalk.red(`${failedCount} aliases failed to add`);
+  }
+
+  // write summary in a single line
+  ui.writeInformation(summary);
+
+  return true;
+}
+
+/**
+ * This reads the content of the startup file.
+ * If the file does not exist, it creates an empty file and returns an empty string.
+ * The startup file is the shell's startup script (eg: ~/.bashrc, ~/.zshrc, etc.).
+ * It is used to set up the shell environment when it starts.
+ * Some shells may not have a startup file, in which case this function will create one.
+ */
+export function readOrCreateStartupFile(filePath) {
+  if (!fs.existsSync(filePath)) {
+    fs.writeFileSync(filePath, "", "utf-8");
+    ui.writeInformation(`File ${filePath} created.`);
+  }
+  return fs.readFileSync(filePath, "utf-8");
+}
+
+/**
+ * This function appends the aliases to the startup file.
+ *  eg: for bash it will append 'alias npm="aikido-npm"' for npm to ~/.bashrc
+ * @returns an object with the counts of added, existing, and failed aliases.
+ */
+export function appendAliasesToFile(aliases, fileContent, startupFilePath) {
+  let addedCount = 0;
+  let existingCount = 0;
+  let failedCount = 0;
+
+  for (const alias of aliases) {
+    try {
+      if (fileContent.includes(alias)) {
+        existingCount++;
+        continue;
+      }
+
+      fs.appendFileSync(startupFilePath, `${EOL}${alias}`, "utf-8");
+
+      addedCount++;
+    } catch {
+      failedCount++;
+      continue;
+    }
+  }
+
+  return {
+    addedCount,
+    existingCount,
+    failedCount,
+  };
+}

package/src/shell-integration/setup.spec.js

@@ -0,0 +1,304 @@
+import { describe, it } from "node:test";
+import assert from "node:assert";
+import { EOL, tmpdir } from "node:os";
+import fs from "node:fs";
+import { getAliases } from "./helpers.js";
+import { readOrCreateStartupFile, appendAliasesToFile } from "./setup.js";
+
+describe("setupShell", () => {
+  function runSetupTestsForEnvironment(shell, startupExtension, expectedAliases) {
+    describe(`${shell} shell setup`, () => {
+      it(`should add aliases to ${shell} file`, () => {
+        const lines = [`#!/usr/bin/env ${shell}`, "", "alias cls='clear'"];
+        const filePath = createShellStartupScript(lines, startupExtension);
+        
+        const aliases = getAliases(filePath);
+        const fileContent = fs.readFileSync(filePath, "utf-8");
+        
+        const result = appendAliasesToFile(aliases, fileContent, filePath);
+        
+        assert.strictEqual(result.addedCount, 3, "Should add 3 aliases");
+        assert.strictEqual(result.existingCount, 0, "Should find no existing aliases");
+        assert.strictEqual(result.failedCount, 0, "Should have no failed aliases");
+        
+        const updatedContent = readAndDeleteFile(filePath);
+        for (const alias of expectedAliases) {
+          assert.ok(updatedContent.includes(alias), `Alias "${alias}" should be added`);
+        }
+        assert.ok(updatedContent.includes("alias cls='clear'"), "Original aliases should remain");
+      });
+
+      it(`should not add aliases if they already exist in ${shell} file`, () => {
+        const lines = [`#!/usr/bin/env ${shell}`, "", ...expectedAliases];
+        const filePath = createShellStartupScript(lines, startupExtension);
+        
+        const aliases = getAliases(filePath);
+        const fileContent = fs.readFileSync(filePath, "utf-8");
+        
+        const result = appendAliasesToFile(aliases, fileContent, filePath);
+        
+        assert.strictEqual(result.addedCount, 0, "Should add 0 aliases");
+        assert.strictEqual(result.existingCount, 3, "Should find 3 existing aliases");
+        assert.strictEqual(result.failedCount, 0, "Should have no failed aliases");
+        
+        const updatedContent = readAndDeleteFile(filePath);
+        // Count occurrences to ensure no duplicates were added
+        for (const alias of expectedAliases) {
+          assert.strictEqual(countOccurrences(updatedContent, alias), 1, `Alias "${alias}" should appear exactly once`);
+        }
+      });
+
+      it(`should create file and add aliases if file does not exist for ${shell}`, () => {
+        const randomName = Math.random().toString(36).substring(2, 15);
+        const filePath = `${tmpdir()}/nonexistent-${randomName}${startupExtension}`;
+        if (fs.existsSync(filePath)) {
+          fs.rmSync(filePath, { force: true });
+        }
+        
+        // Test readOrCreateStartupFile function
+        const fileContent = readOrCreateStartupFile(filePath);
+        assert.strictEqual(fileContent, "", "Should return empty string for new file");
+        assert.ok(fs.existsSync(filePath), "File should be created");
+        
+        // Test adding aliases to the newly created file
+        const aliases = getAliases(filePath);
+        const result = appendAliasesToFile(aliases, fileContent, filePath);
+        
+        assert.strictEqual(result.addedCount, 3, "Should add 3 aliases");
+        assert.strictEqual(result.existingCount, 0, "Should find no existing aliases");
+        assert.strictEqual(result.failedCount, 0, "Should have no failed aliases");
+        
+        const updatedContent = readAndDeleteFile(filePath);
+        for (const alias of expectedAliases) {
+          assert.ok(updatedContent.includes(alias), `Alias "${alias}" should be added`);
+        }
+      });
+
+      it(`should add aliases only once when called multiple times for ${shell}`, () => {
+        const lines = [`#!/usr/bin/env ${shell}`, ""];
+        const filePath = createShellStartupScript(lines, startupExtension);
+        
+        const aliases = getAliases(filePath);
+        
+        // First call - should add aliases
+        let fileContent = fs.readFileSync(filePath, "utf-8");
+        const result1 = appendAliasesToFile(aliases, fileContent, filePath);
+        assert.strictEqual(result1.addedCount, 3, "First call should add 3 aliases");
+        
+        // Second call - should detect existing aliases
+        fileContent = fs.readFileSync(filePath, "utf-8");
+        const result2 = appendAliasesToFile(aliases, fileContent, filePath);
+        assert.strictEqual(result2.addedCount, 0, "Second call should add 0 aliases");
+        assert.strictEqual(result2.existingCount, 3, "Second call should find 3 existing aliases");
+        
+        const updatedContent = readAndDeleteFile(filePath);
+        for (const alias of expectedAliases) {
+          assert.strictEqual(countOccurrences(updatedContent, alias), 1, `Alias "${alias}" should appear exactly once`);
+        }
+      });
+
+      it(`should use real getAliases() for ${shell} file`, () => {
+        const filePath = `${tmpdir()}/test${startupExtension}`;
+        const aliases = getAliases(filePath);
+        
+        // Verify we get the expected aliases for this shell type
+        assert.strictEqual(aliases.length, 3, "Should get 3 aliases (npm, npx, yarn)");
+        for (let i = 0; i < aliases.length; i++) {
+          assert.strictEqual(aliases[i], expectedAliases[i], `Alias ${i} should match expected format`);
+        }
+      });
+
+      it(`should handle mixed scenario - some existing, some new for ${shell}`, () => {
+        const lines = [`#!/usr/bin/env ${shell}`, "", expectedAliases[0], "alias other='command'"];
+        const filePath = createShellStartupScript(lines, startupExtension);
+        
+        const aliases = getAliases(filePath);
+        const fileContent = fs.readFileSync(filePath, "utf-8");
+        
+        const result = appendAliasesToFile(aliases, fileContent, filePath);
+        
+        assert.strictEqual(result.addedCount, 2, "Should add 2 new aliases");
+        assert.strictEqual(result.existingCount, 1, "Should find 1 existing alias");
+        assert.strictEqual(result.failedCount, 0, "Should have no failed aliases");
+        
+        const updatedContent = readAndDeleteFile(filePath);
+        for (const alias of expectedAliases) {
+          assert.ok(updatedContent.includes(alias), `Alias "${alias}" should be present`);
+        }
+        assert.ok(updatedContent.includes("alias other='command'"), "Other aliases should remain");
+      });
+    });
+  }
+
+  // Test for each shell type using real getAliases() output
+  runSetupTestsForEnvironment("bash", ".bashrc", [
+    "alias npm='aikido-npm'",
+    "alias npx='aikido-npx'",
+    "alias yarn='aikido-yarn'"
+  ]);
+
+  runSetupTestsForEnvironment("zsh", ".zshrc", [
+    "alias npm='aikido-npm'",
+    "alias npx='aikido-npx'",
+    "alias yarn='aikido-yarn'"
+  ]);
+
+  runSetupTestsForEnvironment("fish", ".fish", [
+    'alias npm "aikido-npm"',
+    'alias npx "aikido-npx"',
+    'alias yarn "aikido-yarn"'
+  ]);
+
+  runSetupTestsForEnvironment("pwsh", ".ps1", [
+    "Set-Alias npm aikido-npm",
+    "Set-Alias npx aikido-npx",
+    "Set-Alias yarn aikido-yarn"
+  ]);
+
+  describe("readOrCreateStartupFile", () => {
+    it("should read existing file content", () => {
+      const lines = ["#!/usr/bin/env bash", "", "alias test='echo test'"];
+      const filePath = createShellStartupScript(lines, ".bashrc");
+      
+      const content = readOrCreateStartupFile(filePath);
+      
+      assert.ok(content.includes("#!/usr/bin/env bash"), "Should contain shebang");
+      assert.ok(content.includes("alias test='echo test'"), "Should contain existing aliases");
+      
+      // Cleanup
+      fs.rmSync(filePath, { force: true });
+    });
+
+    it("should create file if it doesn't exist", () => {
+      const filePath = `${tmpdir()}/test-${Math.random().toString(36).substring(2, 15)}.bashrc`;
+      if (fs.existsSync(filePath)) {
+        fs.rmSync(filePath, { force: true });
+      }
+      
+      const content = readOrCreateStartupFile(filePath);
+      
+      assert.strictEqual(content, "", "Should return empty string for new file");
+      assert.ok(fs.existsSync(filePath), "File should be created");
+      
+      // Cleanup
+      fs.rmSync(filePath, { force: true });
+    });
+
+    it("should handle empty existing file", () => {
+      const filePath = `${tmpdir()}/test-${Math.random().toString(36).substring(2, 15)}.bashrc`;
+      fs.writeFileSync(filePath, "", "utf-8");
+      
+      const content = readOrCreateStartupFile(filePath);
+      
+      assert.strictEqual(content, "", "Should return empty string for empty file");
+      assert.ok(fs.existsSync(filePath), "File should still exist");
+      
+      // Cleanup
+      fs.rmSync(filePath, { force: true });
+    });
+  });
+
+  describe("appendAliasesToFile edge cases", () => {
+    it("should handle empty aliases array", () => {
+      const lines = ["#!/usr/bin/env bash", "", "alias test='echo test'"];
+      const filePath = createShellStartupScript(lines, ".bashrc");
+      const fileContent = fs.readFileSync(filePath, "utf-8");
+      
+      const result = appendAliasesToFile([], fileContent, filePath);
+      
+      assert.strictEqual(result.addedCount, 0, "Should add 0 aliases");
+      assert.strictEqual(result.existingCount, 0, "Should find 0 existing aliases");
+      assert.strictEqual(result.failedCount, 0, "Should have 0 failed aliases");
+      
+      const updatedContent = readAndDeleteFile(filePath);
+      assert.ok(updatedContent.includes("alias test='echo test'"), "Original content should remain");
+    });
+
+    it("should handle partial substring matches correctly", () => {
+      const lines = [
+        "#!/usr/bin/env bash",
+        "",
+        "alias npmx='some-other-command'", // Contains 'npm' but shouldn't match 'alias npm='
+        "alias test='echo test'"
+      ];
+      const filePath = createShellStartupScript(lines, ".bashrc");
+      const fileContent = fs.readFileSync(filePath, "utf-8");
+      
+      const aliases = ["alias npm='aikido-npm'"];
+      const result = appendAliasesToFile(aliases, fileContent, filePath);
+      
+      assert.strictEqual(result.addedCount, 1, "Should add 1 alias (npm)");
+      assert.strictEqual(result.existingCount, 0, "Should find 0 existing aliases");
+      assert.strictEqual(result.failedCount, 0, "Should have 0 failed aliases");
+      
+      const updatedContent = readAndDeleteFile(filePath);
+      assert.ok(updatedContent.includes("alias npm='aikido-npm'"), "npm alias should be added");
+      assert.ok(updatedContent.includes("alias npmx='some-other-command'"), "npmx alias should remain");
+    });
+
+    it("should handle file with only whitespace", () => {
+      const filePath = `${tmpdir()}/test-${Math.random().toString(36).substring(2, 15)}.bashrc`;
+      const fileContent = `${EOL}${EOL}   ${EOL}`;
+      fs.writeFileSync(filePath, fileContent, "utf-8");
+      
+      const aliases = ["alias npm='aikido-npm'"];
+      const result = appendAliasesToFile(aliases, fileContent, filePath);
+      
+      assert.strictEqual(result.addedCount, 1, "Should add 1 alias");
+      assert.strictEqual(result.existingCount, 0, "Should find 0 existing aliases");
+      assert.strictEqual(result.failedCount, 0, "Should have 0 failed aliases");
+      
+      const updatedContent = fs.readFileSync(filePath, "utf-8");
+      assert.ok(updatedContent.includes("alias npm='aikido-npm'"), "Alias should be added");
+      
+      // Cleanup
+      fs.rmSync(filePath, { force: true });
+    });
+  });
+
+  describe("appendAliasesToFile error handling", () => {
+    it("should handle file permission errors gracefully", () => {
+      const filePath = `${tmpdir()}/test-${Math.random().toString(36).substring(2, 15)}.bashrc`;
+      fs.writeFileSync(filePath, "#!/usr/bin/env bash", "utf-8");
+      
+      // Make file read-only to simulate permission error
+      fs.chmodSync(filePath, 0o444);
+      
+      const aliases = ["alias npm='aikido-npm'"];
+      const fileContent = fs.readFileSync(filePath, "utf-8");
+      
+      const result = appendAliasesToFile(aliases, fileContent, filePath);
+      
+      assert.strictEqual(result.addedCount, 0, "Should add 0 aliases due to permission error");
+      assert.strictEqual(result.existingCount, 0, "Should find 0 existing aliases");
+      assert.strictEqual(result.failedCount, 1, "Should have 1 failed alias");
+      
+      // Restore permissions and cleanup
+      fs.chmodSync(filePath, 0o644);
+      fs.rmSync(filePath, { force: true });
+    });
+  });
+});
+
+function createShellStartupScript(lines, fileExtension) {
+  const randomFileName = Math.random().toString(36).substring(2, 15);
+  const filePath = `${tmpdir()}/${randomFileName}${fileExtension}`;
+  fs.writeFileSync(filePath, lines.join(EOL), "utf-8");
+  return filePath;
+}
+
+function readAndDeleteFile(filePath) {
+  const fileContent = fs.readFileSync(filePath, "utf-8");
+  fs.rmSync(filePath, { force: true });
+  return fileContent.split(EOL);
+}
+
+function countOccurrences(lines, searchString) {
+  let count = 0;
+  for (const line of lines) {
+    if (line.includes(searchString)) {
+      count++;
+    }
+  }
+  return count;
+}

package/src/shell-integration/shellDetection.js

@@ -0,0 +1,75 @@
+import * as os from "os";
+import { execSync } from "child_process";
+
+const shellList = {
+  bash: {
+    name: "Bash",
+    executable: "bash",
+    getStartupFileCommand: "echo ~/.bashrc",
+  },
+  zsh: {
+    name: "Zsh",
+    executable: "zsh",
+    getStartupFileCommand: "echo ${ZDOTDIR:-$HOME}/.zshrc",
+  },
+  fish: {
+    name: "Fish",
+    executable: "fish",
+    getStartupFileCommand: "echo ~/.config/fish/config.fish",
+  },
+  powershell: {
+    name: "PowerShell Core",
+    executable: "pwsh",
+    getStartupFileCommand: "echo $PROFILE",
+  },
+  windowsPowerShell: {
+    name: "Windows PowerShell",
+    executable: "powershell",
+    getStartupFileCommand: "echo $PROFILE",
+  },
+};
+
+export function detectShells() {
+  let availableShells = [];
+
+  for (const shellName of Object.keys(shellList)) {
+    const shell = shellList[shellName];
+
+    if (isShellAvailable(shell)) {
+      const startupFile = getShellStartupFile(shell);
+      availableShells.push({
+        name: shell.name,
+        executable: shell.executable,
+        startupFile: startupFile || null,
+      });
+    }
+  }
+
+  return availableShells;
+}
+
+function isShellAvailable(shell) {
+  try {
+    if (os.platform() === "win32") {
+      execSync(`where ${shell.executable}`, { stdio: "ignore" });
+    } else {
+      execSync(`which ${shell.executable}`, { stdio: "ignore" });
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function getShellStartupFile(shell) {
+  try {
+    const command = shell.getStartupFileCommand;
+    const output = execSync(command, {
+      encoding: "utf8",
+      shell: shell.executable,
+    }).trim();
+    return output;
+  } catch {
+    return null;
+  }
+}

package/src/shell-integration/teardown.js

@@ -0,0 +1,140 @@
+import chalk from "chalk";
+import { ui } from "../environment/userInteraction.js";
+import { detectShells } from "./shellDetection.js";
+import { getAliases } from "./helpers.js";
+import fs from "fs";
+import { EOL } from "os";
+
+export async function teardown() {
+  ui.writeInformation(
+    chalk.bold("Removing shell aliases.") +
+      " This will remove safe-chain aliases for npm, npx, and yarn commands."
+  );
+  ui.emptyLine();
+
+  try {
+    const shells = detectShells();
+    if (shells.length === 0) {
+      ui.writeError("No supported shells detected. Cannot remove aliases.");
+      return;
+    }
+
+    ui.writeInformation(
+      `Detected ${shells.length} supported shell(s): ${shells
+        .map((shell) => chalk.bold(shell.name))
+        .join(", ")}.`
+    );
+
+    let updatedCount = 0;
+    for (const shell of shells) {
+      if (removeAliasesForShell(shell)) {
+        updatedCount++;
+      }
+    }
+
+    if (updatedCount > 0) {
+      ui.emptyLine();
+      ui.writeInformation(`Please restart your terminal to apply the changes.`);
+    }
+  } catch (error) {
+    ui.writeError(
+      `Failed to remove shell aliases: ${error.message}. Please check your shell configuration.`
+    );
+    return;
+  }
+}
+
+/**
+ * This function removes aliases for the given shell.
+ * It reads the shell's startup file (eg ~/.bashrc, ~/.zshrc, etc.),
+ * and then removes the aliases for npm, npx, and yarn commands.
+ * If the aliases don't exist, it will report that they were not found.
+ * If the startup file does not exist, it will report that no aliases need to be removed.
+ *
+ * The shell startup script is loaded by the respective shell when it starts.
+ * This means that the aliases will be removed from the shell after it is restarted.
+ */
+function removeAliasesForShell(shell) {
+  if (!shell.startupFile) {
+    ui.writeError(
+      `- ${chalk.bold(
+        shell.name
+      )}: no startup file found. Cannot remove aliases.`
+    );
+    return false;
+  }
+
+  if (!fs.existsSync(shell.startupFile)) {
+    ui.writeInformation(
+      `- ${chalk.bold(
+        shell.name
+      )}: startup file does not exist. No aliases to remove.`
+    );
+    return false;
+  }
+
+  const aliases = getAliases(shell.startupFile);
+  const fileContent = fs.readFileSync(shell.startupFile, "utf-8");
+  const { removedCount, notFoundCount } = removeAliasesFromFile(
+    aliases,
+    fileContent,
+    shell.startupFile
+  );
+
+  let summary = "- " + chalk.bold(shell.name) + ": ";
+
+  if (removedCount > 0) {
+    summary += chalk.green(`${removedCount} aliases were removed`);
+  }
+  if (notFoundCount > 0) {
+    if (removedCount > 0) {
+      summary += ", ";
+    }
+    summary += chalk.yellow(`${notFoundCount} aliases were not found`);
+  }
+  if (removedCount === 0 && notFoundCount === 0) {
+    summary += chalk.yellow("no aliases found to remove");
+  }
+
+  ui.writeInformation(summary);
+  return removedCount > 0;
+}
+
+/**
+ * This function removes the aliases from the startup file.
+ * It searches for exact matches of each alias line and removes them.
+ * eg: for bash it will remove 'alias npm="aikido-npm"' for npm from ~/.bashrc
+ * @returns an object with the counts of removed and not found aliases.
+ */
+export function removeAliasesFromFile(aliases, fileContent, startupFilePath) {
+  let removedCount = 0;
+  let notFoundCount = 0;
+  let updatedContent = fileContent;
+
+  for (const alias of aliases) {
+    const lines = updatedContent.split(EOL);
+    let aliasLineIndex = lines.findIndex((line) => line.trim() === alias);
+
+    if (aliasLineIndex !== -1) {
+      removedCount++;
+
+      // Remove all occurrences of the alias line, in case it appears multiple times
+      while (aliasLineIndex !== -1) {
+        lines.splice(aliasLineIndex, 1);
+        aliasLineIndex = lines.findIndex((line) => line.trim() === alias);
+      }
+      updatedContent = lines.join(EOL);
+    } else {
+      notFoundCount++;
+    }
+  }
+
+  if (removedCount > 0) {
+    fs.writeFileSync(startupFilePath, updatedContent, "utf-8");
+  }
+
+  return {
+    removedCount,
+    notFoundCount,
+  };
+}

package/src/shell-integration/teardown.spec.js

@@ -0,0 +1,177 @@
+import { describe, it } from "node:test";
+import assert from "node:assert";
+import { EOL, tmpdir } from "node:os";
+import fs from "node:fs";
+import { getAliases } from "./helpers.js";
+import { removeAliasesFromFile } from "./teardown.js";
+
+describe("teardown", () => {
+  function runRemovalTestsForEnvironment(shell, startupExtension, expectedAliases) {
+    describe(`${shell} shell removal`, () => {
+      it(`should remove aliases from ${shell} file`, () => {
+        const lines = [`#!/usr/bin/env ${shell}`, "", ...expectedAliases, ""];
+        const filePath = createShellStartupScript(lines, startupExtension);
+        
+        // Test the removeAliasesFromFile function directly
+        const aliases = getAliases(filePath);
+        const fileContent = fs.readFileSync(filePath, "utf-8");
+        
+        const result = removeAliasesFromFile(aliases, fileContent, filePath);
+        
+        assert.strictEqual(result.removedCount, 3, "Should remove 3 aliases");
+        assert.strictEqual(result.notFoundCount, 0, "Should find all aliases");
+        
+        const updatedContent = readAndDeleteFile(filePath);
+        for (const alias of expectedAliases) {
+          assert.ok(!updatedContent.includes(alias), `Alias "${alias}" should be removed`);
+        }
+      });
+
+      it(`should handle file with no aliases for ${shell}`, () => {
+        const lines = [`#!/usr/bin/env ${shell}`, "", "alias other='command'", ""];
+        const filePath = createShellStartupScript(lines, startupExtension);
+        
+        const aliases = getAliases(filePath);
+        const fileContent = fs.readFileSync(filePath, "utf-8");
+        
+        const result = removeAliasesFromFile(aliases, fileContent, filePath);
+        
+        assert.strictEqual(result.removedCount, 0, "Should remove 0 aliases");
+        assert.strictEqual(result.notFoundCount, 3, "Should report 3 aliases not found");
+        
+        const updatedContent = readAndDeleteFile(filePath);
+        assert.ok(updatedContent.includes("alias other='command'"), "Other aliases should remain unchanged");
+      });
+
+      it(`should remove duplicate aliases from ${shell} file`, () => {
+        const lines = [
+          `#!/usr/bin/env ${shell}`,
+          "",
+          ...expectedAliases,
+          "alias other='command'",
+          ...expectedAliases, // duplicates
+          ""
+        ];
+        const filePath = createShellStartupScript(lines, startupExtension);
+        
+        const aliases = getAliases(filePath);
+        const fileContent = fs.readFileSync(filePath, "utf-8");
+        
+        const result = removeAliasesFromFile(aliases, fileContent, filePath);
+        
+        assert.strictEqual(result.removedCount, 3, "Should remove 3 aliases (counting duplicates as single removal)");
+        assert.strictEqual(result.notFoundCount, 0, "Should find all aliases");
+        
+        const updatedContent = readAndDeleteFile(filePath);
+        for (const alias of expectedAliases) {
+          assert.ok(!updatedContent.includes(alias), `Alias "${alias}" should be completely removed`);
+        }
+        assert.ok(updatedContent.includes("alias other='command'"), "Other aliases should remain");
+      });
+
+      it(`should use real getAliases() for ${shell} file`, () => {
+        const filePath = `${tmpdir()}/test${startupExtension}`;
+        const aliases = getAliases(filePath);
+        
+        // Verify we get the expected aliases for this shell type
+        assert.strictEqual(aliases.length, 3, "Should get 3 aliases (npm, npx, yarn)");
+        for (let i = 0; i < aliases.length; i++) {
+          assert.strictEqual(aliases[i], expectedAliases[i], `Alias ${i} should match expected format`);
+        }
+      });
+
+      it(`should handle partial alias matches for ${shell}`, () => {
+        const lines = [
+          `#!/usr/bin/env ${shell}`,
+          "",
+          expectedAliases[0], // Only first alias
+          "alias other='command'",
+          ""
+        ];
+        const filePath = createShellStartupScript(lines, startupExtension);
+        
+        const aliases = getAliases(filePath);
+        const fileContent = fs.readFileSync(filePath, "utf-8");
+        
+        const result = removeAliasesFromFile(aliases, fileContent, filePath);
+        
+        assert.strictEqual(result.removedCount, 1, "Should remove 1 alias");
+        assert.strictEqual(result.notFoundCount, 2, "Should report 2 aliases not found");
+        
+        const updatedContent = readAndDeleteFile(filePath);
+        assert.ok(!updatedContent.includes(expectedAliases[0]), "First alias should be removed");
+        assert.ok(updatedContent.includes("alias other='command'"), "Other aliases should remain");
+      });
+    });
+  }
+
+  // Test for each shell type using real getAliases() output
+  runRemovalTestsForEnvironment("bash", ".bashrc", [
+    "alias npm='aikido-npm'",
+    "alias npx='aikido-npx'",
+    "alias yarn='aikido-yarn'"
+  ]);
+
+  runRemovalTestsForEnvironment("zsh", ".zshrc", [
+    "alias npm='aikido-npm'",
+    "alias npx='aikido-npx'",
+    "alias yarn='aikido-yarn'"
+  ]);
+
+  runRemovalTestsForEnvironment("fish", ".fish", [
+    'alias npm "aikido-npm"',
+    'alias npx "aikido-npx"',
+    'alias yarn "aikido-yarn"'
+  ]);
+
+  runRemovalTestsForEnvironment("pwsh", ".ps1", [
+    "Set-Alias npm aikido-npm",
+    "Set-Alias npx aikido-npx",
+    "Set-Alias yarn aikido-yarn"
+  ]);
+
+  describe("removeAliasesFromFile edge cases", () => {
+    it("should handle empty file", () => {
+      const aliases = ["alias npm='aikido-npm'"];
+      const fileContent = "";
+      const filePath = `${tmpdir()}/test-${Math.random().toString(36).substring(2, 15)}.bashrc`;
+      fs.writeFileSync(filePath, fileContent, "utf-8");
+      
+      const result = removeAliasesFromFile(aliases, fileContent, filePath);
+      
+      assert.strictEqual(result.removedCount, 0, "Should remove 0 aliases from empty file");
+      assert.strictEqual(result.notFoundCount, 1, "Should report 1 alias not found");
+      
+      // Cleanup
+      fs.rmSync(filePath, { force: true });
+    });
+
+    it("should handle file with only whitespace", () => {
+      const aliases = ["alias npm='aikido-npm'"];
+      const fileContent = `${EOL}${EOL}   ${EOL}`;
+      const filePath = `${tmpdir()}/test-${Math.random().toString(36).substring(2, 15)}.bashrc`;
+      fs.writeFileSync(filePath, fileContent, "utf-8");
+      
+      const result = removeAliasesFromFile(aliases, fileContent, filePath);
+      
+      assert.strictEqual(result.removedCount, 0, "Should remove 0 aliases from whitespace-only file");
+      assert.strictEqual(result.notFoundCount, 1, "Should report 1 alias not found");
+      
+      // Cleanup
+      fs.rmSync(filePath, { force: true });
+    });
+  });
+});
+
+function createShellStartupScript(lines, fileExtension) {
+  const randomFileName = Math.random().toString(36).substring(2, 15);
+  const filePath = `${tmpdir()}/${randomFileName}${fileExtension}`;
+  fs.writeFileSync(filePath, lines.join(EOL), "utf-8");
+  return filePath;
+}
+
+function readAndDeleteFile(filePath) {
+  const fileContent = fs.readFileSync(filePath, "utf-8");
+  fs.rmSync(filePath, { force: true });
+  return fileContent.split(EOL);
+}

package/src/shell-integration/addAlias.js

@@ -1,63 +0,0 @@
-import fs from "fs";
-import path from "path";
-import { EOL } from "os";
-import { getAliases } from "./helpers.js";
-import { ui } from "../environment/userInteraction.js";
-
-export function isAddAliasCommand(args) {
-  if (args[0] === "add-aikido-aliases") {
-    return true;
-  }
-
-  if (args[0] === "add-aikido-npm-alias") {
-    // not in the documenation anymore, but still here for backwards compatibility
-    return true;
-  }
-
-  return false;
-}
-
-export function addAlias(args) {
-  if (!isAddAliasCommand(args)) {
-    return;
-  }
-
-  if (args.length < 2) {
-    ui.writeError("Please specify the file to add the alias to.");
-    return;
-  }
-
-  const filePath = path.resolve(args[1]);
-  const aliases = getAliases(filePath);
-
-  if (!fs.existsSync(filePath)) {
-    fs.writeFileSync(filePath, "", "utf-8");
-    ui.writeInformation(`File ${filePath} created.`);
-  }
-
-  const fileContent = fs.readFileSync(filePath, "utf-8");
-
-  let missingAliases = [];
-  for (const alias of aliases) {
-    if (fileContent.includes(alias)) {
-      ui.writeInformation(`Alias "${alias}" already exists in ${filePath}`);
-    } else {
-      missingAliases.push(alias);
-    }
-  }
-
-  if (missingAliases.length === 0) {
-    ui.writeInformation(`The aliases are already present in ${filePath}`);
-    return;
-  }
-
-  const aliasLines = missingAliases.join(EOL);
-  ui.writeInformation(`Adding alias "${aliasLines}" to ${filePath}...`);
-
-  // Append the alias to the file
-  fs.appendFileSync(filePath, `${EOL}${aliasLines}${EOL}`, "utf-8");
-  ui.writeInformation(`Alias added to ${filePath}`);
-  ui.writeInformation(
-    `Please restart your terminal for the changes to take effect.`
-  );
-}

package/src/shell-integration/removeAlias.js

@@ -1,61 +0,0 @@
-import fs from "fs";
-import path from "path";
-import { getAliases } from "./helpers.js";
-import { ui } from "../environment/userInteraction.js";
-import { EOL } from "os";
-
-export function isRemoveAliasCommand(args) {
-  if (args[0] === "remove-aikido-aliases") {
-    return true;
-  }
-
-  if (args[0] === "remove-aikido-npm-alias") {
-    // not in the documenation anymore, but still here for backwards compatibility
-    return true;
-  }
-
-  return false;
-}
-
-export function removeAlias(args) {
-  if (!isRemoveAliasCommand(args)) {
-    return;
-  }
-
-  if (args.length < 2) {
-    ui.writeError("Please specify the file to remove the alias from.");
-    return;
-  }
-
-  const filePath = path.resolve(args[1]);
-  const aliases = getAliases(filePath);
-
-  if (!fs.existsSync(filePath)) {
-    ui.writeError(`File ${filePath} does not exist.`);
-    return;
-  }
-
-  for (const alias of aliases) {
-    const fileContent = fs.readFileSync(filePath, "utf-8");
-    if (!fileContent.includes(alias)) {
-      ui.writeInformation(`Alias "${alias}" does not exist in ${filePath}`);
-      continue;
-    }
-
-    ui.writeInformation(`Removing alias "${alias}" from ${filePath}...`);
-
-    // Remove the alias from the file.
-    // Make sure to remove the added newlines as well, but also make sure to remove aliases if they don't have newlines
-    const updatedContent = fileContent
-      .replaceAll(`${EOL}${alias}${EOL}`, "")
-      .replaceAll(`${alias}${EOL}`, "")
-      .replaceAll(`${EOL}${alias}`, "")
-      .replaceAll(alias, "");
-
-    fs.writeFileSync(filePath, updatedContent, "utf-8");
-    ui.writeInformation(`Alias "${alias}" removed from ${filePath}`);
-  }
-  ui.writeInformation(
-    `Please restart your terminal for the changes to take effect.`
-  );
-}

package/src/shell-integration/shellIntegration.spec.js

@@ -1,172 +0,0 @@
-import { describe, it } from "node:test";
-import assert from "node:assert";
-import { EOL, tmpdir } from "node:os";
-import fs from "node:fs";
-import { addAlias } from "./addAlias.js";
-import { removeAlias } from "./removeAlias.js";
-
-describe("Add alias", () => {
-  function runTestsForEnvironment(shell, startupExtension, aliases) {
-    it(`should add alias to ${shell} file`, () => {
-      const lines = [`#!/usr/bin/env ${shell}`, "", "alias cls='clear'"];
-      const filePath = createShellStartupScript(lines, startupExtension);
-
-      addAlias(["add-aikido-aliases", filePath]);
-
-      const fileContent = readAndDeleteFile(filePath);
-      for (const alias of aliases) {
-        assert.ok(fileContent.includes(alias));
-      }
-    });
-
-    it(`should not add alias if it already exists in ${shell} file`, () => {
-      const lines = [`#!/usr/bin/env ${shell}`, "", ...aliases];
-      const filePath = createShellStartupScript(lines, startupExtension);
-
-      addAlias(["add-aikido-aliases", filePath]);
-
-      const fileContent = readAndDeleteFile(filePath);
-      assert.strictEqual(fileContent.length, lines.length);
-    });
-
-    it(`should create file and add alias if file does not exist`, () => {
-      const filePath = `${tmpdir()}/nonexistent-file${startupExtension}`;
-      if (fs.existsSync(filePath)) {
-        fs.rmSync(filePath, { force: true });
-      }
-
-      addAlias(["add-aikido-aliases", filePath]);
-
-      assert.ok(fs.existsSync(filePath));
-      const fileContent = readAndDeleteFile(filePath);
-      for (const alias of aliases) {
-        assert.ok(fileContent.includes(alias));
-      }
-    });
-
-    it(`should add the alias only once in ${shell} file`, () => {
-      const lines = [`#!/usr/bin/env ${shell}`, ""];
-      const filePath = createShellStartupScript(lines, startupExtension);
-
-      addAlias(["add-aikido-aliases", filePath]);
-      addAlias(["add-aikido-aliases", filePath]);
-
-      const fileContent = readAndDeleteFile(filePath);
-      for (const alias of aliases) {
-        assert.strictEqual(countOccurences(fileContent, alias), 1);
-      }
-    });
-
-    it(`should remove one alias from ${shell} file`, () => {
-      const alias = aliases[Math.floor(Math.random() * aliases.length)];
-      const lines = [`#!/usr/bin/env ${shell}`, "", alias];
-      const filePath = createShellStartupScript(lines, startupExtension);
-
-      removeAlias(["remove-aikido-npm-alias", filePath]);
-
-      const fileContent = readAndDeleteFile(filePath);
-      assert.ok(!fileContent.includes(alias));
-    });
-
-    it(`should remove all aliases from ${shell} file`, () => {
-      const lines = [`#!/usr/bin/env ${shell}`, "", ...aliases, ""];
-      const filePath = createShellStartupScript(lines, startupExtension);
-
-      removeAlias(["remove-aikido-npm-alias", filePath]);
-
-      const fileContent = readAndDeleteFile(filePath);
-      for (const alias of aliases) {
-        assert.ok(!fileContent.includes(alias));
-      }
-    });
-
-    it(`should not remove alias if it does not exist in ${shell} file`, () => {
-      const lines = [`#!/usr/bin/env ${shell}`, "", "alias cls='clear'"];
-      const filePath = createShellStartupScript(lines, startupExtension);
-
-      removeAlias(["remove-aikido-npm-alias", filePath]);
-
-      const fileContent = readAndDeleteFile(filePath);
-      assert.ok(fileContent.includes("alias cls='clear'"));
-    });
-
-    it(`should not remove alias if file does not exist`, () => {
-      const filePath = `${tmpdir()}/nonexistent-file${startupExtension}`;
-      if (fs.existsSync(filePath)) {
-        fs.rmSync(filePath, { force: true });
-      }
-
-      removeAlias(["remove-aikido-npm-alias", filePath]);
-
-      assert.ok(!fs.existsSync(filePath));
-    });
-
-    it(`should remove aliases from ${shell} file if duplicated`, () => {
-      const lines = [
-        `#!/usr/bin/env ${shell}`,
-        "",
-        ...aliases,
-        "cls='clear'",
-        ...aliases,
-        ...aliases,
-        "",
-      ];
-      const filePath = createShellStartupScript(lines, startupExtension);
-
-      removeAlias(["remove-aikido-npm-alias", filePath]);
-
-      const fileContent = readAndDeleteFile(filePath);
-      for (const alias of aliases) {
-        assert.ok(!fileContent.includes(alias));
-      }
-    });
-  }
-
-  runTestsForEnvironment("bash", ".bashrc", [
-    "alias npm='aikido-npm'",
-    "alias npx='aikido-npx'",
-    "alias yarn='aikido-yarn'",
-  ]);
-  runTestsForEnvironment("zsh", ".zshrc", [
-    "alias npm='aikido-npm'",
-    "alias npx='aikido-npx'",
-    "alias yarn='aikido-yarn'",
-  ]);
-  runTestsForEnvironment("fish", ".fish", [
-    'alias npm "aikido-npm"',
-    'alias npx "aikido-npx"',
-    'alias yarn "aikido-yarn"',
-  ]);
-  runTestsForEnvironment("pwsh", ".ps1", [
-    "Set-Alias npm aikido-npm",
-    "Set-Alias npx aikido-npx",
-    "Set-Alias yarn aikido-yarn",
-  ]);
-});
-
-function createShellStartupScript(lines, fileExtension) {
-  var randomFileName = Math.random().toString(36).substring(2, 15);
-  var filePath = `${tmpdir()}/${randomFileName}${fileExtension}`;
-  fs.writeFileSync(filePath, lines.join(EOL), "utf-8");
-  return filePath;
-}
-
-function readAndDeleteFile(filePath) {
-  var fileContent = fs.readFileSync(filePath, "utf-8");
-  fs.rm(filePath, { force: true }, (err) => {
-    if (err) {
-      console.error(`Error deleting file: ${err}`);
-    }
-  });
-  return fileContent.split(EOL);
-}
-
-function countOccurences(lines, alias) {
-  let count = 0;
-  for (const line of lines) {
-    if (line.includes(alias)) {
-      count++;
-    }
-  }
-  return count;
-}