kill-me-now 0.0.1 → 0.0.3

package/README.md

@@ -1,6 +1,6 @@
 # Kill Me Now
 
-Find and kill application processes
+Find and kill application processes by _file path_
 
 ```bash
 npm i -P kill-me-now
@@ -8,6 +8,42 @@ npm i -P kill-me-now
 
 ## Parameters
 
-- A `filePath` is to identify application processes is _required_
-- A `process` ID to *exclude* is _optional_
-- A `command` is _optional_
+- A `name` (which is the _file path_) to identify application processes is _required_
+- A `pid` to *exclude* is _optional_
+- And a `cmd` is _optional_
+
+## Example
+
+Import `killMeNow`
+
+```javascript
+import killMeNow from 'kill-me-now'
+```
+
+Kill all processes on _this path_
+
+```javascript
+/**
+ *  Get the current working directory
+ */
+const cwd = process.cwd()
+
+await killMeNow(cwd)
+```
+
+(This will include the current process represented by `process`)
+
+Kill any processes on _this path_ except for _the current process_
+
+```javascript
+/**
+ *  Get the current working directory
+ */
+const cwd = process.cwd()
+/**
+ *  Get the current process ID
+ */
+const pid = process.pid
+
+await killMeNow(cwd, pid)
+```

package/index.mjs

@@ -21,70 +21,38 @@ const error = debug('kill-me-now:error')
 log('`kill-me-now` is awake')
 
 /**
- *  @param {string} filePath
+ *  @param {string} alpha
  *  @returns {(openFile: Record<string, string>) => boolean}
  */
-function getHasOpenFiles (filePath) {
-  info('getHasOpenFiles')
+function getHasName (alpha) {
+  info('getHasName')
 
   /**
    *  @param {Record<string, string>} openFile
    *  @returns {boolean}
    */
-  function hasFilePath ({ 'FILE PATH': FILEPATH }) {
-    info('hasFilePath')
+  return function hasName ({ name: omega }) {
+    info('hasName')
 
     return (
-      FILEPATH.startsWith(filePath)
-    )
-  }
-
-  /**
-   *  @param {Array<Record<string, string>>} openFiles
-   *  @returns {boolean}
-   */
-  return function hasOpenFiles (openFiles) {
-    info('hasOpenFiles')
-
-    return (
-      openFiles.some(hasFilePath)
+      omega.startsWith(alpha)
     )
   }
 }
 
 /**
- *  @param {string} filePath
+ *  @param {number} alpha
  *  @returns {(openFile: Record<string, string>) => boolean}
  */
-function getFilterForFilePath (filePath) {
-  info('getFilterForFilePath')
+function getHasPid (alpha) {
+  info('getHasPid')
 
-  /**
-   *  @param {Record<string, string>} openFile
-   *  @returns {boolean}
-   */
-  return function filterForFilePath ({ 'FILE PATH': FILEPATH }) {
-    info('filterForFilePath')
-
-    return (
-      FILEPATH.startsWith(filePath)
-    )
-  }
-}
-
-/**
- *  @param {number} process
- *  @returns {(openFile: Record<string, string>) => boolean}
- */
-function getFilterForProcess (process) {
-  info('getFilterForProcess')
-
-  if (process) {
-    return function filterForProcess ({ PROCESS }) {
-      info('filterForProcess')
+  if (alpha) {
+    return function hasPid ({ pid: omega }) {
+      info('hasPid')
 
       return (
-        PROCESS !== process
+        omega !== alpha
       )
     }
   }
@@ -95,18 +63,18 @@ function getFilterForProcess (process) {
 }
 
 /**
- *  @param {string} command
+ *  @param {string} alpha
  *  @returns {(openFile: Record<string, string>) => boolean}
  */
-function getFilterForCommand (command) {
-  info('getFilterForCommand')
+function getHasCmd (alpha) {
+  info('getHasCmd')
 
-  if (command) {
-    return function filterForCommand ({ COMMAND }) {
-      info('filterForCommand')
+  if (alpha) {
+    return function hasCmd ({ cmd: omega }) {
+      info('hasCmd')
 
       return (
-        COMMAND === command
+        omega === alpha
       )
     }
   }
@@ -120,15 +88,15 @@ function getFilterForCommand (command) {
  *  @param {Record<string, string>} openFile
  *  @returns {void}
  */
-function forEach ({ PROCESS }) {
-  info('forEach')
+function killProcess ({ pid }) {
+  info('killProcess')
 
   try {
-    log(`Killing process ${PROCESS} ...`)
+    log(`Killing process ${pid} ...`)
 
-    process.kill(PROCESS)
+    process.kill(pid)
 
-    log(`Killing process ${PROCESS} succeeded.`)
+    log(`Killing process ${pid} succeeded.`)
   } catch (e) {
     const {
       code
@@ -136,24 +104,25 @@ function forEach ({ PROCESS }) {
 
     if (code !== 'ESRCH') error(e)
 
-    error(`Killing process ${PROCESS} failed.`)
+    error(`Killing process ${pid} failed.`)
   }
 }
 
 /**
- *  @param {string} filePath
- *  @param {number} [process] Process ID
- *  @param {string} [command] Command
+ *  @param {string} name
+ *  @param {number} [pid] Process ID
+ *  @param {string} [cmd] Command
  *  @returns {Promise<void>}
  */
-export default async function killMeNow (filePath, process, command) {
+export default async function killMeNow (name, pid, cmd) {
   const lsof = await getLsofArray()
-
-  if (lsof.some(getHasOpenFiles(filePath))) {
-    lsof.flat()
-      .filter(getFilterForFilePath(filePath))
-      .filter(getFilterForProcess(process))
-      .filter(getFilterForCommand(command))
-      .forEach(forEach)
+  const hasName = getHasName(name)
+
+  if (lsof.some(hasName)) {
+    lsof
+      .filter(hasName)
+      .filter(getHasPid(pid))
+      .filter(getHasCmd(cmd))
+      .forEach(killProcess)
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kill-me-now",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "main": "./index.mjs",
   "type": "module",
   "author": {
@@ -11,13 +11,16 @@
   "license": "ISC",
   "repository": {
     "type": "git",
-    "url": "git://github.com/sequencemedia/kill-me-now.git"
+    "url": "git+https://github.com/sequencemedia/kill-me-now.git"
   },
   "scripts": {
     "lint": "eslint .",
     "lint:fix": "npm run lint -- --fix",
     "prepare": "husky"
   },
+  "dependencies": {
+    "@sequencemedia/lsof": "^0.0.4"
+  },
   "devDependencies": {
     "@sequencemedia/eslint-config-standard": "^0.2.52",
     "@sequencemedia/eslint-config-typescript": "^0.1.82",
@@ -25,8 +28,5 @@
     "eslint": "^9.26.0",
     "globals": "^16.0.0",
     "husky": "^9.1.7"
-  },
-  "dependencies": {
-    "@sequencemedia/lsof": "^0.0.2"
   }
 }