fscr 6.2.6 → 7.3.0

package/dist/lib/test-files/.fscriptsb.md

@@ -0,0 +1,107 @@
+<!-- toc -->
+
+- [Build](#build)
+  * [v:publish](#vpublish)
+  * [script:js](#scriptjs)
+- [Groups2](#groups2)
+  * [console:js](#consolejs)
+  * [input:js-](#inputjs-)
+  * [log:much:js](#logmuchjs)
+
+<!-- tocstop -->
+
+# Build
+
+Build group description
+
+## v:publish
+
+Update v and push
+
+```bash
+sh publish.sh
+```
+
+## script:js
+
+```js
+const chalk = require("chalk");
+console.log(`${chalk.underline.bold("RUNS JS\n\nt")}`);
+```
+
+# Groups2
+
+That darn second group!!!!!
+           
+## console:js
+
+Only one script here with bash
+
+```bash
+node src/sampleScripts/exampleLogTimeout.js
+```
+
+## input:js-
+
+Get some input from user
+
+```bash
+node src/sampleScripts/exampleInput.js
+```
+
+## log:much:js
+
+Basically logs till yo momma says stop!
+
+```js
+const chalk = require("chalk");
+const sample = arr => arr[Math.floor(Math.random() * arr.length)];
+const quotes = [
+    "The trickster's functiowhat they reslly s function is to break taboos, create mischief, stir things up. In the end, the trickster gives people what they res function is to break taboos, create mischief, stir things up. In the end, the trickster gives people what they rewant, some sort of freedom. - Tom Robbins",
+    '"Disbelief in magic can  really s function is to break taboos, create mischief, stir things up. In the end, the trickster gives people what they res function is to break taboos, create mischief, stir things up. In the end, the trickster gives people what they rewant, some sort of freedom. - Tom Robbins",\n' +
+        '    "Disbelief in magic can force a poor soul into believing in government and business. - Tom Robbins',
+    'The trouble with the fasforce a poor soul into believing in government and business. - Tom Robbins",\n' +
+        '    "The trouble with the fasforce a poor soul into believing in government and business. - Tom Robbins",\n' +
+        '    "The trouble with the fast lane is that all the movement is horizontal. And I like to go vertical sometimes. - Tom Robbins',
+    "Our world isn't made of earth, air and water or even molecules and atoms; our world is made of language. - Tom Robbimade of earth, air and water or even molecules and atoms; our world is made of language. - Tom Robbins",
+    "I'm not infatuated with frivoith frivoith frivoith frivoith frivoith frivoith frivoith frivolousness. We're just good friends. - Tom Robbins",
+    "In fiction, when you paint yourself into a corner, you can write a pair of suction cups onto the bottoms of your shoes and walk up the wall and out the skylight and see the sun breaking through the clouds. In nonfiction, you don't have that luxury. - Tom Robbins"
+];
+let sxy;
+const getOption = st => {
+    // if (Math.random() > 0.5) {
+    //     st = st + sample(quotes) + sample(quotes) + sample(quotes);
+    // }
+    let options = [
+        chalk.blue(st),
+        chalk.underline.green(st),
+        chalk.green.bgRed.bold(st),
+        chalk.blue(st, st, st, st),
+        chalk.red(st, chalk.underline.bgBlue(st) + st)
+    ];
+    return sample(options);
+};
+let isMil = 0;
+const theRun = async () => {
+    return new Promise(resolve => {
+        sxy = setInterval(() => {
+            const qt = sample(quotes);
+            console.log(new Date() + " ------- ----- ---- \n");
+            console.log(getOption(qt));
+            console.log(new Date() + " ------- ----- ---- \n");
+            console.log("----- ---- \n");
+            console.log("----- ---- \n");
+            console.log("----- ---- \n");
+            if (isMil === 30) {
+            	clearInterval(sxy);
+            	console.log("DONE DONE DONE");
+            	resolve();
+            } else {
+                isMil += 10;
+            }
+        }, 1000);
+    });
+};
+
+theRun();
+```

package/dist/lib/test-files/.mdtest.md

@@ -0,0 +1,40 @@
+# First category of scripts
+
+ Welcome to your new amazing .fscripts.md file. It replaces the headaches of npm scripts! But so much more.
+
+
+## fsr
+
+TBD
+
+```bash
+node bin/run
+```
+
+
+## fsr:d
+
+TBD
+
+```bash
+DEBUG=* node bin/run
+```
+
+
+## deploy
+
+TBD
+
+```bash
+node src/utils/release/publish.js
+```
+
+
+## pretty
+
+TBD
+
+```bash
+prettier src/*.js --write
+```
+

package/dist/lib/test-files/consoleSample.js

@@ -1,13 +1,17 @@
 import chalk from "chalk";
 import yargs from "yargs";
 const argv = yargs(process.argv.slice(2)).argv;
+
 (async function () {
-  console.log(`${chalk.green("PRE --- TEST 52")} ${process.argv.slice(2)} ${JSON.stringify(argv)}`);
-  await new Promise(resolve => {
-    setTimeout(() => {
-      console.log(`${chalk.green("ATTT --- TEST 52")}`);
-      resolve();
-    }, 3500);
-  });
-  console.log(`${chalk.green("POST --- TEST 52")}`);
-})();
+    console.log(
+        `${chalk.green("PRE --- TEST 52")} ${process.argv.slice(2)} ${JSON.stringify(argv)}`
+    );
+
+    await new Promise((resolve) => {
+        setTimeout(() => {
+            console.log(`${chalk.green("ATTT --- TEST 52")}`);
+            resolve();
+        }, 3500);
+    });
+    console.log(`${chalk.green("POST --- TEST 52")}`);
+})();

package/dist/lib/test-files/inputSample.js

@@ -1,17 +1,20 @@
 import chalk from "chalk";
 import inquirer from "inquirer";
+
 (async function () {
-  console.log(`${chalk.green("PRE INPUT")}\n`);
-  inquirer.prompt([{
-    type: "list",
-    name: "category",
-    message: "What category do you want to run?",
-    choices: [1, 2, 3, 4, 5]
-  }]).then(({
-    category
-  }) => {
-    console.log(`${chalk.green("CHOSEN ", category)}`);
-  });
-  console.log(`${chalk.green("POST INPUT")}`);
-  console.log("NODEENV", process.env.INPUT);
-})();
+    console.log(`${chalk.green("PRE INPUT")}\n`);
+    inquirer
+        .prompt([
+            {
+                type: "list",
+                name: "category",
+                message: "What category do you want to run?",
+                choices: [1, 2, 3, 4, 5]
+            }
+        ])
+        .then(({ category }) => {
+            console.log(`${chalk.green("CHOSEN ", category)}`);
+        });
+    console.log(`${chalk.green("POST INPUT")}`);
+    console.log("NODEENV", process.env.INPUT);
+})();

package/dist/lib/test-files/testConsole.js

@@ -1 +1 @@
-console.log("TEST CONSOLE OUTPUT");
+console.log("TEST CONSOLE OUTPUT");

package/dist/lib/test-files/testInput.js

@@ -1,2 +1,2 @@
 const input = process.env.INPUT || 'default';
-console.log(`INPUT: ${input}`);
+console.log(`INPUT: ${input}`);

package/dist/lib/upgradePackages.js

@@ -6,60 +6,70 @@ import { fileURLToPath } from "url";
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 const logError = message => {
-  console.log(chalk.red("[Error]: " + message));
+    console.log(chalk.red("[Error]: " + message));
 };
 const logInfo = message => {
-  console.log(chalk.blue("[Start]: " + message));
+    console.log(chalk.blue("[Start]: " + message));
 };
 const logSuccess = message => {
-  console.log(chalk.green("[Done]: " + message));
+    console.log(chalk.green("[Done]: " + message));
 };
+
 let global = "";
 let packagePath = path.resolve(process.cwd(), "package.json");
-if (!fs.existsSync(packagePath)) {
-  logError("Cannot find package.json file in the current directory");
-  process.exit(1);
-}
-const packageJson = JSON.parse(fs.readFileSync(packagePath, "utf-8"));
-let ignorePkgs = [];
+
 const upgradePackages = async () => {
-  if (packageJson["fscripts"]) {
-    if (packageJson["fscripts"]["ignore-upgrade"]) {
-      ignorePkgs = packageJson["fscripts"]["ignore-upgrade"];
+    // Read package.json lazily so importing this module never crashes in a dir without one.
+    if (!fs.existsSync(packagePath)) {
+        logError("Cannot find package.json file in the current directory");
+        process.exit(1);
     }
-  }
-  let upgraded = {
-    before: {},
-    after: {}
-  };
-  for (let element of ["dependencies", "devDependencies", "peerDependencies"]) {
-    if (packageJson[element]) {
-      const packages = Object.keys(packageJson[element]);
-      let packagesList = packages.filter(pkk => !ignorePkgs.includes(pkk)).map(pkk => {
-        upgraded["before"][pkk] = packageJson[element][pkk];
-        return pkk + "@latest";
-      }).join(" ");
-      let command = `yarn add ${packagesList}`;
-      try {
-        // logInfo(command);
-        childProcess.execSync(command, {
-          stdio: "inherit",
-          env: Object.assign({}, process.env, {
-            FORCE_COLOR: true,
-            PATH: `${path.resolve("node_modules")}:${process.env.PATH}`
-          })
-        });
-        const packageJsonAfter = JSON.parse(fs.readFileSync(packagePath));
-        const packagesAfter = Object.keys(packageJsonAfter[element]);
-        let packagesListAfter = packagesAfter.filter(pkk => !ignorePkgs.includes(pkk)).map(pkk => {
-          upgraded["after"][pkk] = packageJsonAfter[element][pkk];
-          return upgraded["before"][pkk] !== upgraded["after"][pkk] ? `Updated: ${pkk} from: ${upgraded["before"][pkk]} | to: ${upgraded["after"][pkk]}\n` : ``;
-        }).join("");
-        logSuccess(packagesListAfter);
-      } catch (e) {
-        logError(`${command} - ${e}`);
-      }
+    const packageJson = JSON.parse(fs.readFileSync(packagePath, "utf-8"));
+    let ignorePkgs = [];
+    if (packageJson["fscripts"]) {
+        if (packageJson["fscripts"]["ignore-upgrade"]) {
+            ignorePkgs = packageJson["fscripts"]["ignore-upgrade"];
+        }
+    }
+    let upgraded = { before: {}, after: {} };
+    for (let element of ["dependencies", "devDependencies", "peerDependencies"]) {
+        if (packageJson[element]) {
+            const packages = Object.keys(packageJson[element]);
+            let packagesList = packages
+                .filter(pkk => !ignorePkgs.includes(pkk))
+                .map(pkk => {
+                    upgraded["before"][pkk] = packageJson[element][pkk];
+                    return pkk + "@latest";
+                })
+                .join(" ");
+            let command = `yarn add ${packagesList}`;
+            try {
+                // logInfo(command);
+                childProcess.execSync(command, {
+                    stdio: "inherit",
+                    env: Object.assign({}, process.env, {
+                        FORCE_COLOR: true,
+                        PATH: `${path.resolve("node_modules")}:${process.env.PATH}`
+                    })
+                });
+                const packageJsonAfter = JSON.parse(fs.readFileSync(packagePath));
+                const packagesAfter = Object.keys(packageJsonAfter[element]);
+                let packagesListAfter = packagesAfter
+                    .filter(pkk => !ignorePkgs.includes(pkk))
+                    .map(pkk => {
+                        upgraded["after"][pkk] = packageJsonAfter[element][pkk];
+                        return upgraded["before"][pkk] !== upgraded["after"][pkk]
+                            ? `Updated: ${pkk} from: ${upgraded["before"][pkk]} | to: ${
+                                  upgraded["after"][pkk]
+                              }\n`
+                            : ``;
+                    })
+                    .join("");
+                logSuccess(packagesListAfter);
+            } catch (e) {
+                logError(`${command} - ${e}`);
+            }
+        }
     }
-  }
 };
-export default upgradePackages;
+export default upgradePackages;

package/dist/lib/utils/clear.js

@@ -3,16 +3,19 @@
  * @param opts pass true to fully clear
  */
 export default function clear(opts) {
-  if (typeof opts === "boolean") {
-    opts = {
-      fullClear: opts
-    };
-  }
-  opts = opts || {};
-  opts.fullClear = opts.hasOwnProperty("fullClear") ? opts.fullClear : true;
-  if (opts.fullClear === true) {
-    process.stdout.write("\x1b[2J");
-  }
-  process.stdout.write("\x1b[0f");
-}
-;
+    if (typeof opts === "boolean") {
+        opts = {
+            fullClear: opts
+        };
+    }
+
+    opts = opts || {};
+
+    opts.fullClear = opts.hasOwnProperty("fullClear") ? opts.fullClear : true;
+
+    if (opts.fullClear === true) {
+        process.stdout.write("\x1b[2J");
+    }
+
+    process.stdout.write("\x1b[0f");
+};

package/dist/lib/utils/console.js

@@ -1,33 +1,39 @@
 import { timestamp } from "./helpers.js";
 import chalk from "chalk";
+
 const d = timestamp();
+
 const colors = {
-  Reset: "\x1b[0m",
-  Red: "\x1b[31m",
-  Green: "\x1b[32m",
-  Yellow: "\x1b[33m"
+    Reset: "\x1b[0m",
+    Red: "\x1b[31m",
+    Green: "\x1b[32m",
+    Yellow: "\x1b[33m"
 };
+
 const infoLog = console.info;
 const logLog = console.log;
 const warnLog = console.warn;
 const errorLog = console.error;
-console.log = function (args) {
-  const copyArgs = Array.prototype.slice.call(arguments);
-  copyArgs.unshift(`${chalk.gray(d)} ${chalk.gray.bold("[LOG]")}️`);
-  infoLog.apply(null, copyArgs);
+
+console.log = function(args) {
+    const copyArgs = Array.prototype.slice.call(arguments);
+    copyArgs.unshift(`${chalk.gray(d)} ${chalk.gray.bold("[LOG]")}️`);
+    infoLog.apply(null, copyArgs);
 };
-console.info = function (args) {
-  const copyArgs = Array.prototype.slice.call(arguments);
-  copyArgs.unshift(`${chalk.gray(d)} ${chalk.blue.bold("i [INFO]")}️`);
-  infoLog.apply(null, copyArgs);
+console.info = function(args) {
+    const copyArgs = Array.prototype.slice.call(arguments);
+    copyArgs.unshift(`${chalk.gray(d)} ${chalk.blue.bold("i [INFO]")}️`);
+    infoLog.apply(null, copyArgs);
 };
-console.warn = function (args) {
-  const copyArgs = Array.prototype.slice.call(arguments);
-  copyArgs.unshift(`${chalk.gray(d)} ${chalk.yellow.bold("⚠ [WARN]")}️`);
-  warnLog.apply(null, copyArgs);
+
+console.warn = function(args) {
+    const copyArgs = Array.prototype.slice.call(arguments);
+    copyArgs.unshift(`${chalk.gray(d)} ${chalk.yellow.bold("⚠ [WARN]")}️`);
+    warnLog.apply(null, copyArgs);
+};
+
+console.error = function(args) {
+    const copyArgs = Array.prototype.slice.call(arguments);
+    copyArgs.unshift(`${chalk.gray(d)} ${chalk.red.bold("× [ERROR]")}️`);
+    warnLog.apply(null, copyArgs);
 };
-console.error = function (args) {
-  const copyArgs = Array.prototype.slice.call(arguments);
-  copyArgs.unshift(`${chalk.gray(d)} ${chalk.red.bold("× [ERROR]")}️`);
-  warnLog.apply(null, copyArgs);
-};

package/dist/lib/utils/encryption.js

@@ -1,18 +1,60 @@
 import crypto from "crypto";
-const algorithm = "aes-192-cbc";
-const iv = Buffer.alloc(16, 0); // Initialization vector.
+
+// OpenSSL / CryptoJS-compatible AES-256-CBC.
+// Output format matches `CryptoJS.AES.encrypt(text, password).toString()` and
+// `openssl enc -aes-256-cbc -salt -base64`: base64("Salted__" + 8-byte salt + ciphertext).
+const algorithm = "aes-256-cbc";
+const MAGIC = Buffer.from("Salted__", "utf8");
+
+// OpenSSL EVP_BytesToKey (MD5) key+IV derivation from password + salt.
+const deriveKeyIv = (password, salt) => {
+    const pass = Buffer.from(password, "utf8");
+    let data = Buffer.alloc(0);
+    let block = Buffer.alloc(0);
+    while (data.length < 48) {
+        // 32-byte key + 16-byte IV
+        block = crypto.createHash("md5").update(Buffer.concat([block, pass, salt])).digest();
+        data = Buffer.concat([data, block]);
+    }
+    return { key: data.subarray(0, 32), iv: data.subarray(32, 48) };
+};
+
 const encrypt = (toEncrypt, password) => {
-  const key = crypto.scryptSync(password, "salt", 24);
-  const cipher = crypto.createCipheriv(algorithm, key, iv);
-  let encrypted = cipher.update(toEncrypt, "utf8", "hex");
-  encrypted += cipher.final("hex");
-  return encrypted;
+    const salt = crypto.randomBytes(8);
+    const { key, iv } = deriveKeyIv(password, salt);
+    const cipher = crypto.createCipheriv(algorithm, key, iv);
+    const ciphertext = Buffer.concat([
+        cipher.update(Buffer.from(toEncrypt, "utf8")),
+        cipher.final()
+    ]);
+    return Buffer.concat([MAGIC, salt, ciphertext]).toString("base64");
+};
+
+const decryptLegacy = (toDecrypt, password) => {
+    const key = crypto.scryptSync(password, "salt", 24);
+    const iv = Buffer.alloc(16, 0);
+    const decipher = crypto.createDecipheriv("aes-192-cbc", key, iv);
+    let decrypted = decipher.update(String(toDecrypt).trim(), "hex", "utf8");
+    decrypted += decipher.final("utf8");
+    return decrypted;
 };
+
 const decrypt = (toDecrypt, password) => {
-  const key = crypto.scryptSync(password, "salt", 24);
-  const decipher = crypto.createDecipheriv(algorithm, key, iv);
-  let decrypted = decipher.update(toDecrypt, "hex", "utf8");
-  decrypted += decipher.final("utf8");
-  return decrypted;
+    const raw = String(toDecrypt).trim();
+    const data = Buffer.from(raw, "base64");
+    if (!data.subarray(0, 8).equals(MAGIC)) {
+        // legacy format: hex-encoded AES-192-CBC
+        return decryptLegacy(raw, password);
+    }
+    const salt = data.subarray(8, 16);
+    const ciphertext = data.subarray(16);
+    const { key, iv } = deriveKeyIv(password, salt);
+    const decipher = crypto.createDecipheriv(algorithm, key, iv);
+    try {
+        return Buffer.concat([decipher.update(ciphertext), decipher.final()]).toString("utf8");
+    } catch (e) {
+        throw new Error("Decryption failed — wrong password or corrupted file");
+    }
 };
-export { decrypt, encrypt };
+
+export { decrypt, encrypt };

package/dist/lib/utils/hash.js

@@ -0,0 +1,128 @@
+/**
+ * Hash utilities for cache key generation
+ * @module utils/hash
+ */
+
+import { createHash } from 'crypto';
+import { statSync } from 'fs';
+
+/**
+ * Generate a SHA-256 hash from a string
+ * @param {string} input - Input string
+ * @param {number} [length=16] - Output length (characters)
+ * @returns {string} Hash string
+ */
+export function hash(input, length = 16) {
+    return createHash('sha256')
+        .update(input)
+        .digest('hex')
+        .substring(0, length);
+}
+
+/**
+ * Generate a hash from multiple inputs
+ * @param {...string} inputs - Input strings
+ * @returns {string} Combined hash
+ */
+export function hashMultiple(...inputs) {
+    const combined = inputs.join(':');
+    return hash(combined);
+}
+
+/**
+ * Generate a cache key from file path and metadata
+ * @param {string} filePath - File path
+ * @param {Object} [options] - Additional options
+ * @param {boolean} [options.includeMtime=true] - Include modification time
+ * @param {boolean} [options.includeSize=false] - Include file size
+ * @returns {string} Cache key
+ */
+export function generateFileKey(filePath, options = {}) {
+    const includeMtime = options.includeMtime !== false;
+    const includeSize = options.includeSize || false;
+
+    try {
+        const stats = statSync(filePath);
+        const parts = [filePath];
+
+        if (includeMtime) {
+            parts.push(stats.mtimeMs.toString());
+        }
+
+        if (includeSize) {
+            parts.push(stats.size.toString());
+        }
+
+        return hash(parts.join(':'));
+    } catch (error) {
+        throw new Error(`Failed to generate file key for ${filePath}: ${error.message}`);
+    }
+}
+
+/**
+ * Generate a cache key from an object
+ * @param {Object} obj - Object to hash
+ * @returns {string} Cache key
+ */
+export function hashObject(obj) {
+    const str = JSON.stringify(obj, Object.keys(obj).sort());
+    return hash(str);
+}
+
+/**
+ * Generate a cache key from file path and content hash
+ * @param {string} filePath - File path
+ * @param {string} content - File content
+ * @returns {string} Cache key
+ */
+export function generateContentKey(filePath, content) {
+    const contentHash = hash(content);
+    return hash(`${filePath}:${contentHash}`);
+}
+
+/**
+ * Get file metadata for cache validation
+ * @param {string} filePath - File path
+ * @returns {Object} File metadata
+ */
+export function getFileMetadata(filePath) {
+    try {
+        const stats = statSync(filePath);
+        return {
+            mtime: stats.mtimeMs,
+            size: stats.size,
+            exists: true
+        };
+    } catch (error) {
+        return {
+            mtime: null,
+            size: null,
+            exists: false
+        };
+    }
+}
+
+/**
+ * Check if file has changed based on metadata
+ * @param {string} filePath - File path
+ * @param {number} cachedMtime - Cached modification time
+ * @returns {boolean} True if file has changed
+ */
+export function hasFileChanged(filePath, cachedMtime) {
+    try {
+        const stats = statSync(filePath);
+        return stats.mtimeMs !== cachedMtime;
+    } catch {
+        return true; // Consider changed if file doesn't exist
+    }
+}
+
+export default {
+    hash,
+    hashMultiple,
+    hashObject,
+    generateFileKey,
+    generateContentKey,
+    getFileMetadata,
+    hasFileChanged
+};