puppyperpetual 0.0.1-security → 1.0.0

package/README.md

@@ -1 +1,57 @@
-WIP, coming soon
+# puppyperpetual
+
+node script to run things... perpetually. adapted from [legacyshell](https://github.com/onlypuppy7/LegacyShell)
+
+[On npm @ https://www.npmjs.com/package/puppyperpetual](https://www.npmjs.com/package/puppyperpetual)
+
+[And GitHub @ https://github.com/onlypuppy7/perpetual](https://github.com/onlypuppy7/perpetual)
+
+## usage (as an npm package)
+
+you can use it to run your node stuff perpetually:
+
+```js
+import Perpetual from '../index.js';
+
+const perpetual = new Perpetual('test_process', {
+    process_cmd: 'node ./src/test/test_process.js',
+});
+await perpetual.run();
+```
+
+or anything really:
+
+```js
+import Perpetual from '../index.js';
+
+const perpetual = new Perpetual('test_process', {
+    process_cmd: 'cd . && git pull && date',
+});
+await perpetual.run();
+```
+
+## usage (as a node app thing)
+
+as per tradition for my projects, simple installation!
+
+1. `npm i`
+
+then run once to create config
+
+- `npm run start`
+
+then customise it in `store/config.yaml`, making a new entry for every thing
+
+then run like this:
+
+- `node .\perpetual.js --default`
+
+alternatively, just pass in your command:
+
+- `node .\perpetual.js "cd . && echo date"`
+
+then you dont need to mess around with the horrible yaml. dont worry, i hate doing it too.
+
+## it doesnt work?
+
+i dont care. i use this for my own stuff. i know that it works on linux and thats all i need.

package/package.json

@@ -1,5 +1,18 @@
 {
-"name": "puppyperpetual",
-"description": "coming soon!",
-"version": "0.0.1-security"
-}
+    "name": "puppyperpetual",
+    "type": "module",
+    "version": "v1.0.0",
+    "description": "Run stuff FOREVER! PERPETUALLY!",
+    "main": "perpetual.js",
+    "scripts": {
+        "start": "node perpetual.js",
+        "test": "node src/test/test.js"
+    },
+    "dependencies": {
+        "chalk": "^5.3.0",
+        "js-yaml": "^4.1.0",
+        "puppylog": "^1.0.5",
+        "puppymisc": "^1.0.4",
+        "puppywebhook": "^1.0.1"
+    }
+}

package/perpetual.js

@@ -0,0 +1,22 @@
+import { fileURLToPath } from 'node:url';
+import { dirname } from 'node:path';
+import Perpetual from './src/index.js';
+
+let rootDir = import.meta.dirname;
+
+if (!rootDir) {
+    const __filename = fileURLToPath(import.meta.url);
+    rootDir = dirname(__filename);
+    console.log("(Using fallback mechanism for rootDir)");
+};
+
+console.log(process.argv, rootDir);
+
+const serverName = process.argv[2].replace("--","");
+const isDirect = !process.argv[2].startsWith("--");
+
+const perpetual = new Perpetual(serverName, {
+    process_cmd: isDirect ? process.argv.slice(2).join(" ") : null,
+    rootDir,
+});
+await perpetual.run();

package/src/ConfigManager.js

@@ -0,0 +1,61 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import yaml from 'js-yaml';
+
+export class ConfigManager {
+    constructor(rootDir, serverName) {
+        this.rootDir = rootDir;
+        this.serverName = serverName;
+
+        this.defaultConfigPath = path.join(rootDir, 'src', 'defaultconfig.yaml');
+        this.configPath = path.join(rootDir, 'store', 'config.yaml');
+
+        this.ensureConfigExists();
+        this.config = yaml.load(fs.readFileSync(this.configPath, 'utf8'));
+    }
+
+    ensureConfigExists() {
+        if (!fs.existsSync(this.configPath)) {
+            fs.mkdirSync(path.dirname(this.configPath), { recursive: true });
+            fs.copyFileSync(this.defaultConfigPath, this.configPath);
+        }
+    }
+
+    getServerOptions(options) {
+        let passed = options || {};
+        Object.apply(passed, this.config.servers?.[this.serverName] || {});
+
+        if (!passed.dir) {
+            if (passed.process_cmd.includes("cd ")) {
+                console.log("Using custom process command:", passed.process_cmd);
+                //detect via regex if cd is used
+                const cdMatch = passed.process_cmd.match(/cd\s+([^\s]+)\s*&&\s*(.*)/);
+                if (cdMatch) {
+                    console.log("Detected 'cd' command in process_cmd:", cdMatch[1]);
+                    passed.dir = cdMatch[1];
+                };
+            };
+        }
+
+        return {
+            //process
+            process_cmd:            passed.process_cmd              || "idk lol",
+            dir:                    passed.dir                      || "",
+            //daily restart
+            dailyrestart_enable:    passed.dailyrestart_enable      || false,
+            dailyrestart_time:      passed.dailyrestart_time        || "4:00",
+            dailyrestart_quickpull: passed.dailyrestart_quickpull,
+            //file logging
+            logfile_enable:         passed.logfile_enable,
+            logfile_location:       passed.logfile_location         || path.join(this.rootDir, "store", "logs", this.serverName), //no editing kek
+            //webhook logging
+            webhook_url:            passed.webhook_url              || "", //false or empty is disabled
+            webhook_username:       passed.webhook_username         || "Webhook", //eg "LegacyShell: Client Server"
+            webhook_avatar:         passed.webhook_avatar           || "https://cdn.onlypuppy7.online/legacyshell/client.png", //eg "https://cdn.onlypuppy7.online/legacyshell/client.png"
+            webhook_ping_user:      passed.webhook_ping_user        || false, //this might flood your shit
+            webhook_ping_role:      passed.webhook_ping_role        || false, //this might flood EVERYONE'S shit
+            //pulling
+            is_puller:              this.config.pullers?.includes(this.serverName) || false,
+        };
+    }
+}

package/src/Logger.js

@@ -0,0 +1,77 @@
+import fs from 'node:fs';
+import fetch from 'node-fetch';
+import { getTimestamp, stripAnsi, divideString, ensureDirExists } from 'puppymisc';
+import log from 'puppylog';
+
+export class Logger {
+    constructor(options) {
+        this.options = options;
+        this.logQueue = [];
+        this.queuedChunks = [];
+        this.maxMessageLength = 1900;
+        this.messagesSent = 0;
+
+        ensureDirExists(options.logfile_location);
+        this.logFilePath = `${options.logfile_location}/${getTimestamp(true)}.log`;
+        ensureDirExists(this.logFilePath);
+    }
+
+    appendLog(msg, noSend = false) {
+        msg = stripAnsi(msg);
+        if (!noSend) this.logQueue.push(msg);
+        fs.appendFile(this.logFilePath, `${msg}\n`, () => {});
+    }
+
+    logSend(msg) {
+        const line = `#${getTimestamp()} ${msg}`;
+        log.muted(line);
+        this.appendLog(line);
+    }
+
+    logNoSend(msg) {
+        const line = `#${getTimestamp()} ${msg}`;
+        log.muted(line);
+        this.appendLog(line, true);
+    }
+
+    async sendToWebhook() {
+        while (this.logQueue.length) {
+            let msg = this.logQueue.shift();
+            if (msg.length > this.maxMessageLength) {
+                this.logQueue.unshift(...divideString(msg, this.maxMessageLength));
+            } else {
+                const lastChunk = this.queuedChunks[0] || "";
+                const newChunk = lastChunk + `\n${msg}`;
+                if (newChunk.length > this.maxMessageLength) {
+                    this.queuedChunks.unshift(`\n${msg}`);
+                } else {
+                    this.queuedChunks[0] = newChunk;
+                }
+            }
+        }
+
+        if (this.queuedChunks.length && this.options.webhook_url) {
+            try {
+                const response = await fetch(this.options.webhook_url, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({
+                        username: this.options.webhook_username,
+                        avatar_url: this.options.webhook_avatar,
+                        content: this.queuedChunks[this.queuedChunks.length - 1].slice(0, 2000),
+                    })
+                });
+                if (!response.ok) throw new Error(response.statusText);
+                this.logNoSend(`Logs sent to webhook (${this.messagesSent})`);
+                this.queuedChunks.pop();
+                this.messagesSent++;
+            } catch (err) {
+                this.logNoSend(`Error sending webhook: ${err.message}`);
+            }
+        }
+    }
+
+    startWebhookInterval(interval = 15000) {
+        this.webhookInterval = setInterval(() => this.sendToWebhook(), interval);
+    }
+}

package/src/ProcessManager.js

@@ -0,0 +1,193 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { spawn } from 'node:child_process';
+import { Worker } from 'node:worker_threads';
+import { getTimestamp } from 'puppymisc';
+
+export class ProcessManager {
+    constructor(options, logger, rootDir) {
+        this.options = options;
+        this.logger = logger;
+        this.rootDir = rootDir;
+
+        this.runningProcess = null;
+        this.restartScheduled = false;
+    }
+
+    async startProcess(purposefulStop = false) {
+        if (this.runningProcess) {
+            this.logger.logSend(`Stopping previous process...`);
+            this.runningProcess.purposefulStop = purposefulStop;
+
+            if (this.runningProcess instanceof Worker) {
+                try {
+                    await this.runningProcess.terminate();
+                } catch (err) {
+                    this.logger.logSend(`Failed to stop previous process via .terminate: ${err.message} ${this.runningProcess}`);
+                }
+            } else {
+                try {
+                    this.runningProcess.kill('SIGINT');
+                    this.logger.logSend(`Stopped previous process via .kill: ${this.runningProcess.pid}`);
+                } catch (err) {
+                    this.logger.logSend(`Failed to stop previous process via .kill: ${err.message} ${this.runningProcess}`);
+                }
+
+                try {
+                    process.kill(-this.runningProcess.pid, 'SIGINT');
+                    this.logger.logSend(`Stopped previous process via process.kill: ${this.runningProcess.pid}`);
+                } catch (err) {
+                    this.logger.logSend(`Failed to stop previous process via process.kill: ${err.message} ${this.runningProcess}`);
+                }
+            }
+        } else {
+            this.logger.logSend(`Starting process: ${this.options.process_cmd}`);
+
+            const useWorkerThreads = true;
+            const isNodeScript = this.options.process_cmd.startsWith('node ');
+            let scriptPath = this.options.process_cmd;
+
+            if (isNodeScript && useWorkerThreads) {
+                // Use Worker Threads for Node.js scripts
+                scriptPath = scriptPath.slice(5).trim();
+                scriptPath = path.isAbsolute(scriptPath) ? scriptPath : path.join(this.rootDir, scriptPath);
+
+                if (!fs.existsSync(scriptPath)) {
+                    this.logger.logSend(`Script file does not exist: ${scriptPath}`);
+                    return;
+                }
+
+                this.logger.logSend(`Using Worker Threads for script: ${scriptPath}`);
+                this.runningProcess = new Worker(scriptPath, { workerData: {}, stdout: true, stderr: true });
+
+                this.runningProcess.stdout.on('data', (data) => {
+                    const lines = data.toString().split('\n').filter(Boolean);
+                    lines.forEach(line => {
+                        const logLine = `${getTimestamp()} ${line}`;
+                        process.stdout.write(`${logLine}\n`);
+                        this.logger.appendLog(logLine);
+                    });
+                });
+
+                this.runningProcess.stderr.on('data', (data) => {
+                    const lines = data.toString().split('\n').filter(Boolean);
+                    lines.forEach(line => {
+                        const logLine = `${getTimestamp()} ERROR: ${line}`;
+                        process.stderr.write(`${logLine}\n`);
+                        this.logger.appendLog(logLine);
+                    });
+                });
+
+                this.runningProcess.on('error', (err) => {
+                    const logLine = `${getTimestamp()} ERROR: ${err.message}`;
+                    process.stderr.write(`${logLine}\n`);
+                    this.logger.appendLog(logLine);
+                });
+
+                this.runningProcess.on('exit', (code, signal) => {
+                    code = code === 57 ? 1337 : code;
+                    if (signal === 'SIGINT') {
+                        this.logger.logSend(`Process terminated manually.`);
+                        return;
+                    }
+
+                    const pingUser = this.options.webhook_ping_user ? ` <@${this.options.webhook_ping_user}>` : "";
+                    const pingRole = this.options.webhook_ping_role ? ` <@&${this.options.webhook_ping_role}>` : "";
+
+                    this.logger.logSend(`Process exited with code ${code}, signal ${signal}. ${(code === 1337 || this.runningProcess.purposefulStop) ? "No ping, intended restart" : `Restarting...${pingUser}${pingRole}`}`);
+
+                    setTimeout(() => {
+                        this.runningProcess = null;
+                        this.startProcess();
+                    }, (code === 1337 || this.runningProcess.purposefulStop) ? 1000 : 5000);
+                });
+
+            } else {
+                this.runningProcess = spawn('bash', ['-c', scriptPath], {
+                    stdio: ['inherit', 'pipe', 'pipe'],
+                    env: { ...process.env, FORCE_COLOR: 'true' },
+                    detached: process.platform !== 'win32',
+                });
+
+                const handleOutput = (data, isError = false) => {
+                    const lines = data.toString().split('\n').filter(Boolean);
+                    lines.forEach(line => {
+                        const logLine = `${getTimestamp()}${isError ? " ERROR:" : ""} ${line}`;
+                        if (isError) process.stderr.write(`${logLine}\n`);
+                        else process.stdout.write(`${logLine}\n`);
+                        this.logger.appendLog(logLine);
+                    });
+                };
+
+                this.runningProcess.stdout.on('data', d => handleOutput(d));
+                this.runningProcess.stderr.on('data', d => handleOutput(d, true));
+
+                const onExit = (code, signal) => {
+                    code = code === 57 ? 1337 : code;
+                    const pingUser = this.options.webhook_ping_user ? ` <@${this.options.webhook_ping_user}>` : "";
+                    const pingRole = this.options.webhook_ping_role ? ` <@&${this.options.webhook_ping_role}>` : "";
+                    this.logger.logSend(`Process exited with code ${code}. ${code === 1337 ? "No ping, intended restart" : `Restarting...${pingUser}${pingRole}`}`);
+                    setTimeout(() => {
+                        this.runningProcess = null;
+                        this.startProcess();
+                    }, (code === 1337 || signal === 'SIGINT') ? 1000 : 5000);
+                };
+
+                this.runningProcess.on('exit', (code, signal) => {
+                    this.logger.logSend(`Process exited with code ${code}, signal ${signal}.`);
+                    onExit(code, signal);
+                });
+            }
+        }
+    }
+
+    autoRestart() {
+        if (!this.options.dailyrestart_enable) return;
+        if (this.restartScheduled) {
+            this.logger.logSend("Restart already scheduled.");
+            return;
+        }
+
+        const now = new Date();
+        const [hour, minute] = this.options.dailyrestart_time.split(':').map(Number);
+        const nextRestart = new Date();
+        nextRestart.setHours(hour, minute, 0, 0);
+        if (nextRestart < now) nextRestart.setDate(nextRestart.getDate() + 1);
+
+        let timeUntilRestart = nextRestart - now;
+        if (timeUntilRestart <= 0) timeUntilRestart += 24*60*60*1000;
+
+        this.logger.logSend(`Scheduled restart in ${Math.floor(timeUntilRestart / 1000 / 60)} minutes.`);
+        this.restartScheduled = true;
+
+        setTimeout(async () => {
+            if (this.options.dailyrestart_quickpull) {
+                this.logger.logSend("Quick-pulling before restart.");
+                this.executeCommand('git', ['pull'], 'ignore');
+            }
+            this.logger.logSend("Auto-restarting process.");
+            await this.startProcess();
+            this.restartScheduled = false;
+            this.autoRestart();
+        }, timeUntilRestart);
+    }
+
+    executeCommand(command, args, stdio = "inherit") {
+        let dir = this.options.dir || "";
+
+        console.log(dir, this.options.dir);
+
+        const cmdProcess = spawn(command, args, {
+            stdio,
+            cwd: this.options.dir && this.options.dir !== "" && dir,
+        });
+    
+        cmdProcess.on('exit', (code) => {
+            if (stdio !== 'ignore') console.log(`${command} exited with code: ${code}`);
+        });
+    
+        cmdProcess.on('error', (err) => {
+            console.error(`Failed to start ${command}:`, err);
+        });
+    }
+}

package/src/defaultconfig.yaml

@@ -0,0 +1,23 @@
+#which should be the ones to do pulls?
+pullers: ["default"] #default: ["default"]
+
+# config for how you want the files to continually run. setup for error notifications on discord!
+# the options are the same for all, but you can configure each differently.
+default: #example
+  process_cmd: "node src/test.js" #dont touch unless u changed the path
+  dir: ""
+
+  #daily restarts, at specified time every day
+  dailyrestart_enable: true
+  dailyrestart_time: "4:00" # HH:MM (24 hours)
+  dailyrestart_quickpull: false #if true, will pull before restarting
+
+  #logfiles
+  logfile_enable: true
+
+  #webhook logging
+  webhook_url: "" #empty disables it
+  webhook_username: "Test!"
+  webhook_avatar: "https://cdn.onlypuppy7.online/legacyshell/client.png"
+  webhook_ping_user: "514778439018872842" #ENTER THE USER ID. for when there is an error. empty = no ping.
+  webhook_ping_role: "1221557010651418705" #ENTER THE ROLE ID. for when there is an error. empty = no ping.

package/src/index.js

@@ -0,0 +1,47 @@
+import path from 'node:path';
+import { ConfigManager } from './ConfigManager.js';
+import { Logger } from './Logger.js';
+import { ProcessManager } from './ProcessManager.js';
+import readline from 'node:readline';
+
+export class Perpetual {
+    constructor(serverName, options) {
+        const rootDir = options.rootDir || path.resolve('./');
+        this.configManager = new ConfigManager(rootDir, serverName);
+        this.options = this.configManager.getServerOptions(options);
+        this.logger = new Logger(this.options);
+        this.processManager = new ProcessManager(this.options, this.logger, rootDir);
+    }
+
+    async run() {
+        if (this.options.webhook_url) this.logger.startWebhookInterval();
+        await this.processManager.startProcess();
+
+        const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout,
+            prompt: '> '
+        });
+
+        rl.prompt();
+        rl.on('line', async (line) => {
+            let cmd = line.trim();
+            if (cmd === "r" || cmd === "restart") {
+                await this.processManager.startProcess(true);
+            } else if (cmd === "p" || cmd === "pull") {
+                this.processManager.executeCommand('git', ['pull']);
+            } else if (cmd === "pr") { // pull and restart
+                this.processManager.executeCommand('git', ['pull']);
+                setTimeout(() => {
+                    this.processManager.startProcess(true);
+                }, 5e3);
+            };
+            rl.prompt();
+        }).on('close', () => {
+            console.log('Exiting interactive mode!');
+            process.exit(0);
+        });
+    }
+}
+
+export default Perpetual;

package/src/test/test.js

@@ -0,0 +1,7 @@
+import Perpetual from '../index.js';
+
+const perpetual = new Perpetual('test_process', {
+    // process_cmd: 'node ./src/test/test_process.js',
+    process_cmd: 'date',
+})
+await perpetual.run();

package/src/test/test_process.js

@@ -0,0 +1,10 @@
+import log from 'puppylog';
+
+(async () => {
+    let count = 0;
+    while (true) {
+        log.success("Hello, world!", count++);
+        if (count == 10) throw new Error("Test error to check error handling");
+        await new Promise(resolve => setTimeout(resolve, 1000));
+    };
+})();

package/.gitattributes

@@ -1,2 +0,0 @@
-# Auto detect text files and perform LF normalization
-* text=auto