fscr 6.2.3 → 7.3.0

package/dist/lib/plugins/deployment/index.js

@@ -0,0 +1,113 @@
+import promptQuestion from "../../utils/prompt.js";
+import fcFilepicker1 from "fc-filepick";
+import { spawn } from "child_process";
+
+const fcFilepicker = fcFilepicker1.default;
+
+/**
+ * Deploy
+ * @param files
+ * @param subdomain
+ * @param ctx
+ * @returns {Promise<unknown>}
+ */
+const deployExec = async (files, subdomain, ctx) => {
+    const domain = `${subdomain}.surge.sh`;
+    ctx.logger.info(`Deploying ${files} → ${domain}`);
+    return await new Promise((resolve, reject) => {
+        const cmd = spawn("npx", ["surge", files, domain], { stdio: "inherit", shell: false });
+        cmd.on("close", (code) => {
+            if (code !== 0) reject(new Error(`surge exited with code ${code}`));
+            else resolve();
+        });
+    });
+};
+export default {
+    name: "deployment",
+    version: "1.0.0",
+    description: "Deploy your application to various environments",
+    author: "FSCR Team",
+    minFscrVersion: "7.0.0",
+    tags: ["deployment", "devops"],
+
+    async init(context) {
+        const deploymentHistory = [];
+
+        // Post-deployment tracking
+        context.registerHook("post-command", async (data) => {
+            if (data.command === "deploy") {
+                deploymentHistory.push({
+                    timestamp: data.timestamp,
+                    success: data.success,
+                    duration: data.duration
+                });
+
+                context.setStorage({ deploymentHistory });
+            }
+        });
+
+        // Register deploy command
+        context.registerCommand({
+            name: "deploy",
+            description: "Deploy to a specific surge domain",
+            aliases: ["ship", "publish"],
+            options: [
+                {
+                    flags: "--files",
+                    description: "Location of files to publish"
+                },
+                {
+                    flags: "--subdomain",
+                    description: "What is the surge.sh subdomain"
+                }
+            ],
+            handler: async (options, ctx) => {
+                const files = options.files;
+                const subdomain = options.subdomain;
+
+                if (!files || !subdomain) {
+                    ctx.logger.error("Usage: fsr deploy --files <path> --subdomain <name>");
+                    return;
+                }
+
+                await deployExec(files, subdomain, ctx);
+            },
+            examples: [
+                "fsr deploy --files ./dist",
+                "fsr deploy --files ./dist --subdomain angel-test-5252"
+            ]
+        });
+
+        // Register deployment history command
+        context.registerCommand({
+            name: "deploy-history",
+            description: "View deployment history",
+            handler: async (options, ctx) => {
+                if (deploymentHistory.length === 0) {
+                    ctx.logger.info("No deployment history");
+                    return;
+                }
+
+                ctx.logger.info("Recent Deployments:");
+                ctx.logger.info("─".repeat(60));
+
+                const recent = deploymentHistory.slice(-10);
+                for (const record of recent) {
+                    const status = record.success ? "✓" : "✗";
+                    const date = new Date(record.timestamp).toLocaleString();
+                    ctx.logger.info(`${status} ${date} (${record.duration}ms)`);
+                }
+
+                ctx.logger.info("─".repeat(60));
+            },
+            examples: ["fsr deploy-history"]
+        });
+
+        context.logger.success("Deployment plugin initialized");
+    },
+    async run(ctx) {
+        const r = await promptQuestion({}, "Subdomain?");
+        const folder = await fcFilepicker({ type: "folder" });
+        await deployExec(folder, r, ctx);
+    }
+};

package/dist/lib/plugins/hooks.js

@@ -0,0 +1,17 @@
+const registry = new Map();
+
+export const registerHook = (name, fn) => {
+    if (!registry.has(name)) registry.set(name, []);
+    registry.get(name).push(fn);
+};
+
+export const fireHook = async (name, data) => {
+    const handlers = registry.get(name) ?? [];
+    for (const fn of handlers) {
+        try {
+            await fn(data);
+        } catch (err) {
+            console.error(`[hook:${name}] ${err.message}`);
+        }
+    }
+};

package/dist/lib/plugins/loader.js

@@ -0,0 +1,91 @@
+import { readdirSync, existsSync } from "fs";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+import chalk from "chalk";
+import { registerHook, fireHook } from "./hooks.js";
+
+const pluginsDir = join(dirname(fileURLToPath(import.meta.url)));
+
+const logger = {
+    info: (msg) => console.log(chalk.cyan(msg)),
+    success: (msg) => console.log(chalk.green(msg)),
+    error: (msg) => console.error(chalk.red(msg)),
+    warn: (msg) => console.warn(chalk.yellow(msg)),
+};
+
+export const loadPlugins = async () => {
+    const commands = [];
+
+    let entries;
+    try {
+        entries = readdirSync(pluginsDir, { withFileTypes: true });
+    } catch {
+        return commands;
+    }
+
+    const dirs = entries.filter((e) => e.isDirectory());
+
+    const runnablePlugins = [];
+
+    for (const dir of dirs) {
+        const entryPath = join(pluginsDir, dir.name, "index.js");
+        if (!existsSync(entryPath)) continue;
+
+        try {
+            const { default: plugin } = await import(entryPath);
+            if (!plugin?.init) continue;
+
+            const context = {
+                logger,
+                registerHook,
+                registerCommand: (def) => commands.push(def),
+            };
+
+            await plugin.init(context);
+
+            if (typeof plugin.run === "function") {
+                runnablePlugins.push({ name: plugin.name || dir.name, description: plugin.description || "", run: () => plugin.run({ logger }) });
+            }
+        } catch (err) {
+            logger.error(`[plugin:${dir.name}] Failed to load: ${err.message}`);
+        }
+    }
+
+    return { commands, runnablePlugins };
+};
+
+export const registerPluginCommands = (yargsInstance, commands) => {
+    for (const cmd of commands) {
+        yargsInstance = yargsInstance.command(
+            cmd.name,
+            cmd.description || "",
+            (yargs) => {
+                for (const opt of cmd.options || []) {
+                    const long = opt.flags.match(/--([a-z-]+)/)?.[1];
+                    const short = opt.flags.match(/-([a-z])[^-]/)?.[1];
+                    if (!long) continue;
+                    yargs.option(long, {
+                        alias: short,
+                        description: opt.description,
+                        type: opt.type || "string",
+                    });
+                }
+            },
+            async (argv) => {
+                const start = Date.now();
+                try {
+                    await cmd.handler(argv, { logger });
+                    await fireHook("post-task", { taskName: cmd.name, duration: Date.now() - start, success: true });
+                } catch (err) {
+                    await fireHook("task-error", { taskName: cmd.name, duration: Date.now() - start, error: err });
+                    throw err;
+                }
+            }
+        );
+
+        for (const ex of cmd.examples || []) {
+            yargsInstance = yargsInstance.example(ex, "");
+        }
+    }
+    return yargsInstance;
+};

package/dist/lib/plugins/task-notifier/index.js

@@ -0,0 +1,72 @@
+/**
+ * Task Notifier Plugin
+ * Send notifications when tasks complete
+ */
+
+export default {
+    name: "task-notifier",
+    version: "1.0.0",
+    description: "Send desktop notifications for task completion",
+    author: "FSCR Team",
+    tags: ["notifications", "productivity"],
+
+    async init(context) {
+        let notificationsEnabled = true;
+
+        // Hook into task completion
+        context.registerHook("post-task", async (data) => {
+            if (!notificationsEnabled) return;
+
+            const title = data.success
+                ? `✓ Task Completed: ${data.taskName}`
+                : `✗ Task Failed: ${data.taskName}`;
+
+            const message = `Duration: ${(data.duration / 1000).toFixed(2)}s`;
+
+            // In real implementation, use a notification library
+            context.logger.info(`[Notification] ${title} - ${message}`);
+            console.log("TASK", title);
+        });
+
+        // Hook into errors
+        context.registerHook("task-error", async (data) => {
+            if (!notificationsEnabled) return;
+
+            context.logger.error(
+                `[Notification] ✗ Task Error: ${data.taskName}\n${data.error.message}`
+            );
+        });
+
+        // Register notification control commands
+        context.registerCommand({
+            name: "notify",
+            description: "Control task notifications",
+            options: [
+                { flags: "-e, --enable", description: "Enable notifications", type: "boolean" },
+                { flags: "-d, --disable", description: "Disable notifications", type: "boolean" },
+                { flags: "-s, --status", description: "Show notification status", type: "boolean" }
+            ],
+            handler: async (options, ctx) => {
+                if (options.enable) {
+                    notificationsEnabled = true;
+                    ctx.logger.success("Notifications enabled");
+                } else if (options.disable) {
+                    notificationsEnabled = false;
+                    ctx.logger.info("Notifications disabled");
+                } else if (options.status) {
+                    const status = notificationsEnabled ? "enabled" : "disabled";
+                    ctx.logger.info(`Notifications are ${status}`);
+                } else {
+                    ctx.logger.info("Usage: fsr notify [--enable|--disable|--status]");
+                }
+            },
+            examples: [
+                "fsr notify --enable",
+                "fsr notify --disable",
+                "fsr notify --status"
+            ]
+        });
+
+        context.logger.success("Task Notifier plugin initialized");
+    }
+};

package/dist/lib/release/bump.js

@@ -4,49 +4,57 @@ import prompt from "../utils/prompt.js";
 import fs from "fs";
 let packagePath = path.resolve(process.cwd(), "package.json");
 import { execSync } from "child_process";
-const runAsync = async command => {
-  return execSync(command);
+
+const runAsync = async (command) => {
+    return execSync(command);
 };
-if (!fs.existsSync(packagePath)) {
-  console.error("Cannot find package.json file in the current directory");
-  process.exit(1);
-}
-const bump = async (typeParam = null) => {
-  let type = "patch";
-  if (!typeParam) {
-    type = await prompt({
-      type: "list",
-      message: chalk.green.bold.underline("How big of a bump is this?"),
-      choices: ["patch", "minor", "major"]
-    });
-  } else {
-    type = typeParam;
-  }
-  let gitTag = await prompt({
-    type: "confirm",
-    message: chalk.green.bold.underline("Add git tag?"),
-    default: false
-  });
-  await runAsync(`yarn version --${type} ${gitTag ? "--no-git-tag-version" : ""} --no-commit-hooks`);
-  const packageJson = await fs.readFileSync(packagePath);
-  const {
-    version
-  } = JSON.parse(packageJson);
-  if (gitTag) {
-    let description = await prompt({
-      type: "input",
-      message: chalk.green.bold.underline("Describe what was changed (optional):"),
-      default: ""
-    });
-    let commitMessage = `VERSION ${version}`;
-    if (description && description.trim()) {
-      commitMessage += `\n\n${description.trim()}`;
+
+const bump = async (typeParam = null, skipGit = false) => {
+    if (!fs.existsSync(packagePath)) {
+        console.error("Cannot find package.json file in the current directory");
+        process.exit(1);
     }
-    await runAsync(`git add .`);
-    await runAsync(`git commit -m "${commitMessage}"`);
-    await runAsync(`git tag -a v${version} -m "VERSION ${version}"`);
-    await runAsync(`git push origin --tags`);
-  }
-  console.log(chalk.green.underline(`\nNew version: ${version}\n`));
+    let type = "patch";
+    if (!typeParam) {
+        type = await prompt({
+            type: "list",
+            message: chalk.green.bold.underline("How big of a bump is this?"),
+            choices: ["patch", "minor", "major"]
+        });
+    } else {
+        type = typeParam;
+    }
+    let gitTag = false;
+    if (!skipGit) {
+        gitTag = await prompt({
+            type: "confirm",
+            message: chalk.green.bold.underline("Add git tag?"),
+            default: false
+        });
+    }
+    await runAsync(
+        `yarn version --${type} ${gitTag ? "--no-git-tag-version" : ""} --no-commit-hooks`
+    );
+    const packageJson = await fs.readFileSync(packagePath);
+    const { version } = JSON.parse(packageJson);
+    if (gitTag) {
+        let description = await prompt({
+            type: "input",
+            message: chalk.green.bold.underline("Describe what was changed (optional):"),
+            default: ""
+        });
+
+        let commitMessage = `VERSION ${version}`;
+        if (description && description.trim()) {
+            commitMessage += `\n\n${description.trim()}`;
+        }
+
+        await runAsync(`git add .`);
+        await runAsync(`git commit -m "${commitMessage}"`);
+        await runAsync(`git tag -a v${version} -m "VERSION ${version}"`);
+        await runAsync(`git push origin --tags`);
+    }
+    console.log(chalk.green.underline(`\nNew version: ${version}\n`));
 };
-export default bump;
+
+export default bump;

package/dist/lib/release/commitWithMessage.js

@@ -5,61 +5,89 @@ import seeChangedFiles from "./seeChangedFiles.js";
 import bump from "./bump.js";
 import validateNotDev from "./validateNotDev.js";
 import simple from "simple-git";
+
 async function pub() {
-  await validateNotDev();
-  await bump();
-  let pack = await readJson("package.json");
-  await seeChangedFiles();
-  let commitMsg = "";
-  const type = await new Promise(resolve => {
-    inquirer.prompt([{
-      type: "list",
-      message: chalk.green.bold.underline("What type of change is this?"),
-      choices: ["refactor", "fix", "improvement", "docs", "style", "php", "test", "build", "ci", "chore", "revert"],
-      name: "retType"
-    }]).then(async ({
-      retType
-    }) => {
-      resolve(retType);
+    await validateNotDev();
+    await bump();
+    let pack = await readJson("package.json");
+    await seeChangedFiles();
+    let commitMsg = "";
+    const type = await new Promise(resolve => {
+        inquirer
+            .prompt([
+                {
+                    type: "list",
+                    message: chalk.green.bold.underline("What type of change is this?"),
+                    choices: [
+                        "refactor",
+                        "fix",
+                        "improvement",
+                        "docs",
+                        "style",
+                        "php",
+                        "test",
+                        "build",
+                        "ci",
+                        "chore",
+                        "revert"
+                    ],
+                    name: "retType"
+                }
+            ])
+            .then(async ({ retType }) => {
+                resolve(retType);
+            });
     });
-  });
-  commitMsg += `[${type}] `;
-  inquirer.prompt([{
-    type: "input",
-    message: chalk.bold.hex("#38be18")(`TITLE: What's new this version ${pack.version}: `),
-    name: "commitTitle"
-  }]).then(({
-    commitTitle
-  }) => {
-    commitMsg += commitTitle + `\t\tVERSION ${pack.version}`;
-    inquirer.prompt([{
-      type: "message",
-      message: chalk.bold.hex("#38be18")(`Explain in detail!`),
-      name: "commitDescription"
-    }]).then(async ({
-      commitDescription
-    }) => {
-      commitMsg += "\n" + commitDescription;
-      simple().add("./*").commit(`${commitMsg}`).addRemote("origin", "https://github.com/agrublev/freedcamp-script-runner.git").push(["-u", "origin", "Development"], () => console.log("done"));
+    commitMsg += `[${type}] `;
+    inquirer
+        .prompt([
+            {
+                type: "input",
+                message: chalk.bold.hex("#38be18")(
+                    `TITLE: What's new this version ${pack.version}: `
+                ),
+                name: "commitTitle"
+            }
+        ])
+        .then(({ commitTitle }) => {
+            commitMsg += commitTitle + `\t\tVERSION ${pack.version}`;
+            inquirer
+                .prompt([
+                    {
+                        type: "message",
+                        message: chalk.bold.hex("#38be18")(`Explain in detail!`),
+                        name: "commitDescription"
+                    }
+                ])
+                .then(async ({ commitDescription }) => {
+                    commitMsg += "\n" + commitDescription;
+                    simple()
+                        .add("./*")
+                        .commit(`${commitMsg}`)
+                        .addRemote(
+                            "origin",
+                            "https://github.com/agrublev/freedcamp-script-runner.git"
+                        )
+                        .push(["-u", "origin", "Development"], () => console.log("done"));
 
-      // .commit(`${commitMsg}`)
-      // .addRemote("origin", "https://github.com/agrublev/freedcamp-script-runner.git")
-      // .push(["-u", "origin", "Tztt"], () => console.log("done"));
+                    // .commit(`${commitMsg}`)
+                    // .addRemote("origin", "https://github.com/agrublev/freedcamp-script-runner.git")
+                    // .push(["-u", "origin", "Tztt"], () => console.log("done"));
 
-      // .push(["-u", "origin"], () => console.log("done"))
-      // .addTag(`${pack.version}`, () => console.warn("-- Console TAGGED", 52))
-      // .pushTags();
-      try {
-        // logInfo(command);
-        childProcess.execSync("git push -u origin Treat", {
-          stdio: "inherit",
-          env: Object.assign({}, process.env, {
-            FORCE_COLOR: true,
-            PATH: `${path.resolve("node_modules")}:${process.env.PATH}`
-          })
+                    // .push(["-u", "origin"], () => console.log("done"))
+                    // .addTag(`${pack.version}`, () => console.warn("-- Console TAGGED", 52))
+                    // .pushTags();
+                    try {
+                        // logInfo(command);
+                        childProcess.execSync("git push -u origin Treat", {
+                            stdio: "inherit",
+                            env: Object.assign({}, process.env, {
+                                FORCE_COLOR: true,
+                                PATH: `${path.resolve("node_modules")}:${process.env.PATH}`
+                            })
+                        });
+                    } catch (e) {}
+                });
         });
-      } catch (e) {}
-    });
-  });
 }
-pub();
+pub();

package/dist/lib/release/publish.js

@@ -5,19 +5,24 @@ const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 import { boxInform } from "../utils/helpers.js";
 import chalk from "chalk";
+
 async function pub() {
-  let command = `sh ${path.resolve(__dirname, "publish.sh")}`;
-  try {
-    childProcess.execSync(command, {
-      stdio: "inherit",
-      env: Object.assign({}, process.env, {
-        FORCE_COLOR: true,
-        PATH: `${path.resolve("node_modules")}:${process.env.PATH}`
-      })
-    });
-    boxInform(chalk.green.bold.underline("PUBLISHED"), "https://www.npmjs.com/package/fscripts", 3);
-  } catch (e) {
-    console.error(`${command} - ${e}`);
-  }
+    let command = `sh ${path.resolve(__dirname, "publish.sh")}`;
+    try {
+        childProcess.execSync(command, {
+            stdio: "inherit",
+            env: Object.assign({}, process.env, {
+                FORCE_COLOR: true,
+                PATH: `${path.resolve("node_modules")}:${process.env.PATH}`
+            })
+        });
+        boxInform(
+            chalk.green.bold.underline("PUBLISHED"),
+            "https://www.npmjs.com/package/fscripts",
+            3
+        );
+    } catch (e) {
+        console.error(`${command} - ${e}`);
+    }
 }
-pub();
+pub();

package/dist/lib/release/pushToGit.js

@@ -1,43 +1,52 @@
 import { spawn } from "child-process-promise";
 import prompt from "console-prompt";
+
 const gitTarget = "origin";
 let gitTargetBranch = "Development";
+
 const runGitPush = gitParams => {
-  const gitPromise = spawn("git", gitParams);
-  const {
-    childProcess
-  } = gitPromise;
-  childProcess.stdout.pipe(process.stdout);
-  childProcess.stderr.pipe(process.stderr);
-  return gitPromise;
+    const gitPromise = spawn("git", gitParams);
+    const { childProcess } = gitPromise;
+
+    childProcess.stdout.pipe(process.stdout);
+    childProcess.stderr.pipe(process.stderr);
+
+    return gitPromise;
 };
 
 // Git command to get the current branch name: git rev-parse --abbrev-ref HEAD
 
 const push = () => {
-  spawn("git", ["rev-parse", "--abbrev-ref", "HEAD"], {
-    capture: ["stdout", "stderr"]
-  }).then(result => {
-    const currGitBranch = result.stdout.toString().trim();
-    if (!currGitBranch) {
-      console.error("Current git branch is undefined!");
-      process.exit(2);
-    }
-
-    // if (gitTargetBranch === undefined) {
-    gitTargetBranch = currGitBranch;
-    // }
-
-    console.log(`Push current git branch [${currGitBranch}] to ${gitTargetBranch} of: \n` + `${gitTarget}`);
-    const gitParams = ["push"];
-    gitParams.push(`${gitTarget}`);
-    gitParams.push(`${currGitBranch}:${gitTargetBranch}`);
-    console.log(`The exact command is: 
+    spawn("git", ["rev-parse", "--abbrev-ref", "HEAD"], { capture: ["stdout", "stderr"] })
+        .then(result => {
+            const currGitBranch = result.stdout.toString().trim();
+
+            if (!currGitBranch) {
+                console.error("Current git branch is undefined!");
+                process.exit(2);
+            }
+
+            // if (gitTargetBranch === undefined) {
+            gitTargetBranch = currGitBranch;
+            // }
+
+            console.log(
+                `Push current git branch [${currGitBranch}] to ${gitTargetBranch} of: \n` +
+                    `${gitTarget}`
+            );
+
+            const gitParams = ["push"];
+
+            gitParams.push(`${gitTarget}`);
+            gitParams.push(`${currGitBranch}:${gitTargetBranch}`);
+
+            console.log(`The exact command is: 
         git ${gitParams.join(" ")}`);
-    return runGitPush(gitParams);
-  }).catch(error => {
-    const err = error.stderr ? error.stderr : error;
-    console.error("Execution Errors:", err);
-  });
+            return runGitPush(gitParams);
+        })
+        .catch(error => {
+            const err = error.stderr ? error.stderr : error;
+            console.error("Execution Errors:", err);
+        });
 };
-export default push;
+export default push;