@webpod/ps 0.0.0-beta.0

package/LICENSE.txt

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2024 Webpod
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

package/README.md

@@ -0,0 +1,155 @@
+# @webpod/ps
+
+> A Node.js module for looking up running processes. Originated from [neekey/ps](https://github.com/neekey/ps), [UmbraEngineering/ps](https://github.com/UmbraEngineering/ps) and completely reforged.
+
+## Differences
+* [x] Rewritten in TypeScript
+* [x] CJS and ESM package entry points
+* [x] `table-parser` replaced with `@webpod/ingrid` to handle some issues: [neekey/ps#76](https://github.com/neekey/ps/issues/76), [neekey/ps#62](https://github.com/neekey/ps/issues/62), [neekey/table-parser#11](https://github.com/neekey/table-parser/issues/11), [neekey/table-parser#18](https://github.com/neekey/table-parser/issues/18)
+* [x] Provides promisified responses
+* [ ] Brings sync API
+* [x] Builds a process tree
+
+## Install
+```bash
+$ npm install @webpod/ps
+```
+
+## Internals
+This module invokes different tools to get process list:
+
+* `ps` for unix/mac: `ps -lx`
+* [`wmic` for win runtimes](https://learn.microsoft.com/en-us/windows/win32/wmisdk/wmic): `wmic process get ProcessId,CommandLine`.
+
+## Usage
+
+### lookup()
+Searches for the process by the specified `pid`.
+```ts
+import {lookup} from '@webpod/ps'
+
+// Both callback and promise styles are supported
+const list = await lookup({pid: 12345})
+
+// or
+lookup({pid: 12345}, (err, list) => {
+  if (err) {
+    throw new Error(err)
+  }
+
+  const [found] = list
+  if (found) {
+    console.log('PID: %s, COMMAND: %s, ARGUMENTS: %s', found.pid, found.command, found.arguments)
+  } else {
+    console.log('No such process found!')
+  }
+})
+```
+
+Define a query opts to filter the results by `command` and/or `arguments` predicates:
+```ts
+const list = await lookup({
+  command: 'node', // it will be used to build a regex 
+  arguments: '--debug',
+})
+
+list.forEach(entry => {
+  console.log('PID: %s, COMMAND: %s, ARGUMENTS: %s', entry.pid, entry.command, entry.arguments);
+})
+```
+
+Unix users can override the default `ps` arguments:
+```ts
+lookup({
+  command: 'node',
+  psargs: 'ux'
+}, (err, resultList) => {
+// ...
+})
+```
+
+Specify the `ppid` option to filter the results by the parent process id (make sure that your custom `psargs` provides this output: `-l` or `-j` for instance)
+```ts
+lookup({
+  command: 'mongod',
+  psargs: '-l',
+  ppid: 82292
+}, (err, resultList) => {
+ // ...
+})
+```
+
+### tree()
+Returns a child processes list by the specified parent `pid`. Some kind of shortcut for `lookup({ppid: pid})`.
+```ts
+import { tree } from '@webpod/ps'
+
+const children = await tree(123) 
+/**
+[
+  {pid: 124, ppid: 123},
+  {pid: 125, ppid: 123}
+] 
+*/
+```
+
+To obtain all nested children, set `recursive` option to `true`:
+```ts
+const children = await tree({pid: 123, recursive: true}) 
+/**
+[
+  {pid: 124, ppid: 123},
+  {pid: 125, ppid: 123},
+
+  {pid: 126, ppid: 124},
+  {pid: 127, ppid: 124},
+  {pid: 128, ppid: 124},
+  
+  {pid: 129, ppid: 125},
+  {pid: 130, ppid: 125},
+] 
+*/
+```
+
+### kill()
+Eliminates the process by its `pid`.
+
+```ts
+import { kill } from '@webpod/ps'
+
+kill('12345', (err, pid) => {
+  if (err) {
+    throw new Error(err)
+  } else {
+    console.log('Process %s has been killed!', pid)
+  }
+})
+```
+
+Method `kill` also supports a `signal` option to be passed. It's only a wrapper of `process.kill()` with checking of that killing is finished after the method is called.
+
+```ts
+import { kill } from '@webpod/ps'
+
+// Pass signal SIGKILL for killing the process without allowing it to clean up
+kill('12345', 'SIGKILL', (err, pid) => {
+  if (err) {
+    throw new Error(err)
+  } else {
+    console.log('Process %s has been killed without a clean-up!', pid)
+  }
+})
+```
+
+You can also use object notation to specify more opts:
+```ts
+kill( '12345', {
+  signal: 'SIGKILL',
+  timeout: 10,  // will set up a ten seconds timeout if the killing is not successful
+}, () => {})
+```
+
+Notice that the nodejs build-in `process.kill()` does not accept number as a signal, you will have to use string format.
+
+## License
+[MIT](./LICENSE)

package/package.json

@@ -0,0 +1,66 @@
+{
+  "name": "@webpod/ps",
+  "version": "0.0.0-beta.0",
+  "description": "A process lookup utility",
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "main": "target/cjs/index.cjs",
+  "exports": {
+    ".": {
+      "types": "./target/dts/index.d.ts",
+      "require": "./target/cjs/index.cjs",
+      "import": "./target/esm/index.mjs",
+      "default": "./target/esm/index.mjs"
+    }
+  },
+  "scripts": {
+    "build": "concurrently 'npm:build:*'",
+    "build:js": "node ./src/scripts/build.mjs",
+    "build:dts": "tsc --emitDeclarationOnly --outDir target/dts",
+    "build:docs": "typedoc --options src/main/typedoc",
+    "build:stamp": "npx buildstamp",
+    "test": "concurrently 'npm:test:*'",
+    "test:lint": "eslint -c src/test/lint/.eslintrc.json src",
+    "test:unit": "c8 -r lcov -r text -o target/coverage -x src/scripts -x src/test -x target node --loader ts-node/esm --experimental-specifier-resolution=node src/scripts/test.mjs",
+    "test:legacy": "node ./node_modules/mocha/bin/mocha -t 0 -R spec src/test/legacy/test.cjs"
+  },
+  "files": [
+    "target/cjs",
+    "target/esm",
+    "target/dts"
+  ],
+  "keywords": [
+    "ps",
+    "process",
+    "lookup",
+    "pid"
+  ],
+  "dependencies": {
+    "@webpod/ingrid": "^0.0.0-beta.1",
+    "zurk": "^0.0.32"
+  },
+  "devDependencies": {
+    "@types/node": "^20.11.30",
+    "c8": "^9.1.0",
+    "concurrently": "^8.2.2",
+    "esbuild": "^0.20.2",
+    "esbuild-node-externals": "^1.13.0",
+    "esbuild-plugin-entry-chunks": "^0.1.11",
+    "eslint": "^8.57.0",
+    "eslint-config-qiwi": "^2.1.3",
+    "fast-glob": "^3.3.2",
+    "minimist": "^1.2.8",
+    "mocha": "^10.3.0",
+    "sinon": "^17.0.1",
+    "ts-node": "^10.9.2",
+    "typedoc": "^0.25.12",
+    "typescript": "^5.4.3"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/webpod/ps.git"
+  },
+  "license": "MIT"
+}

package/target/cjs/index.cjs

@@ -0,0 +1,244 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
+// src/main/ts/index.ts
+var ts_exports = {};
+__export(ts_exports, {
+  default: () => ts_default,
+  kill: () => kill,
+  lookup: () => lookup,
+  tree: () => tree
+});
+module.exports = __toCommonJS(ts_exports);
+
+// src/main/ts/ps.ts
+var import_node_process = __toESM(require("node:process"), 1);
+var import_node_fs = __toESM(require("node:fs"), 1);
+var import_ingrid = require("@webpod/ingrid");
+var import_spawn = require("zurk/spawn");
+var import_node_os = require("node:os");
+var EOL = /(\r\n)|(\n\r)|\n|\r/;
+var IS_WIN = import_node_process.default.platform === "win32";
+var isBin = (f) => {
+  if (f === "")
+    return false;
+  if (!f.includes("/"))
+    return true;
+  if (!import_node_fs.default.existsSync(f))
+    return false;
+  const stat = import_node_fs.default.lstatSync(f);
+  return stat.isFile() || stat.isSymbolicLink();
+};
+var lookup = (query = {}, cb = noop) => {
+  const { promise, resolve, reject } = makeDeferred();
+  const { psargs = ["-lx"] } = query;
+  const args = typeof psargs === "string" ? psargs.split(/\s+/) : psargs;
+  const extract = IS_WIN ? extractWmic : identity;
+  const callback = (err, { stdout }) => {
+    if (err) {
+      reject(err);
+      cb(err);
+      return;
+    }
+    const list = parseProcessList(extract(stdout), query);
+    resolve(list);
+    cb(null, list);
+  };
+  const ctx = IS_WIN ? {
+    cmd: "cmd",
+    input: "wmic process get ProcessId,ParentProcessId,CommandLine \n",
+    callback,
+    run(cb2) {
+      cb2();
+    }
+  } : {
+    cmd: "ps",
+    args,
+    run(cb2) {
+      cb2();
+    },
+    callback
+  };
+  (0, import_spawn.exec)(ctx);
+  return promise;
+};
+var parseProcessList = (output, query = {}) => {
+  const processList = parseGrid(output.trim());
+  const pidList = (query.pid === void 0 ? [] : [query.pid].flat(1)).map((v) => v + "");
+  const filters = [
+    (p) => query.command ? new RegExp(query.command, "i").test(p.command) : true,
+    (p) => query.arguments ? new RegExp(query.arguments, "i").test(p.arguments.join(" ")) : true,
+    (p) => query.ppid ? query.ppid + "" === p.ppid : true
+  ];
+  return processList.filter(
+    (p) => (pidList.length === 0 || pidList.includes(p.pid)) && filters.every((f) => f(p))
+  );
+};
+var extractWmic = (stdout) => {
+  const _stdout = stdout.split(EOL);
+  const beginRow = _stdout.findIndex((out) => (out == null ? void 0 : out.indexOf("CommandLine")) === 0);
+  _stdout.splice(_stdout.length - 1, 1);
+  _stdout.splice(0, beginRow);
+  return _stdout.join(import_node_os.EOL);
+};
+var pickTree = (list, pid, recursive = false) => {
+  const children = list.filter((p) => p.ppid === pid + "");
+  return [
+    ...children,
+    ...children.flatMap((p) => recursive ? pickTree(list, p.pid, true) : [])
+  ];
+};
+var tree = (_0, ..._1) => __async(void 0, [_0, ..._1], function* (opts, cb = noop) {
+  if (typeof opts === "string" || typeof opts === "number") {
+    return tree({ pid: opts }, cb);
+  }
+  try {
+    const { pid, recursive = false } = opts;
+    const list = pickTree(yield lookup(), pid, recursive);
+    cb(null, list);
+    return list;
+  } catch (err) {
+    cb(err);
+    throw err;
+  }
+});
+var kill = (pid, opts, next) => {
+  if (typeof opts == "function") {
+    return kill(pid, void 0, opts);
+  }
+  if (typeof opts == "string" || typeof opts == "number") {
+    return kill(pid, { signal: opts }, next);
+  }
+  const { promise, resolve, reject } = makeDeferred();
+  const {
+    timeout = 30,
+    signal = "SIGTERM"
+  } = opts || {};
+  try {
+    import_node_process.default.kill(+pid, signal);
+  } catch (e) {
+    reject(e);
+    next == null ? void 0 : next(e);
+    return promise;
+  }
+  let checkConfident = 0;
+  let checkTimeoutTimer;
+  let checkIsTimeout = false;
+  const checkKilled = (finishCallback) => lookup({ pid }, (err, list = []) => {
+    if (checkIsTimeout)
+      return;
+    if (err) {
+      clearTimeout(checkTimeoutTimer);
+      reject(err);
+      finishCallback == null ? void 0 : finishCallback(err, pid);
+    } else if (list.length > 0) {
+      checkConfident = checkConfident - 1 || 0;
+      checkKilled(finishCallback);
+    } else {
+      checkConfident++;
+      if (checkConfident === 5) {
+        clearTimeout(checkTimeoutTimer);
+        resolve(pid);
+        finishCallback == null ? void 0 : finishCallback(null, pid);
+      } else {
+        checkKilled(finishCallback);
+      }
+    }
+  });
+  if (next) {
+    checkKilled(next);
+    checkTimeoutTimer = setTimeout(() => {
+      checkIsTimeout = true;
+      next(new Error("Kill process timeout"));
+    }, timeout * 1e3);
+  } else {
+    resolve(pid);
+  }
+  return promise;
+};
+var parseGrid = (output) => output ? formatOutput((0, import_ingrid.parse)(output, { format: IS_WIN ? "win" : "unix" })) : [];
+var formatOutput = (data) => data.reduce((m, d) => {
+  var _a, _b, _c, _d;
+  const pid = ((_a = d.PID) == null ? void 0 : _a[0]) || ((_b = d.ProcessId) == null ? void 0 : _b[0]);
+  const ppid = ((_c = d.PPID) == null ? void 0 : _c[0]) || ((_d = d.ParentProcessId) == null ? void 0 : _d[0]);
+  const cmd = d.CMD || d.CommandLine || d.COMMAND || [];
+  if (pid && cmd.length > 0) {
+    const c = cmd.findIndex((_v, i) => isBin(cmd.slice(0, i).join(" ")));
+    const command = cmd.slice(0, c).join(" ");
+    const args = cmd.length > 1 ? cmd.slice(c) : [];
+    m.push({
+      pid,
+      ppid,
+      command,
+      arguments: args
+    });
+  }
+  return m;
+}, []);
+var makeDeferred = () => {
+  let resolve;
+  let reject;
+  const promise = new Promise((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  return { resolve, reject, promise };
+};
+var noop = () => {
+};
+var identity = (v) => v;
+
+// src/main/ts/index.ts
+var ts_default = { lookup, kill, tree };
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  kill,
+  lookup,
+  tree
+});

package/target/dts/foo.d.ts

@@ -0,0 +1 @@
+export declare const foo: () => undefined;

package/target/dts/index.d.ts

@@ -0,0 +1,8 @@
+export type * from './ps.ts';
+export { kill, lookup, tree } from './ps.ts';
+declare const _default: {
+    lookup: (query?: import("./ps.ts").TPsLookupQuery, cb?: import("./ps.ts").TPsLookupCallback) => Promise<import("./ps.ts").TPsLookupEntry[]>;
+    kill: (pid: string | number, opts?: string | number | import("./ps.ts").TPsKillOptions | import("./ps.ts").TPsNext | undefined, next?: import("./ps.ts").TPsNext | undefined) => Promise<void>;
+    tree: (opts: string | number | import("./ps.ts").TPsTreeOpts, cb?: import("./ps.ts").TPsLookupCallback) => Promise<import("./ps.ts").TPsLookupEntry[]>;
+};
+export default _default;

package/target/dts/ps.d.ts

@@ -0,0 +1,61 @@
+/// <reference types="node" resolution-mode="require"/>
+import { TIngridResponse } from '@webpod/ingrid';
+export type TPsLookupCallback = (err: any, processList?: TPsLookupEntry[]) => void;
+export type TPsLookupEntry = {
+    pid: string;
+    ppid?: string;
+    command: string;
+    arguments: string[];
+};
+export type TPsLookupQuery = {
+    pid?: number | string | (string | number)[];
+    command?: string;
+    arguments?: string;
+    ppid?: number | string;
+    psargs?: string | string[];
+};
+export type TPsKillOptions = {
+    timeout?: number;
+    signal?: string | number | NodeJS.Signals;
+};
+export type TPsNext = (err?: any, data?: any) => void;
+/**
+ * Query Process: Focus on pid & cmd
+ * @param query
+ * @param {String|String[]} query.pid
+ * @param {String} query.command RegExp String
+ * @param {String} query.arguments RegExp String
+ * @param {String|String[]} query.psargs
+ * @param {Function} cb
+ * @param {Object=null} cb.err
+ * @param {Object[]} cb.processList
+ * @return {Object}
+ */
+export declare const lookup: (query?: TPsLookupQuery, cb?: TPsLookupCallback) => Promise<TPsLookupEntry[]>;
+export declare const parseProcessList: (output: string, query?: TPsLookupQuery) => TPsLookupEntry[];
+export declare const extractWmic: (stdout: string) => string;
+export type TPsTreeOpts = {
+    pid: string | number;
+    recursive?: boolean;
+};
+export declare const pickTree: (list: TPsLookupEntry[], pid: string | number, recursive?: boolean) => TPsLookupEntry[];
+export declare const tree: (opts: string | number | TPsTreeOpts, cb?: TPsLookupCallback) => Promise<TPsLookupEntry[]>;
+/**
+ * Kill process
+ * @param pid
+ * @param {Object|String} opts
+ * @param {String} opts.signal
+ * @param {number} opts.timeout
+ * @param next
+ */
+export declare const kill: (pid: string | number, opts?: TPsNext | TPsKillOptions | TPsKillOptions['signal'], next?: TPsNext) => Promise<void>;
+export declare const parseGrid: (output: string) => TPsLookupEntry[];
+export declare const formatOutput: (data: TIngridResponse) => TPsLookupEntry[];
+export type PromiseResolve<T = any> = (value?: T | PromiseLike<T>) => void;
+export declare const makeDeferred: <T = any, E = any>() => {
+    promise: Promise<T>;
+    resolve: PromiseResolve<T>;
+    reject: PromiseResolve<E>;
+};
+export declare const noop: () => void;
+export declare const identity: <T>(v: T) => T;

package/target/esm/index.mjs

@@ -0,0 +1,184 @@
+// src/main/ts/ps.ts
+import process from "node:process";
+import fs from "node:fs";
+import { parse } from "@webpod/ingrid";
+import { exec } from "zurk/spawn";
+import { EOL as SystemEOL } from "node:os";
+var EOL = /(\r\n)|(\n\r)|\n|\r/;
+var IS_WIN = process.platform === "win32";
+var isBin = (f) => {
+  if (f === "")
+    return false;
+  if (!f.includes("/"))
+    return true;
+  if (!fs.existsSync(f))
+    return false;
+  const stat = fs.lstatSync(f);
+  return stat.isFile() || stat.isSymbolicLink();
+};
+var lookup = (query = {}, cb = noop) => {
+  const { promise, resolve, reject } = makeDeferred();
+  const { psargs = ["-lx"] } = query;
+  const args = typeof psargs === "string" ? psargs.split(/\s+/) : psargs;
+  const extract = IS_WIN ? extractWmic : identity;
+  const callback = (err, { stdout }) => {
+    if (err) {
+      reject(err);
+      cb(err);
+      return;
+    }
+    const list = parseProcessList(extract(stdout), query);
+    resolve(list);
+    cb(null, list);
+  };
+  const ctx = IS_WIN ? {
+    cmd: "cmd",
+    input: "wmic process get ProcessId,ParentProcessId,CommandLine \n",
+    callback,
+    run(cb2) {
+      cb2();
+    }
+  } : {
+    cmd: "ps",
+    args,
+    run(cb2) {
+      cb2();
+    },
+    callback
+  };
+  exec(ctx);
+  return promise;
+};
+var parseProcessList = (output, query = {}) => {
+  const processList = parseGrid(output.trim());
+  const pidList = (query.pid === void 0 ? [] : [query.pid].flat(1)).map((v) => v + "");
+  const filters = [
+    (p) => query.command ? new RegExp(query.command, "i").test(p.command) : true,
+    (p) => query.arguments ? new RegExp(query.arguments, "i").test(p.arguments.join(" ")) : true,
+    (p) => query.ppid ? query.ppid + "" === p.ppid : true
+  ];
+  return processList.filter(
+    (p) => (pidList.length === 0 || pidList.includes(p.pid)) && filters.every((f) => f(p))
+  );
+};
+var extractWmic = (stdout) => {
+  const _stdout = stdout.split(EOL);
+  const beginRow = _stdout.findIndex((out) => out?.indexOf("CommandLine") === 0);
+  _stdout.splice(_stdout.length - 1, 1);
+  _stdout.splice(0, beginRow);
+  return _stdout.join(SystemEOL);
+};
+var pickTree = (list, pid, recursive = false) => {
+  const children = list.filter((p) => p.ppid === pid + "");
+  return [
+    ...children,
+    ...children.flatMap((p) => recursive ? pickTree(list, p.pid, true) : [])
+  ];
+};
+var tree = async (opts, cb = noop) => {
+  if (typeof opts === "string" || typeof opts === "number") {
+    return tree({ pid: opts }, cb);
+  }
+  try {
+    const { pid, recursive = false } = opts;
+    const list = pickTree(await lookup(), pid, recursive);
+    cb(null, list);
+    return list;
+  } catch (err) {
+    cb(err);
+    throw err;
+  }
+};
+var kill = (pid, opts, next) => {
+  if (typeof opts == "function") {
+    return kill(pid, void 0, opts);
+  }
+  if (typeof opts == "string" || typeof opts == "number") {
+    return kill(pid, { signal: opts }, next);
+  }
+  const { promise, resolve, reject } = makeDeferred();
+  const {
+    timeout = 30,
+    signal = "SIGTERM"
+  } = opts || {};
+  try {
+    process.kill(+pid, signal);
+  } catch (e) {
+    reject(e);
+    next?.(e);
+    return promise;
+  }
+  let checkConfident = 0;
+  let checkTimeoutTimer;
+  let checkIsTimeout = false;
+  const checkKilled = (finishCallback) => lookup({ pid }, (err, list = []) => {
+    if (checkIsTimeout)
+      return;
+    if (err) {
+      clearTimeout(checkTimeoutTimer);
+      reject(err);
+      finishCallback?.(err, pid);
+    } else if (list.length > 0) {
+      checkConfident = checkConfident - 1 || 0;
+      checkKilled(finishCallback);
+    } else {
+      checkConfident++;
+      if (checkConfident === 5) {
+        clearTimeout(checkTimeoutTimer);
+        resolve(pid);
+        finishCallback?.(null, pid);
+      } else {
+        checkKilled(finishCallback);
+      }
+    }
+  });
+  if (next) {
+    checkKilled(next);
+    checkTimeoutTimer = setTimeout(() => {
+      checkIsTimeout = true;
+      next(new Error("Kill process timeout"));
+    }, timeout * 1e3);
+  } else {
+    resolve(pid);
+  }
+  return promise;
+};
+var parseGrid = (output) => output ? formatOutput(parse(output, { format: IS_WIN ? "win" : "unix" })) : [];
+var formatOutput = (data) => data.reduce((m, d) => {
+  const pid = d.PID?.[0] || d.ProcessId?.[0];
+  const ppid = d.PPID?.[0] || d.ParentProcessId?.[0];
+  const cmd = d.CMD || d.CommandLine || d.COMMAND || [];
+  if (pid && cmd.length > 0) {
+    const c = cmd.findIndex((_v, i) => isBin(cmd.slice(0, i).join(" ")));
+    const command = cmd.slice(0, c).join(" ");
+    const args = cmd.length > 1 ? cmd.slice(c) : [];
+    m.push({
+      pid,
+      ppid,
+      command,
+      arguments: args
+    });
+  }
+  return m;
+}, []);
+var makeDeferred = () => {
+  let resolve;
+  let reject;
+  const promise = new Promise((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  return { resolve, reject, promise };
+};
+var noop = () => {
+};
+var identity = (v) => v;
+
+// src/main/ts/index.ts
+var ts_default = { lookup, kill, tree };
+export {
+  ts_default as default,
+  kill,
+  lookup,
+  tree
+};