@aikidosec/safe-chain 1.0.0 → 1.0.11

package/src/shell-integration/removeShell.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 removeShell() {
+  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/removeShell.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 "./removeShell.js";
+
+describe("removeShell", () => {
+  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/setupShell.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 setupShell() {
+  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,
+  };
+}