deepwork-node-watchdog 1.0.0

package/README.md

@@ -0,0 +1,140 @@
+# deepwork-node-watchdog
+
+Watchdog de procesos para Node.js. Monitorea los procesos del sistema en intervalos configurables y mata automáticamente los procesos que estén en una lista negra. Compatible con **Windows**, **Linux** y **macOS**.
+
+Pensado para entornos de trabajo enfocado: bloquea apps de distracción (Discord, WhatsApp, etc.) mientras trabajas.
+
+---
+
+## Instalación
+
+### Como herramienta global (CLI)
+
+```bash
+npm install -g deepwork-node-watchdog
+```
+
+### Como dependencia en tu proyecto
+
+```bash
+npm install deepwork-node-watchdog
+```
+
+---
+
+## Uso como CLI
+
+### Iniciar el watchdog
+
+```bash
+deepwork-watchdog --blacklist /ruta/absoluta/a/blacklist.txt
+```
+
+### Listar procesos en ejecución
+
+```bash
+deepwork-watchdog --list
+```
+
+### 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.
+
+```txt
+# Apps de distracción
+discord
+whatsapp
+spotify
+```
+
+---
+
+## Uso como librería
+
+```ts
+import { start, stop, 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
+});
+
+// Detener el watchdog
+stop();
+
+// Verificar si está corriendo
+console.log(isRunning()); // true | false
+
+// 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.
+
+| 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.
+
+### `stop(): void`
+
+Detiene el watchdog y limpia el timer interno.
+
+### `isRunning(): boolean`
+
+Retorna `true` si el watchdog está activo.
+
+### `listProcesses(): Promise<{ pid: number; name: string }[]>`
+
+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 |
+|-------------------|---------------------|--------------------|
+| Windows           | `tasklist`          | `taskkill /F /PID` |
+| Linux / macOS     | `ps`                | `kill -9`          |
+
+---
+
+## Licencia
+
+ISC — Kevin Javier Reyes

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

@@ -0,0 +1,7 @@
+/**
+ * Read the content file at the given path.
+ *
+ * @param {string} filePath Path of the blacklist file to read.
+ * @returns {string[]} List of process names to blacklist.
+ */
+export declare function loadBlacklist(filePath: string): string[];

package/dist/helpers/blacklist.helper.js

@@ -0,0 +1,64 @@
+"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.loadBlacklist = loadBlacklist;
+const fs = __importStar(require("fs"));
+const normalize_util_1 = require("../utils/normalize.util");
+/**
+ * Read the content file at the given path.
+ *
+ * @param {string} filePath Path of the blacklist file to read.
+ * @returns {string[]} List of process names to blacklist.
+ */
+function loadBlacklist(filePath) {
+    // Validate if file exists
+    if (!fs.existsSync(filePath))
+        return [];
+    // Read the file and apply:
+    // - Trim each line
+    // - Ignore empty lines and comments (lines starting with #)
+    // - Normalize to lowercase and remove .exe suffix for consistency
+    try {
+        return fs
+            .readFileSync(filePath, "utf8")
+            .split("\n")
+            .map((l) => l.trim())
+            .filter((l) => l && !l.startsWith("#"))
+            .map(normalize_util_1.normalizeProcessName);
+    }
+    catch {
+        return [];
+    }
+}

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

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

package/dist/helpers/command.helper.js

@@ -0,0 +1,95 @@
+"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.killProcess = killProcess;
+exports.listProcesses = listProcesses;
+const child_process_1 = require("child_process");
+const util_1 = require("util");
+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) {
+    try {
+        if (os.platform() === "win32") {
+            await execAsync(`taskkill /F /PID ${pid}`, { timeout: 5000 });
+        }
+        else {
+            await execAsync(`kill -9 ${pid}`, { timeout: 5000 });
+        }
+        (0, log_util_1.log)(`Killed process: ${name} (PID: ${pid})`, logFile);
+    }
+    catch (err) {
+        (0, log_util_1.log)(`Failed to kill ${name} (PID: ${pid}): ${err}`, logFile);
+    }
+}
+async function listProcesses() {
+    try {
+        if (os.platform() === "win32") {
+            const { stdout } = await execAsync("tasklist /FO CSV /NH", {
+                timeout: 5000,
+            });
+            return stdout
+                .trim()
+                .split("\n")
+                .map((line) => {
+                const parts = line.split('","');
+                const name = (parts[0] || "").replace(/^"/, "");
+                const pid = parseInt(parts[1] || "0", 10);
+                return { pid, name: (0, normalize_util_1.normalizeProcessName)(name) };
+            })
+                .filter((p) => p.pid > 0);
+        }
+        else {
+            const { stdout } = await execAsync("ps -eo pid,comm --no-headers", {
+                timeout: 5000,
+            });
+            return stdout
+                .trim()
+                .split("\n")
+                .map((line) => {
+                const [pidStr, ...nameParts] = line.trim().split(/\s+/);
+                return {
+                    pid: parseInt(pidStr, 10),
+                    name: nameParts.join(" ").toLowerCase(),
+                };
+            })
+                .filter((p) => p.pid > 0);
+        }
+    }
+    catch {
+        return [];
+    }
+}

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

@@ -0,0 +1,8 @@
+import { Config } from "../watchdog.types";
+/**
+ * Read "watchdog.conf" from the same directory as this script, parse it, and return a Config object.
+ * If the config file does not exist or cannot be read, return default values.
+ *
+ * @returns {Config} Config object with the configuration values
+ */
+export declare function loadConfig(): Config;

package/dist/helpers/config.helper.js

@@ -0,0 +1,80 @@
+"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.loadConfig = loadConfig;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+/**
+ * Read "watchdog.conf" from the same directory as this script, parse it, and return a Config object.
+ * If the config file does not exist or cannot be read, return default values.
+ *
+ * @returns {Config} Config object with the configuration values
+ */
+function loadConfig() {
+    // Define default values
+    const defaults = {
+        INTERVAL_MS: 3000,
+        LOG_FILE: "watchdog.log",
+    };
+    // Determinate and validate the path to the config file
+    const configPath = path.join(__dirname, "watchdog.conf");
+    if (!fs.existsSync(configPath))
+        return defaults;
+    // Read and parse the config file
+    try {
+        const config = { ...defaults };
+        // Read the config file content
+        const content = fs.readFileSync(configPath, "utf8");
+        // Loop Line by line and parse key-value pairs
+        for (const line of content.split("\n")) {
+            const trimmed = line.trim();
+            if (!trimmed || trimmed.startsWith("#"))
+                continue;
+            const eqIdx = trimmed.indexOf("=");
+            if (eqIdx === -1)
+                continue;
+            const key = trimmed.slice(0, eqIdx).trim();
+            const value = trimmed.slice(eqIdx + 1).trim();
+            if (key === "INTERVAL_MS")
+                config.INTERVAL_MS = parseInt(value, 10) || defaults.INTERVAL_MS;
+            if (key === "LOG_FILE")
+                config.LOG_FILE = value;
+        }
+        return config;
+    }
+    catch {
+        return defaults;
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+import { WatchdogOptions } from "./watchdog.types";
+export declare function start(options: WatchdogOptions): void;
+export declare function stop(): void;
+export declare function isRunning(): boolean;
+export declare const listProcesses: typeof import("./helpers/command.helper").listProcesses;

package/dist/index.js

@@ -0,0 +1,53 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listProcesses = void 0;
+exports.start = start;
+exports.stop = stop;
+exports.isRunning = isRunning;
+const watchdog_1 = __importDefault(require("./watchdog"));
+const log_util_1 = require("./utils/log.util");
+let running = false;
+let timer = null;
+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,
+    });
+    if (running) {
+        timer = setTimeout(loop, intervalMs);
+    }
+}
+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() {
+    if (!running)
+        return;
+    running = false;
+    activeOptions = null;
+    if (timer) {
+        clearTimeout(timer);
+        timer = null;
+    }
+    (0, log_util_1.log)("Process Watchdog stopped");
+}
+function isRunning() {
+    return running;
+}
+exports.listProcesses = watchdog_1.default.listProcesses;

package/dist/main.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/main.js

@@ -0,0 +1,54 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const log_util_1 = require("./utils/log.util");
+const config_helper_1 = require("./helpers/config.helper");
+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;
+(0, log_util_1.log)("Process Watchdog started" +
+    (BLACKLIST_FILE ? ` with blacklist file: ${BLACKLIST_FILE}` : ""));
+let running = true;
+let timer;
+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);
+        return;
+    }
+    console.log("Scanning processes...");
+    await watchdog_1.default.scan(BLACKLIST_FILE, config);
+    if (running) {
+        timer = setTimeout(loop, config.INTERVAL_MS);
+    }
+}
+if (listIndex !== -1) {
+    (async () => {
+        const processes = await watchdog_1.default.listProcesses();
+        console.log("Current running processes:");
+        processes.forEach((p) => console.log(`- ${p.name} (PID: ${p.pid})`));
+        process.exit(0);
+    })();
+}
+else {
+    loop();
+}
+process.on("SIGINT", () => {
+    running = false;
+    clearTimeout(timer);
+    (0, log_util_1.log)("Process Watchdog stopped (SIGINT)");
+    process.exit(0);
+});
+process.on("SIGTERM", () => {
+    running = false;
+    clearTimeout(timer);
+    (0, log_util_1.log)("Process Watchdog stopped (SIGTERM)");
+    process.exit(0);
+});

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

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

package/dist/utils/log.util.js

@@ -0,0 +1,50 @@
+"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) {
+    const timestamp = new Date().toISOString();
+    const msg = `[${timestamp}] ${message}`;
+    console.log(msg);
+    if (logFile) {
+        try {
+            fs.appendFileSync(logFile, msg + "\n");
+        }
+        catch {
+            /* ignore */
+        }
+    }
+}

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

@@ -0,0 +1 @@
+export declare function normalizeProcessName(name: string): string;

package/dist/utils/normalize.util.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeProcessName = normalizeProcessName;
+function normalizeProcessName(name) {
+    return name.toLowerCase().replace(/\.exe$/, "");
+}

package/dist/watchdog.d.ts

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

package/dist/watchdog.js

@@ -0,0 +1,29 @@
+"use strict";
+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;
+    // Load blacklist
+    const blacklist = typeof blacklistPathOrList === "string"
+        ? (0, blacklist_helper_1.loadBlacklist)(blacklistPathOrList)
+        : blacklistPathOrList;
+    if (blacklist.length === 0)
+        return;
+    // Get current processes
+    const processes = await (0, command_helper_1.listProcesses)();
+    // Kill blacklisted processes
+    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);
+            }
+        }
+    }
+}
+exports.default = {
+    scan,
+    listProcesses: command_helper_1.listProcesses,
+};

package/dist/watchdog.types.d.ts

@@ -0,0 +1,17 @@
+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[];
+    intervalMs?: number;
+    logFile?: string;
+}

package/dist/watchdog.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "deepwork-node-watchdog",
+  "version": "1.0.0",
+  "description": "A Node.js watchdog for DeepWork.",
+  "license": "ISC",
+  "author": "Kevin Javier Reyes",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "bin": {
+    "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",
+    "build": "tsc"
+  },
+  "devDependencies": {
+    "@types/node": "^20.14.0",
+    "ts-node": "^10.9.2",
+    "ts-node-dev": "^2.0.0",
+    "typescript": "^5.4.0"
+  }
+}