deepwork-node-watchdog 1.0.0 → 1.0.2

package/README.md

@@ -24,18 +24,45 @@ npm install deepwork-node-watchdog
 
 ## Uso como CLI
 
-### Iniciar el watchdog
+### Iniciar el watchdog con un archivo de lista negra
 
 ```bash
 deepwork-watchdog --blacklist /ruta/absoluta/a/blacklist.txt
 ```
 
+### Iniciar el watchdog con una lista de procesos separados por coma
+
+```bash
+deepwork-watchdog --blacklist discord,whatsapp,spotify
+```
+
+### Especificar intervalo de escaneo
+
+```bash
+deepwork-watchdog --blacklist discord,spotify --interval 5000
+```
+
 ### Listar procesos en ejecución
 
 ```bash
 deepwork-watchdog --list
 ```
 
+### Ver la versión
+
+```bash
+deepwork-watchdog --version
+```
+
+### Argumentos disponibles
+
+| Argumento      | Tipo      | Default | Descripción                                                                 |
+|----------------|-----------|---------|-----------------------------------------------------------------------------|
+| `--blacklist`  | `string`  | —       | Ruta absoluta a un archivo de lista negra, o nombres separados por coma     |
+| `--interval`   | `number`  | `3000`  | Intervalo entre escaneos en milisegundos                                    |
+| `--list`       | `boolean` | —       | Lista los procesos activos del sistema y termina                             |
+| `--version`    | `boolean` | —       | Muestra la versión del paquete y termina                                    |
+
 ### Archivo de lista negra (`blacklist.txt`)
 
 Cada línea es el nombre de un proceso a matar. Las líneas vacías y los comentarios (`#`) son ignorados. La extensión `.exe` es opcional.
@@ -52,13 +79,12 @@ spotify
 ## Uso como librería
 
 ```ts
-import { start, stop, isRunning, listProcesses } from 'deepwork-node-watchdog';
+import { start, stop, scan, isRunning, listProcesses } from 'deepwork-node-watchdog';
 
 // Iniciar el watchdog con una lista de procesos
 start({
   blacklist: ['discord', 'whatsapp', 'spotify'],
-  intervalMs: 5000,           // Intervalo de escaneo en ms (default: 3000)
-  logFile: 'watchdog.log',    // Opcional: archivo de log
+  intervalMs: 5000, // Intervalo de escaneo en ms (default: 3000)
 });
 
 // Detener el watchdog
@@ -67,41 +93,38 @@ stop();
 // Verificar si está corriendo
 console.log(isRunning()); // true | false
 
+// Escaneo único (sin loop)
+await scan(['discord', 'spotify']);
+
+// También acepta ruta a archivo de lista negra
+await scan('/ruta/absoluta/a/blacklist.txt');
+
 // Listar procesos activos
 const processes = await listProcesses();
 processes.forEach(p => console.log(`${p.name} (PID: ${p.pid})`));
 ```
 
-### También puedes usar un archivo de lista negra
-
-```ts
-start({
-  blacklistPath: '/ruta/absoluta/a/blacklist.txt',
-  intervalMs: 3000,
-});
-```
-
 ---
 
 ## API
 
 ### `start(options: WatchdogOptions): void`
 
-Inicia el watchdog. Si ya está corriendo, no hace nada.
+Inicia el watchdog en loop. Si ya está corriendo, no hace nada.
 
-| Opción          | Tipo       | Default          | Descripción                                      |
-|-----------------|------------|------------------|--------------------------------------------------|
-| `blacklist`     | `string[]` | —                | Lista de nombres de procesos a matar             |
-| `blacklistPath` | `string`   | —                | Ruta absoluta a un archivo de lista negra        |
-| `intervalMs`    | `number`   | `3000`           | Intervalo entre escaneos en milisegundos         |
-| `logFile`       | `string`   | —                | Ruta al archivo de log (opcional)                |
-
-> Se debe especificar `blacklist` o `blacklistPath`. Si no se especifica ninguno, el watchdog se inicia pero no hace nada.
+| Opción       | Tipo                  | Default | Descripción                                                       |
+|--------------|-----------------------|---------|-------------------------------------------------------------------|
+| `blacklist`  | `string \| string[]`  | —       | Ruta a un archivo de lista negra, o array de nombres de procesos  |
+| `intervalMs` | `number`              | `3000`  | Intervalo entre escaneos en milisegundos                          |
 
 ### `stop(): void`
 
 Detiene el watchdog y limpia el timer interno.
 
+### `scan(blacklist: string | string[]): Promise<void>`
+
+Ejecuta un escaneo único. Acepta un array de nombres de procesos o la ruta absoluta a un archivo de lista negra.
+
 ### `isRunning(): boolean`
 
 Retorna `true` si el watchdog está activo.
@@ -112,20 +135,6 @@ Retorna la lista de procesos activos en el sistema.
 
 ---
 
-## Configuración CLI (`watchdog.conf`)
-
-Cuando se usa como CLI, el watchdog lee un archivo `watchdog.conf` en el directorio de instalación:
-
-```ini
-# Intervalo entre escaneos (milisegundos)
-INTERVAL_MS=3000
-
-# Archivo de log (dejar vacío para desactivar)
-LOG_FILE=watchdog.log
-```
-
----
-
 ## Compatibilidad
 
 | Sistema operativo | Comando para listar | Comando para matar |
@@ -137,4 +146,4 @@ LOG_FILE=watchdog.log
 
 ## Licencia
 
-ISC — Kevin Javier Reyes
+ISC — Kevin Javier Reyes

package/dist/helpers/blacklist.helper.js

@@ -35,7 +35,6 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.loadBlacklist = loadBlacklist;
 const fs = __importStar(require("fs"));
-const normalize_util_1 = require("../utils/normalize.util");
 /**
  * Read the content file at the given path.
  *
@@ -55,8 +54,7 @@ function loadBlacklist(filePath) {
             .readFileSync(filePath, "utf8")
             .split("\n")
             .map((l) => l.trim())
-            .filter((l) => l && !l.startsWith("#"))
-            .map(normalize_util_1.normalizeProcessName);
+            .filter((l) => l && !l.startsWith("#"));
     }
     catch {
         return [];

package/dist/helpers/command.helper.d.ts

@@ -1,4 +1,4 @@
-export declare function killProcess(pid: number, name: string, logFile?: string): Promise<void>;
+export declare function killProcess(pid: number, name: string): Promise<void>;
 export declare function listProcesses(): Promise<{
     pid: number;
     name: string;

package/dist/helpers/command.helper.js

@@ -41,7 +41,7 @@ const os = __importStar(require("os"));
 const log_util_1 = require("../utils/log.util");
 const normalize_util_1 = require("../utils/normalize.util");
 const execAsync = (0, util_1.promisify)(child_process_1.exec);
-async function killProcess(pid, name, logFile) {
+async function killProcess(pid, name) {
     try {
         if (os.platform() === "win32") {
             await execAsync(`taskkill /F /PID ${pid}`, { timeout: 5000 });
@@ -49,10 +49,10 @@ async function killProcess(pid, name, logFile) {
         else {
             await execAsync(`kill -9 ${pid}`, { timeout: 5000 });
         }
-        (0, log_util_1.log)(`Killed process: ${name} (PID: ${pid})`, logFile);
+        (0, log_util_1.log)(`Killed process: ${name} (PID: ${pid})`);
     }
     catch (err) {
-        (0, log_util_1.log)(`Failed to kill ${name} (PID: ${pid}): ${err}`, logFile);
+        (0, log_util_1.log)(`Failed to kill ${name} (PID: ${pid}): ${err}`);
     }
 }
 async function listProcesses() {

package/dist/index.d.ts

@@ -1,4 +1,5 @@
 import { WatchdogOptions } from "./watchdog.types";
+export declare function scan(blacklist: string[] | string): Promise<void>;
 export declare function start(options: WatchdogOptions): void;
 export declare function stop(): void;
 export declare function isRunning(): boolean;

package/dist/index.js

@@ -4,6 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.listProcesses = void 0;
+exports.scan = scan;
 exports.start = start;
 exports.stop = stop;
 exports.isRunning = isRunning;
@@ -15,25 +16,20 @@ let activeOptions = null;
 async function loop() {
     if (!running || !activeOptions)
         return;
-    const { blacklistPath, blacklist, intervalMs = 3000, logFile, } = activeOptions;
-    await watchdog_1.default.scan(blacklistPath ?? blacklist, {
-        INTERVAL_MS: intervalMs,
-        LOG_FILE: logFile,
-    });
+    const { blacklist, intervalMs = 3000 } = activeOptions;
+    await watchdog_1.default.scan(blacklist);
     if (running) {
         timer = setTimeout(loop, intervalMs);
     }
 }
+async function scan(blacklist) {
+    return watchdog_1.default.scan(blacklist);
+}
 function start(options) {
     if (running)
         return;
     running = true;
     activeOptions = options;
-    if (!options.blacklistPath &&
-        (!options.blacklist || options.blacklist.length === 0)) {
-        (0, log_util_1.log)("No blacklist specified. Use options.blacklistPath or options.blacklist to set it.", options.logFile);
-        return;
-    }
     loop();
 }
 function stop() {

package/dist/libs/args.lib.d.ts

@@ -0,0 +1,14 @@
+type ArgType = "string" | "boolean" | "number";
+interface ArgDef {
+    flag: string;
+    type: ArgType;
+    required?: boolean;
+    description?: string;
+    default?: string | boolean | number;
+}
+type InferType<T extends ArgType> = T extends "string" ? string : T extends "boolean" ? boolean : number;
+type ParsedArgs<T extends ArgDef[]> = {
+    [K in T[number] as K["flag"] extends `--${infer Name}` ? Name : never]: K["required"] extends true ? InferType<K["type"]> : InferType<K["type"]> | null;
+};
+export declare function parseArgs<const T extends ArgDef[]>(defs: T): ParsedArgs<T>;
+export {};

package/dist/libs/args.lib.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseArgs = parseArgs;
+function parseArgs(defs) {
+    const raw = process.argv.slice(2);
+    const result = {};
+    for (const def of defs) {
+        const name = def.flag.replace(/^--/, "");
+        const idx = raw.indexOf(def.flag);
+        if (def.type === "boolean") {
+            result[name] = idx !== -1;
+        }
+        else if (idx !== -1) {
+            const val = raw[idx + 1];
+            if (val === undefined || val.startsWith("--")) {
+                throw new Error(`Missing value for ${def.flag}`);
+            }
+            result[name] = def.type === "number" ? Number(val) : val;
+        }
+        else if (def.default !== undefined) {
+            result[name] = def.default;
+        }
+        else if (def.required) {
+            throw new Error(`Required argument ${def.flag} is missing`);
+        }
+        else {
+            result[name] = null;
+        }
+    }
+    return result;
+}

package/dist/main.js

@@ -5,31 +5,69 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const log_util_1 = require("./utils/log.util");
-const config_helper_1 = require("./helpers/config.helper");
+const args_lib_1 = require("./libs/args.lib");
 const watchdog_1 = __importDefault(require("./watchdog"));
-const args = process.argv.slice(2);
-const blacklistIndex = args.indexOf("--blacklist");
-const listIndex = args.indexOf("--list");
-const BLACKLIST_FILE = blacklistIndex !== -1 ? args[blacklistIndex + 1] : null;
+const path_1 = __importDefault(require("path"));
+// Default configuration values
+const DEFAULT_INTERVAL_MS = 3000;
+// Define and parse command-line arguments
+const args = (0, args_lib_1.parseArgs)([
+    {
+        flag: "--blacklist",
+        type: "string",
+        description: "Absolute path to blacklist file or a comma-separated list of process names",
+    },
+    {
+        flag: "--list",
+        type: "boolean",
+        description: "List current running processes",
+    },
+    {
+        flag: "--version",
+        type: "boolean",
+        description: "Show the version of the watchdog",
+    },
+    {
+        flag: "--interval",
+        type: "number",
+        description: "Interval in milliseconds for scanning processes",
+        default: DEFAULT_INTERVAL_MS,
+    },
+]);
 (0, log_util_1.log)("Process Watchdog started" +
-    (BLACKLIST_FILE ? ` with blacklist file: ${BLACKLIST_FILE}` : ""));
+    (args.blacklist ? ` with blacklist file: ${args.blacklist}` : ""));
 let running = true;
+let blacklistPathOrNames = null;
 let timer;
+function validateArgsRequirementsToScan() {
+    if (!args.blacklist) {
+        (0, log_util_1.log)("No blacklist file or process names specified. Use --blacklist <absolutePath> or a comma-separated list of process names to set it.");
+        return false;
+    }
+    if (args.interval <= 0) {
+        (0, log_util_1.log)("Interval must be a positive number.");
+        return false;
+    }
+    return true;
+}
 async function loop() {
     if (!running)
         return;
-    const config = (0, config_helper_1.loadConfig)();
-    if (!BLACKLIST_FILE) {
-        (0, log_util_1.log)("No blacklist file specified. Use --blacklist <absolutePath> to set it.", config.LOG_FILE);
+    if (!validateArgsRequirementsToScan()) {
         return;
     }
     console.log("Scanning processes...");
-    await watchdog_1.default.scan(BLACKLIST_FILE, config);
+    await watchdog_1.default.scan(blacklistPathOrNames);
     if (running) {
-        timer = setTimeout(loop, config.INTERVAL_MS);
+        timer = setTimeout(loop, args.interval);
     }
 }
-if (listIndex !== -1) {
+if (args.version) {
+    let pkg = require(path_1.default.resolve(__dirname, "../package.json"));
+    console.log(`Process Watchdog version: ${pkg.version}`);
+    process.exit(0);
+}
+else if (args.list) {
     (async () => {
         const processes = await watchdog_1.default.listProcesses();
         console.log("Current running processes:");
@@ -38,6 +76,19 @@ if (listIndex !== -1) {
     })();
 }
 else {
+    const blacklist = args.blacklist?.trim();
+    if (!blacklist) {
+        (0, log_util_1.log)("No blacklist file or process names specified. Use --blacklist <absolutePath> or a comma-separated list of process names to set it.");
+        process.exit(1);
+    }
+    blacklistPathOrNames = args.blacklist.includes(",")
+        ? args.blacklist.split(",").map((s) => s.trim())
+        : path_1.default.isAbsolute(args.blacklist || "")
+            ? args.blacklist
+            : path_1.default.resolve(process.cwd(), args.blacklist || "");
+    console.log(`Using blacklist file or names: ${blacklistPathOrNames}`);
+    console.log(`Starting process scan loop with interval: ${args.interval}ms`);
+    console.log("Press Ctrl+C to stop the watchdog.");
     loop();
 }
 process.on("SIGINT", () => {

package/dist/utils/log.util.d.ts

@@ -1 +1 @@
-export declare function log(message: string, logFile?: string): void;
+export declare function log(message: string): void;

package/dist/utils/log.util.js

@@ -1,50 +1,8 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.log = log;
-const fs = __importStar(require("fs"));
-function log(message, logFile) {
+function log(message) {
     const timestamp = new Date().toISOString();
     const msg = `[${timestamp}] ${message}`;
     console.log(msg);
-    if (logFile) {
-        try {
-            fs.appendFileSync(logFile, msg + "\n");
-        }
-        catch {
-            /* ignore */
-        }
-    }
 }

package/dist/watchdog.d.ts

@@ -1,6 +1,5 @@
-import { Config } from "./watchdog.types";
 import { listProcesses } from "./helpers/command.helper";
-declare function scan(blacklistPathOrList: string | string[], config: Config): Promise<void>;
+declare function scan(blacklistPathOrList: string | string[]): Promise<void>;
 declare const _default: {
     scan: typeof scan;
     listProcesses: typeof listProcesses;

package/dist/watchdog.js

@@ -3,8 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const blacklist_helper_1 = require("./helpers/blacklist.helper");
 const command_helper_1 = require("./helpers/command.helper");
 const normalize_util_1 = require("./utils/normalize.util");
-async function scan(blacklistPathOrList, config) {
-    const { LOG_FILE } = config;
+async function scan(blacklistPathOrList) {
     // Load blacklist
     const blacklist = typeof blacklistPathOrList === "string"
         ? (0, blacklist_helper_1.loadBlacklist)(blacklistPathOrList)
@@ -17,8 +16,9 @@ async function scan(blacklistPathOrList, config) {
     for (const proc of processes) {
         const normalizedName = (0, normalize_util_1.normalizeProcessName)(proc.name);
         for (const black of blacklist) {
-            if (normalizedName.indexOf(black) !== -1) {
-                await (0, command_helper_1.killProcess)(proc.pid, proc.name, LOG_FILE);
+            const normalizedBlack = (0, normalize_util_1.normalizeProcessName)(black);
+            if (normalizedName.indexOf(normalizedBlack) !== -1) {
+                await (0, command_helper_1.killProcess)(proc.pid, proc.name);
             }
         }
     }

package/dist/watchdog.types.d.ts

@@ -1,17 +1,4 @@
-export interface Config {
-    INTERVAL_MS: number;
-    LOG_FILE: string;
-}
-export interface Profile {
-    name: string;
-    path: string;
-    blacklistPath: string;
-    hasBlacklist: boolean;
-    processCount: number;
-}
 export interface WatchdogOptions {
-    blacklistPath?: string;
-    blacklist?: string[];
+    blacklist: string[] | string;
     intervalMs?: number;
-    logFile?: string;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "deepwork-node-watchdog",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "A Node.js watchdog for DeepWork.",
   "license": "ISC",
   "author": "Kevin Javier Reyes",
@@ -13,9 +13,12 @@
     "deepwork-watchdog": "dist/main.js"
   },
   "scripts": {
-    "start": "ts-node main.ts --blacklist blacklist.txt",
-    "dev": "ts-node-dev --respawn --transpile-only --ignore-watch node_modules main.ts --blacklist blacklist.txt",
-    "list": "ts-node main.ts --list",
+    "start": "ts-node src/main.ts --blacklist steam,epicgames,origin,ubisoft,riot,blizzard",
+    "list": "ts-node src/main.ts --list",
+    "version": "ts-node src/main.ts --version",
+    "start:dev": "ts-node-dev --respawn --transpile-only --ignore-watch node_modules src/main.ts --blacklist steam,epicgames,origin,ubisoft,riot,blizzard",
+    "list:dev": "ts-node-dev --respawn --transpile-only --ignore-watch node_modules src/main.ts --list",
+    "version:dev": "ts-node-dev --respawn --transpile-only --ignore-watch node_modules src/main.ts --version",
     "build": "tsc"
   },
   "devDependencies": {
@@ -23,5 +26,8 @@
     "ts-node": "^10.9.2",
     "ts-node-dev": "^2.0.0",
     "typescript": "^5.4.0"
+  },
+  "dependencies": {
+    "deepwork-node-watchdog": "1.0.0"
   }
 }