index.js

#!/usr/bin/env node
//@ts-check

/** Import nut-js which handles the mouse-moving functionalities */
const { mouse, Point, sleep } = require("@nut-tree/nut-js");
const { version } = require("./package.json");

const colored = {
  yellow: (text) => `\x1b[33m` + text + `\x1b[0m`,
  green: (text) => `\x1b[32m` + text + `\x1b[0m`,
  red: (text) => `\x1b[31m` + text + `\x1b[0m`,
};

/** Read the command line arguments */
const args = process.argv.slice(2);

const DEFAULTS = {
  OFFSET_PX: 1,
  INTERVAL: 60,
};

/**
 * Transform seconds to display time in the format `HH:mm:ss`
 * @param {number} seconds
 * @returns {string} The display time to be shown
 */
const secondsToDisplayTime = (seconds) => {
  return new Date(seconds * 1000).toISOString().substr(11, 8);
};

/**
 * Extracts argument from the process args with the key provided
 * @param {string} param Key of the extracted value
 * @param {number} defaultValue Default value to be used if no such value is found.
 * @returns
 */
const getArgParam = (param, defaultValue) => {
  /** Find the arg index which corresponds to the param provided */
  const paramTagIndex = args.findIndex((arg) => arg === param);
  if (paramTagIndex < 0) return defaultValue;

  /** Get the next element in the array, so we know the value of the param */
  const paramValueIndex = paramTagIndex + 1;

  /** If there is such value after param tag */
  if (args[paramValueIndex]) {
    /** Try to parse it to float */
    const paramValueAsFloat = parseFloat(args[paramValueIndex]);

    /** If it is not a valid number, return the default value */
    if (isNaN(paramValueAsFloat)) {
      return defaultValue;
    } else {
      /** Else return the user-configured value */
      return paramValueAsFloat;
    }
  }

  /** Default return, if no arg after --default value is provided */
  return defaultValue;
};

/**
 * Extracts the offset value from the --offset argument
 * @returns {number} Amount of pixels to move the cursor by. User defined or default.
 */
const getMoveOffset = () => {
  return getArgParam("--offset", DEFAULTS.OFFSET_PX);
};

/**
 * @typedef {Object} ITimeInterval
 * @property {number} seconds - The time which the computer can stay idle in seconds
 * @property {number} milliseconds - The time which the computer can stay idle in milliseconds
 *
 * Extracts the interval value from the --max-idle argument
 * @returns {ITimeInterval} Amount of MS to wait before moving the cursor after system is idle. User defined or default.
 */
const getIdleTimeInterval = () => {
  const intervalTime = getArgParam("--interval", DEFAULTS.INTERVAL);

  return {
    seconds: intervalTime,
    milliseconds: intervalTime * 1_000,
  };
};

/**
 * Determines if --random tag is provided
 * @returns {boolean} If --random tag is provided in process.args
 */
const getIsRandom = () => {
  return args.includes("--random");
};

/** Returns a figlet welcome heading message */
const getFigletWelcomeMessage = () => {
  const figletMessage = `     _  __                 __  __        _   _       _ 
    | |/ /___  ___ _ __   |  \\/  | ___  | | | |_ __ | |
    | ' // _ \\/ _ \\ '_ \\  | |\\/| |/ _ \\ | | | | '_ \\| |
    | . \\  __/  __/ |_) | | |  | |  __/ | |_| | |_) |_|
    |_|\\_\\___|\\___| .__/  |_|  |_|\\___|  \\___/| .__/(_)
                  |_|                         |_|      
  `;
  return figletMessage;
};

/**
 * Generate a random number between the negative of the provided argument and the positive
 * @param {number} maxLimit The maximum number for the generated one
 * @returns {number} Random number between the negative of the provided argument and the positive
 */
const getRandomOffset = (maxLimit) => {
  return Math.floor(Math.random() * maxLimit * 2) - maxLimit;
};

const run = async () => {
  /** Write the heading message with the app name */
  console.log(getFigletWelcomeMessage());

  /** Save settings so we don't do unnecessary operations */
  const interval = getIdleTimeInterval();
  const moveOffset = getMoveOffset();
  const isRandom = getIsRandom();

  process.stdout.cursorTo(4);
  process.stdout.write(
    `Offset:   ${
      isRandom ? colored.red("Random") : colored.yellow(moveOffset + "px")
    }`
  );
  process.stdout.cursorTo(40);
  process.stdout.write(`Ver: ${colored.yellow(version)}\n`);

  process.stdout.cursorTo(4);
  process.stdout.write(`Interval: ${colored.yellow(interval.seconds + "s")}`);
  process.stdout.cursorTo(40);
  process.stdout.write(`By:  ${colored.yellow("bmutafov")}\n`);

  process.stdout.cursorTo(4);
  process.stdout.write(
    "___________________________________________________\n\n"
  );

  /** Set the default idle time label and write it to console */
  process.stdout.cursorTo(4);
  const idleTimeString = "Idling for: ";
  process.stdout.write(idleTimeString);

  /** Hide the terminal cursor */
  process.stderr.write("\x1B[?25l");

  for (let i = 0, moveSign = +1; true; i++) {
    /** Display the info line and keep it updated every second */
    const displayIdleTime = secondsToDisplayTime(i);
    /** Move the cursor to where the default "Idle time" string ends */
    process.stdout.cursorTo(idleTimeString.length + 4);
    /** Clear everything after */
    process.stdout.clearLine(1);
    /** Write the remaining time */
    process.stdout.write(colored.yellow(displayIdleTime + "s"));
    process.stdout.cursorTo(40);
    /** Write the status value */
    process.stdout.write(colored.green("Active"));

    /** If we have reached the maximum idle time */
    if (i % interval.seconds === 0) {
      const nextMoveOffsetAbs = isRandom ? getRandomOffset(600) : moveOffset;
      const nextMoveOffset = nextMoveOffsetAbs * moveSign;
      moveSign *= -1;

      /** Get last position of the cursor and move it by the given offset */
      const prevPosition = await mouse.getPosition();
      const coordinates = new Point(
        prevPosition.x + nextMoveOffset,
        prevPosition.y + nextMoveOffset
      );

      await mouse.setPosition(coordinates);
    }

    /** Sleep 1 second */
    await sleep(1_000);
  }
};

run();