@orxataguy/tyr 1.0.0

package/src/lib/SystemManager.ts

@@ -0,0 +1,83 @@
+import { ShellManager } from './ShellManager.js';
+import { Logger } from '../core/Logger.js';
+import { TyrError } from '../core/TyrError.js';
+
+/**
+ * @class SystemManager
+ * @description General OS maintenance and cleanup utilities.
+ */
+export class SystemManager {
+    private shell: ShellManager;
+    private logger: Logger;
+
+    constructor(shell: ShellManager, logger: Logger) {
+        this.shell = shell;
+        this.logger = logger;
+    }
+
+    /**
+     * @method killPort
+     * @description Identifies which process is occupying a port and force-kills it.
+     * @param {number|string} port - The port to free (e.g. 3000).
+     * @returns {Promise<boolean>} True if a process was killed, False if the port was already free.
+     * @example
+     * await sys.killPort(8080);
+     */
+    public async killPort(port: number | string): Promise<boolean> {
+        try {
+            let pid: string | null = null;
+
+            if (process.platform === 'win32') {
+                const result = await this.shell.exec(`netstat -ano | findstr :${port}`).catch(() => null);
+                if (!result?.trim()) return false;
+                const lines = result.trim().split('\n').filter(l => l.includes(`LISTENING`));
+                if (!lines.length) return false;
+                pid = lines[0].trim().split(/\s+/).pop() ?? null;
+            } else {
+                pid = await this.shell.exec(`lsof -t -i:${port}`).catch(() => null);
+            }
+
+            if (!pid?.trim()) return false;
+
+            this.logger.warn(`Port ${port} blocked by PID ${pid.trim()}. Killing...`);
+
+            if (process.platform === 'win32') {
+                await this.shell.exec(`taskkill /F /PID ${pid.trim()}`);
+            } else {
+                await this.shell.exec(`kill -9 ${pid.trim()}`);
+            }
+
+            this.logger.success(`Port ${port} freed.`);
+            return true;
+        } catch (e) {
+            throw new TyrError(`Could not free port: ${port}`, e, 'Check that you have the necessary permissions.');
+        }
+    }
+
+    /**
+     * @method nukeNodeModules
+     * @description Removes node_modules and package-lock.json from the current directory.
+     * Useful for fixing corrupted NPM installations.
+     * @example
+     * await sys.nukeNodeModules();
+     */
+    public async nukeNodeModules(): Promise<void> {
+        this.logger.info('Cleaning up dependencies...');
+        try {
+            if (process.platform === 'win32') {
+                await this.shell.exec('if exist node_modules rmdir /s /q node_modules');
+                await this.shell.exec('if exist package-lock.json del /f /q package-lock.json');
+            } else {
+                await this.shell.exec('rm -rf node_modules package-lock.json');
+            }
+            this.logger.success('node_modules and package-lock.json removed.');
+        } catch (e) {
+            if (e instanceof TyrError) throw e;
+            throw new TyrError('Could not remove node_modules.', e, 'Check write permissions on the current directory.');
+        }
+    }
+}
+
+export const SystemManagerTests = {
+    killPort: { port: 3000 },
+};

package/src/lib/WebManager.ts

@@ -0,0 +1,62 @@
+import axios, { AxiosRequestConfig, AxiosResponse } from 'axios';
+import * as cheerio from 'cheerio';
+
+import { Logger } from '../core/Logger.js';
+import { TyrError } from '../core/TyrError.js';
+
+/**
+ * @class WebManager
+ * @description Utilities for accessing APIs and the Internet.
+ */
+export class WebManager {
+    private logger: Logger;
+
+    constructor(logger: Logger) {
+        this.logger = logger;
+    }
+
+    private async fetch(url: string, config?: AxiosRequestConfig): Promise<cheerio.CheerioAPI> {
+        try {
+            const response: AxiosResponse<string> = await axios.get(url, config);
+            return cheerio.load(response.data);
+        } catch (e) {
+            throw new TyrError(`Could not fetch URL: ${url}`, e, 'Check your internet connection and that the URL is valid.');
+        }
+    }
+
+    /**
+     * @method selectFromWeb
+     * @description Selects elements from a web page using a CSS selector.
+     * @param {string} url - URL of the page to scrape.
+     * @param {Function} selector - CSS selector function.
+     * @returns {Promise<string[]>} List of extracted text values.
+     * @example
+     * const titles = await web.selectFromWeb('https://example.com', ($) => $('h1'));
+     */
+    public async selectFromWeb(url: string, selector: ($: cheerio.CheerioAPI) => cheerio.Cheerio<any>): Promise<string[]> {
+        try {
+            const $ = await this.fetch(url);
+            const results: string[] = [];
+            const selection = selector($);
+
+            if (typeof selection === 'string') return [selection];
+
+            selection.each((_, element) => {
+                const text = $(element).text().trim();
+                if (text) results.push(text);
+            });
+
+            return results;
+        } catch (e) {
+            if (e instanceof TyrError) throw e;
+            throw new TyrError(`Could not select content from: ${url}`, e);
+        }
+    }
+}
+
+export const WebManagerTests = {
+    selectFromWeb: {
+        url: 'https://www.w3schools.com/',
+        selector: ($: any) => $('title'),
+    },
+};