@kud/soap-cli 1.0.0 → 2.0.0

package/.claude/settings.local.json

@@ -0,0 +1,14 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(node ./index.js)",
+      "Bash(node:*)",
+      "Bash(npm install:*)",
+      "Bash(npm test:*)",
+      "Bash(brew info:*)",
+      "Bash(echo \"exit: $?\")",
+      "Bash(git tag:*)",
+      "Bash(git push:*)"
+    ]
+  }
+}

package/README.md

@@ -1,53 +1,135 @@
-# Soap 🧼 - An app cleaner cli for macOS
+# soap 🧼
 
-> I was so lazy to use any GUI to clean my macOS. - @kud
+> _"I was so lazy to use any GUI to clean my macOS."_ — @kud
 
-A simple command in your shell to remove the application you want to delete and the related files as well (like preferences, logs, `.dmg`, cask formula).
+A macOS CLI that removes an app **and all its leftover files** — preferences, caches, containers, launch agents, and more.
 
-## Motivation
+Inspired by [AppCleaner](https://freemacsoft.net/appcleaner/) and [App Eraser](https://github.com/davunt/app-eraser), but open-source and terminal-native.
 
-I used to use AppCleaner and [App Eraser](https://github.com/davunt/app-eraser) but the first one is not open source (and could have trackers) and the second one is not a CLI but a GUI. Here comes _soap_.
+---
 
 ## Install
 
-```shell
+```sh
 npm install -g @kud/soap-cli
 ```
 
+Or via Homebrew:
+
+```sh
+brew install kud/tap/soap-cli
+```
+
+---
+
 ## Usage
 
-You've got two ways to uninstall an application, via its path or via its cask name.
+```
+soap <cask-name>        Clean an app installed via Homebrew cask
+soap <path-to-app>      Clean a manually installed app
+soap --help             Show this help
+```
 
-#### Application path
+**Examples:**
 
-```shell
-soap <app-path>
-# ex: soap '/Applications/Android Studio.app'
+```sh
+soap spotify
+soap android-studio
+soap '/Applications/Android Studio.app'
 ```
 
-_warning: it won't remove the cask formula even if you've installed the app via homebrew._
+---
+
+## What it does
+
+### Cask mode — `soap spotify`
+
+1. Resolves the `.app` name from `brew info`
+2. Scans ~40 macOS directories for files matching the app name or bundle identifier
+3. Fetches the cask's [zap stanza](https://docs.brew.sh/Cask-Cookbook#stanza-zap) — the maintainer-curated list of known leftover files
+4. Presents a checkbox list of everything found (all pre-selected)
+5. Moves selected files to **Trash** (recoverable from `~/.Trash`)
+6. Optionally runs `brew uninstall --zap` to unregister the cask from Homebrew
+
+### Path mode — `soap '/Applications/Spotify.app'`
+
+Same as above, but skips the Homebrew step. Use this for apps installed manually from a DMG.
 
-#### Cask name
+---
+
+## Example output
 
-```shell
-soap <cask-name>
-# ex: soap android-studio
 ```
+Welcome to soap 🧼, the app cleaner.
+
+⠋ Fetching cask info…
+⠋ Scanning for files…
+
+ℹ Cleaning: Spotify
+ℹ Mode: cask (spotify)
+
+? Found 11 files. Select what to move to Trash:
+ ◉ /Users/kud/Library/Application Support/Spotify
+ ◉ /Users/kud/Library/Caches/com.spotify.client
+ ◉ /Users/kud/Library/Preferences/com.spotify.client.plist
+ ◉ /Users/kud/Library/Saved Application State/com.spotify.client.savedState
+ ◉ /Users/kud/Library/Logs/Spotify
+ ◉ ...
+
+? Run `brew uninstall --zap spotify`? Yes
 
-It will delete for instance this kind of files:
+✔ Moved 11 file(s) to Trash.
 
+◼ Running Homebrew uninstall…
+✔ Done.
 ```
-/Applications/Android Studio.app
-/Users/kud/Downloads/android-studio-ide-182.5314842-mac.dmg
-/Users/kud/Library/Preferences/com.google.android.studio.plist
-/Users/kud/Library/Saved Application State/com.google.android.studio.savedState
-/Users/kud/Library/Application Support/google/AndroidStudio4.2
-/Users/kud/Library/Caches/google/AndroidStudio4.2
-/Users/kud/Library/Logs/google/AndroidStudio4.2
+
+---
+
+## Locations scanned
+
+`soap` scans these directories, plus `<vendor>/` subdirectories derived from the bundle ID:
+
+| Location                            | What's typically there          |
+| ----------------------------------- | ------------------------------- |
+| `/Applications`                     | The app bundle                  |
+| `~/Library/Application Support`     | App data                        |
+| `~/Library/Caches`                  | Cached data                     |
+| `~/Library/Containers`              | Sandboxed app data              |
+| `~/Library/Preferences`             | `.plist` config files           |
+| `~/Library/Logs`                    | App logs                        |
+| `~/Library/LaunchAgents`            | Per-user background services    |
+| `/Library/LaunchDaemons`            | System-wide background services |
+| `~/Library/HTTPStorages`            | HTTP caches                     |
+| `~/Library/Group Containers`        | Shared app-group data           |
+| `~/Library/Saved Application State` | Window state (`.savedState`)    |
+| `~/Library/WebKit`                  | WebKit storage                  |
+| `/private/var/db/receipts`          | Package receipts                |
+| `/Library/Logs/DiagnosticReports`   | Crash reports                   |
+| `/Library/Audio/Plug-Ins/HAL`       | Audio drivers                   |
+| `~/Downloads`                       | Leftover `.dmg` files           |
+
+---
+
+## Debug mode
+
+```sh
+SOAP_DEBUG=1 soap spotify
 ```
 
-No worries, soap will move them into your Trash, so if something wrong has happened, you can check there your files.
+Enables verbose shell output — shows every subprocess command that runs.
+
+---
+
+## Safety
+
+- Files are **moved to Trash**, not permanently deleted.
+- You get a full checkbox list before anything is removed — deselect anything you want to keep.
+- The Homebrew uninstall is a separate confirmation step.
+- The force-uninstall fallback (for already-removed apps still registered in Homebrew) defaults to **No**.
+
+---
 
 ## Credits
 
-Inspired from [App Eraser](https://github.com/davunt/app-eraser)
+Inspired by [App Eraser](https://github.com/davunt/app-eraser) and [AppCleaner](https://freemacsoft.net/appcleaner/).

package/index.js

@@ -3,62 +3,97 @@ import inquirer from "inquirer"
 import signale from "signale"
 import trash from "trash"
 import chalk from "chalk"
-import { $ } from "zx/core"
+import { $, spinner } from "zx"
 
 import {
   appNameFromPath,
-  appNameFromCaskName,
+  getCaskInfo,
   getBundleIdentifier,
   findAppFiles,
 } from "./lib/index.js"
 
-$.verbose = false // true for debugging
+$.verbose = process.env.SOAP_DEBUG === "1"
 
 const [param] = process.argv.slice(2)
 
-if (!param) {
-  console.error(`No parameter specified.`)
-
-  process.exit(0)
+if (!param || param === "--help" || param === "-h") {
+  if (param === "--help" || param === "-h") {
+    console.log(`
+  ${chalk.bold("soap")} 🧼  ${chalk.italic("the app cleaner")}
+
+  ${chalk.bold("Usage:")}
+    soap ${chalk.cyan("<cask-name>")} | ${chalk.cyan("<path-to-app>")}
+
+  ${chalk.bold("Examples:")}
+    soap ${chalk.green("spotify")}               Uninstall Spotify (cask) + all its leftover files
+    soap ${chalk.green("android-studio")}        Uninstall Android Studio (cask)
+    soap ${chalk.green("/Applications/Slack.app")}
+                               Uninstall Slack by path (no brew step)
+
+  ${chalk.bold("What it removes:")}
+    ${chalk.dim("·")} The .app bundle ${chalk.dim("(via brew uninstall --zap or manual selection)")}
+    ${chalk.dim("·")} Preferences  ${chalk.dim("~/Library/Preferences/com.<vendor>.<app>.plist")}
+    ${chalk.dim("·")} Caches       ${chalk.dim("~/Library/Caches/com.<vendor>.<app>")}
+    ${chalk.dim("·")} App support  ${chalk.dim("~/Library/Application Support/<App>")}
+    ${chalk.dim("·")} Containers   ${chalk.dim("~/Library/Containers/com.<vendor>.<app>")}
+    ${chalk.dim("·")} Launch agents, logs, crash reports, DMG files, and more
+
+  ${chalk.bold("Environment:")}
+    ${chalk.yellow("SOAP_DEBUG=1")}               Enable verbose shell output
+    `)
+    process.exit(0)
+  }
+  console.error(
+    chalk.red("No parameter specified. Run `soap --help` for usage."),
+  )
+  process.exit(1)
 }
 
 const isCask = !param.includes(".app")
 
 console.log(
-  `Welcome to ${chalk.bold("soap")} 🧼, ${chalk.italic("the app cleaner")}.\n`,
+  `\nWelcome to ${chalk.bold("soap")} 🧼, ${chalk.italic("the app cleaner")}.\n`,
 )
 
 try {
-  const appName = isCask
-    ? await appNameFromCaskName(param)
-    : appNameFromPath(param)
+  const { appName, zapFiles } = isCask
+    ? await spinner(chalk.dim("Fetching cask info…"), () => getCaskInfo(param))
+    : { appName: appNameFromPath(param), zapFiles: [] }
+
+  if (!appName) {
+    signale.error(`Could not determine app name for "${param}".`)
+    process.exit(1)
+  }
 
   const bundleId = await getBundleIdentifier(appName)
-  const _appFiles = await findAppFiles(appName, bundleId)
-  const appFiles = isCask ? _appFiles.slice(1) : _appFiles
-  const isAppFilesEmpty = appFiles.length === 0
 
-  signale.info(
-    `You want me to clean this application: ${chalk.bold(appName)} 📦.`,
+  const scannedFiles = await spinner(chalk.dim("Scanning for files…"), () =>
+    findAppFiles(appName, bundleId),
   )
 
+  const appFiles = [
+    ...new Set([
+      ...(isCask ? scannedFiles.slice(1) : scannedFiles),
+      ...zapFiles,
+    ]),
+  ]
+  const isAppFilesEmpty = appFiles.length === 0
+
+  signale.info(`Cleaning: ${chalk.bold(appName)}`)
   signale.info(
     isCask
-      ? `I also assume ${chalk.bold("you gave me a cask name")}.`
-      : `I also assume you gave me an application path. ${chalk.bold(
-          "No homebrew cask will be deleted then",
-        )}.`,
+      ? `Mode: ${chalk.bold("cask")} (${param})`
+      : `Mode: ${chalk.bold("path")} — no Homebrew uninstall will run`,
   )
 
   console.log("")
 
-  const { deletedFilesWish } = await inquirer.prompt([
+  const { deletedFilesWish, deletedCaskWish } = await inquirer.prompt([
     {
       type: "checkbox",
       name: "deletedFilesWish",
       when: !isAppFilesEmpty,
-      message:
-        "This is what I've found about it. Please select the files you want to delete.",
+      message: `Found ${chalk.bold(appFiles.length)} files. Select what to move to Trash:`,
       choices: appFiles.map((appFile) => ({
         name: appFile,
         value: appFile,
@@ -69,52 +104,56 @@ try {
       type: "confirm",
       when: isCask,
       name: "deletedCaskWish",
-      message: `Do you want to uninstall "${param}" via homebrew?`,
+      message: `Run ${chalk.bold(`brew uninstall --zap ${param}`)}?`,
+      default: true,
     },
   ])
 
-  if (!isAppFilesEmpty) {
+  if (!isAppFilesEmpty && deletedFilesWish?.length > 0) {
     await trash(deletedFilesWish, { force: true })
 
     console.log("")
-
-    console.log("Files deleted:")
-    deletedFilesWish.forEach((deletedPath) => console.log(`· ${deletedPath}`))
+    signale.success(
+      `Moved ${chalk.bold(deletedFilesWish.length)} file(s) to Trash:`,
+    )
+    deletedFilesWish.forEach((p) =>
+      console.log(`  ${chalk.dim("·")} ${chalk.dim(p)}`),
+    )
+  } else if (!isAppFilesEmpty) {
+    signale.info("No files selected — nothing moved to Trash.")
   }
 
-  if (isCask) {
+  if (isCask && deletedCaskWish) {
     console.log("")
-
-    signale.pending(`Starting cask uninstallation.`)
-
-    await $`brew uninstall ${param}`
+    signale.pending("Running Homebrew uninstall…")
+    await $`brew uninstall --zap ${param}`
   }
 
   console.log("")
-
-  signale.success("Operation successful.")
+  signale.success("Done.")
 } catch (error) {
-  signale.error(`Something wrong appeared. Check the log below.\n`)
-  console.error(error)
-  console.error("")
+  console.log("")
+  signale.error(error.message ?? "An unexpected error occurred.")
+
+  if (process.env.SOAP_DEBUG === "1") {
+    console.error(error)
+  }
 
   if (isCask) {
-    inquirer
-      .prompt([
-        {
-          type: "confirm",
-          name: "forceUninstall",
-          message:
-            "An error occurred. It could happen when the app file no longer exists, but the cask is still present in Homebrew.\nWould you like to forcefully uninstall the cask by running `brew uninstall`?",
-        },
-      ])
-      .then(async (answers) => {
-        if (answers.forceUninstall) {
-          console.error("")
-          signale.pending(`Forcefully uninstalling cask.`)
-          await $`brew uninstall --force ${param}`
-          signale.success("Force uninstallation successful.")
-        }
-      })
+    const { forceUninstall } = await inquirer.prompt([
+      {
+        type: "confirm",
+        name: "forceUninstall",
+        message: `The app may already be removed but the cask is still registered.\nForce-run ${chalk.bold(`brew uninstall --zap --force ${param}`)}?`,
+        default: false,
+      },
+    ])
+
+    if (forceUninstall) {
+      console.log("")
+      signale.pending("Force-uninstalling cask…")
+      await $`brew uninstall --zap --force ${param}`
+      signale.success("Force uninstall complete.")
+    }
   }
 }

package/lib/__tests__/app-name.test.js

@@ -0,0 +1,63 @@
+import { describe, it, expect } from "vitest"
+import {
+  appNameFromPath,
+  createNameVariations,
+  normalizeString,
+} from "../index.js"
+
+describe("appNameFromPath", () => {
+  it("extracts name from full path", () => {
+    expect(appNameFromPath("/Applications/Spotify.app")).toBe("Spotify")
+  })
+
+  it("extracts name from filename only", () => {
+    expect(appNameFromPath("Spotify.app")).toBe("Spotify")
+  })
+
+  it("handles app names with spaces", () => {
+    expect(appNameFromPath("/Applications/Affinity Designer 2.app")).toBe(
+      "Affinity Designer 2",
+    )
+  })
+
+  it("handles nested path", () => {
+    expect(appNameFromPath("/Users/kud/Downloads/MyApp.app")).toBe("MyApp")
+  })
+})
+
+describe("normalizeString", () => {
+  it("lowercases the string", () => {
+    expect(normalizeString("Spotify")).toBe("spotify")
+  })
+
+  it("replaces spaces with empty string by default", () => {
+    expect(normalizeString("Affinity Designer")).toBe("affinitydesigner")
+  })
+
+  it("replaces spaces with custom spacer", () => {
+    expect(normalizeString("Affinity Designer", "-")).toBe("affinity-designer")
+  })
+})
+
+describe("createNameVariations", () => {
+  it("returns all expected variation keys for a simple name", () => {
+    const variations = createNameVariations("Spotify", "com.spotify.client")
+    expect(variations).toContain("spotify")
+    expect(variations).toContain("com.spotify.client")
+  })
+
+  it("produces dash and underscore variants for multi-word names", () => {
+    const variations = createNameVariations(
+      "Affinity Designer",
+      "com.affinity.designer2",
+    )
+    expect(variations).toContain("affinity-designer")
+    expect(variations).toContain("affinity_designer")
+    expect(variations).toContain("affinity.designer")
+  })
+
+  it("returns 6 variations", () => {
+    const variations = createNameVariations("Spotify", "com.spotify.client")
+    expect(variations).toHaveLength(6)
+  })
+})

package/lib/__tests__/file-regex.test.js

@@ -0,0 +1,46 @@
+import { describe, it, expect } from "vitest"
+import { fileRegex } from "../file-regex.js"
+
+const strip = (str) => {
+  let result = str
+  fileRegex.forEach((r) => (result = result.replace(r, "")))
+  return result
+}
+
+describe("fileRegex", () => {
+  it("strips UUID patterns", () => {
+    expect(
+      strip("app-550e8400-e29b-41d4-a716-446655440000.plist"),
+    ).not.toContain("550e8400-e29b-41d4-a716-446655440000")
+  })
+
+  it("strips date patterns", () => {
+    expect(strip("crash-2024-03-15-142500.log")).not.toContain(
+      "2024-03-15-142500",
+    )
+  })
+
+  it("strips .app extension", () => {
+    expect(strip("Spotify.app")).toBe("Spotify")
+  })
+
+  it("strips .plist extension", () => {
+    expect(strip("com.spotify.client.plist")).toBe("com.spotify.client")
+  })
+
+  it("strips .dmg extension", () => {
+    expect(strip("Spotify.dmg")).toBe("Spotify")
+  })
+
+  it("strips .savedState extension", () => {
+    expect(strip("Spotify.savedState")).toBe("Spotify")
+  })
+
+  it("strips diag resource pattern", () => {
+    expect(strip("Spotify_resource.diag")).not.toContain("_resource.diag")
+  })
+
+  it("leaves unrelated strings intact", () => {
+    expect(strip("spotify")).toBe("spotify")
+  })
+})

package/lib/__tests__/pattern-matching.test.js

@@ -0,0 +1,39 @@
+import { describe, it, expect, vi, beforeEach } from "vitest"
+import { isPatternInFile } from "../index.js"
+
+// isPatternInFile relies on the module-level compNameGlob for stripString.
+// We test it with patterns and filenames where the computer name is irrelevant.
+
+describe("isPatternInFile", () => {
+  it("matches when pattern is prominent in the filename", () => {
+    const result = isPatternInFile(["spotify"], "spotify.plist")
+    expect(result).toBeTruthy()
+  })
+
+  it("matches bundle-id style filename", () => {
+    const result = isPatternInFile(
+      ["com.spotify.client"],
+      "com.spotify.client.plist",
+    )
+    expect(result).toBeTruthy()
+  })
+
+  it("does not match when pattern is a minor substring of a long unrelated filename", () => {
+    // 'it' is a substring of 'microsoft' but far too short relative to the full filename
+    const result = isPatternInFile(
+      ["it"],
+      "com.microsoft.office.reminders.plist",
+    )
+    expect(result).toBeFalsy()
+  })
+
+  it("returns falsy when no patterns match", () => {
+    const result = isPatternInFile(["spotify"], "com.apple.finder.plist")
+    expect(result).toBeFalsy()
+  })
+
+  it("returns falsy for empty patterns array", () => {
+    const result = isPatternInFile([], "spotify.plist")
+    expect(result).toBeFalsy()
+  })
+})

package/lib/index.js

@@ -3,12 +3,13 @@ $.verbose = false
 
 import { execSync } from "child_process"
 import fs from "fs/promises"
+import { homedir } from "os"
 import { pathLocations, commonSuffix } from "./path-locations.js"
 import { fileRegex } from "./file-regex.js"
 
 const scoreThreshold = 0.4
 
-let compNameGlob
+let compNameGlob = ""
 
 function stripString(file) {
   let transformedString = file
@@ -26,7 +27,7 @@ function stripString(file) {
   return transformedString
 }
 
-const normalizeString = (str, spacer = "") =>
+export const normalizeString = (str, spacer = "") =>
   str.toLowerCase().replace(/ /g, spacer)
 
 async function getFilePatternArray(appName, bundleId) {
@@ -56,13 +57,14 @@ async function getFilePatternArray(appName, bundleId) {
     ),
   )
 
-  patternArray = [...patternArray, [...appWithSuffix]]
+  patternArray = [...patternArray, ...appWithSuffix]
 
   return patternArray
 }
 
-function isPatternInFile(patterns, fileToCheck) {
+export function isPatternInFile(patterns, fileToCheck) {
   return patterns.find((filePatten) => {
+    if (typeof filePatten !== "string") return false
     if (fileToCheck.includes(filePatten)) {
       const strippedFile = stripString(fileToCheck)
 
@@ -85,14 +87,13 @@ function isPatternInFile(patterns, fileToCheck) {
   })
 }
 
-function createNameVariations(appName, bundleId) {
-  const appNameNorm = appName.toLowerCase().replace(" ", "")
-  const appNameWithoutDot = appNameNorm.toLowerCase().replace(".", "")
-  const appNameUnderscore = appName.toLowerCase().replace(" ", "_")
-  const appNameDash = appName.toLowerCase().replace(" ", "-")
-  const appNameDot = appName.toLowerCase().replace(" ", ".")
-
-  const bundleIdNorm = bundleId.toLowerCase().replace(" ", "")
+export function createNameVariations(appName, bundleId) {
+  const appNameNorm = appName.toLowerCase().replace(/ /g, "")
+  const appNameWithoutDot = appNameNorm.replace(/\./g, "")
+  const appNameUnderscore = appName.toLowerCase().replace(/ /g, "_")
+  const appNameDash = appName.toLowerCase().replace(/ /g, "-")
+  const appNameDot = appName.toLowerCase().replace(/ /g, ".")
+  const bundleIdNorm = bundleId.toLowerCase().replace(/ /g, "")
 
   return [
     appNameNorm,
@@ -104,54 +105,98 @@ function createNameVariations(appName, bundleId) {
   ]
 }
 
-function appNameFromPath(appPath) {
+export function appNameFromPath(appPath) {
   const pathArr = appPath.split("/")
   const appNameWithExt = pathArr[pathArr.length - 1]
-  // remove .app extension
   return appNameWithExt.replace(".app", "")
 }
 
-export const appNameFromCaskName = async (caskName) => {
-  try {
-    const { stdout: info } = await $`brew info ${caskName} --json=v2`
-    const caskData = JSON.parse(info).casks?.[0]
+async function fetchCaskData(caskName) {
+  const { stdout: info } = await $`brew info ${caskName} --json=v2`
+  const caskData = JSON.parse(info).casks?.[0]
+  if (!caskData) throw new Error(`Cask "${caskName}" not found.`)
+  return caskData
+}
 
-    if (!caskData) {
-      throw new Error("Cask data not available.")
-    }
+async function resolveZapPaths(caskData) {
+  const zapPaths = caskData.artifacts
+    .filter((a) => a.zap)
+    .flatMap((a) => a.zap)
+    .filter((entry) => entry.trash)
+    .flatMap((entry) => entry.trash)
+    .map((p) => p.replace(/^~/, homedir()))
+
+  const resolved = await Promise.all(
+    zapPaths.map(async (p) => {
+      if (p.includes("*")) {
+        const matches = []
+        for await (const f of fs.glob(p)) matches.push(f)
+        return matches
+      }
+      try {
+        await fs.access(p)
+        return [p]
+      } catch {
+        return []
+      }
+    }),
+  )
 
+  return resolved.flat()
+}
+
+export const getCaskInfo = async (caskName) => {
+  try {
+    const caskData = await fetchCaskData(caskName)
+
+    let appName = null
     for (const artifact of caskData.artifacts) {
       if (artifact.app) {
-        return artifact.app[0]
+        appName = artifact.app[0]
+        break
       }
     }
 
-    return null
+    const zapFiles = await resolveZapPaths(caskData)
+
+    return { appName, zapFiles }
   } catch (error) {
-    console.error(`Error fetching app name for cask ${caskName}:`, error)
-    return null
+    throw new Error(
+      `Failed to get cask info for "${caskName}": ${error.message}`,
+    )
   }
 }
 
-async function getComputerName() {
-  const compName = await execSync("scutil --get ComputerName").toString()
+export const appNameFromCaskName = async (caskName) => {
+  const { appName } = await getCaskInfo(caskName)
+  return appName
+}
 
-  // remove empty space at end of string
-  return compName.substring(0, compName.length - 1)
+export const getZapFiles = async (caskName) => {
+  const { zapFiles } = await getCaskInfo(caskName)
+  return zapFiles
 }
 
-async function getBundleIdentifier(appName) {
-  const bundleId = await execSync(
-    `osascript -e 'id of app "${appName}"'`,
-  ).toString()
+function getComputerName() {
+  return execSync("scutil --get ComputerName").toString().trimEnd()
+}
 
-  // remove empty space at end of string
-  return bundleId.substring(0, bundleId.length - 1)
+export async function getBundleIdentifier(appName) {
+  try {
+    const bundleId = execSync(
+      `osascript -e 'id of app "${appName}"'`,
+    ).toString()
+    return bundleId.trimEnd()
+  } catch {
+    throw new Error(
+      `Could not find bundle identifier for "${appName}". Is the app installed?`,
+    )
+  }
 }
 
-async function findAppFiles(appName, bundleId) {
+export async function findAppFiles(appName, bundleId) {
   try {
-    compNameGlob = await getComputerName()
+    compNameGlob = getComputerName()
     const bundleIdComponents = bundleId.split(".")
 
     const companyDirs = pathLocations.map(
@@ -170,7 +215,7 @@ async function findAppFiles(appName, bundleId) {
     directoryFiles.forEach((dir, index) => {
       if (dir.status === "fulfilled") {
         dir.value.forEach((dirFile) => {
-          const dirFileNorm = dirFile.toLowerCase().replace(" ", "")
+          const dirFileNorm = dirFile.toLowerCase().replace(/ /g, "")
           if (isPatternInFile(patternArray, dirFileNorm)) {
             filesToRemove.add(
               `${pathsToSearch[parseInt(index, 10)]}/${dirFile}`,
@@ -180,12 +225,9 @@ async function findAppFiles(appName, bundleId) {
       }
     })
 
-    // convert set to array
     return [...filesToRemove]
   } catch (err) {
     console.error(err)
     throw err
   }
 }
-
-export { appNameFromPath, getBundleIdentifier, findAppFiles }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kud/soap-cli",
-  "version": "1.0.0",
+  "version": "2.0.0",
   "description": "An app cleaner cli for macOS",
   "main": "index.js",
   "bin": {
@@ -11,7 +11,7 @@
   },
   "scripts": {
     "dev": "node ./index.js",
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "test": "vitest run"
   },
   "repository": {
     "type": "git",
@@ -26,12 +26,15 @@
   "homepage": "https://github.com/kud/soap-cli#readme",
   "type": "module",
   "dependencies": {
-    "@kud/soap-cli": "1.0.0-5",
-    "chalk": "5.3.0",
-    "del": "7.1.0",
-    "inquirer": "9.2.23",
+    "@kud/soap-cli": "1.0.0",
+    "chalk": "5.6.2",
+    "del": "8.0.1",
+    "inquirer": "13.3.2",
     "signale": "1.4.0",
-    "trash": "8.1.1",
-    "zx": "8.1.3"
+    "trash": "10.1.1",
+    "zx": "8.8.5"
+  },
+  "devDependencies": {
+    "vitest": "4.1.2"
   }
 }