@aiyu-ayaan/nonap 0.0.0-stage → 0.0.1-alpha.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 aiyu-ayaan
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,61 @@
-# Temporary Holding Version
+# NoNap
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Tiny, zero-dependency CLI mouse wiggler. Keeps your machine awake.
+
+Each wiggle moves the cursor a pixel or so and straight back, so the final position never changes and the movement is hard to notice.
+
+## Install
+
+```sh
+npm install -g @aiyu-ayaan/nonap
+```
+
+Or from a clone: `npm link`.
+
+## Usage
+
+```sh
+nonap --start              # or: nonap -s
+nonap -s -i 20 -t 2h       # wiggle every ~20s, stop after 2h
+nonap -s -p random -d 3    # random direction, up to 3px
+nonap --help               # or: nonap -h
+```
+
+## Options
+
+| Flag | Long | Meaning | Default |
+| --- | --- | --- | --- |
+| `-s` | `--start` | Start wiggling until Ctrl+C | |
+| `-i` | `--interval <time>` | Time between wiggles | `30s` |
+| `-j` | `--jitter <time>` | Random ± added to the interval, so timing is not robotic | `5s` |
+| `-d` | `--distance <px>` | Max pixels per wiggle, 1-50 | `1` |
+| `-p` | `--pattern <name>` | `nudge` (fixed distance) or `random` (1 to distance) | `nudge` |
+| `-t` | `--duration <time>` | Stop after this long, `0` = never | `0` |
+| `-q` | `--quiet` | No output while running | |
+| `-h` | `--help` | Show help | |
+| `-v` | `--version` | Show version | |
+
+Time values: `90`, `90s`, `30m`, `2h`, `1h30m`.
+
+## Config
+
+Save defaults so you do not retype flags. Stored in `~/.nonap/config.json`. Flags override saved values.
+
+```sh
+nonap config                    # show
+nonap config set interval 45
+nonap config set distance 2
+nonap config reset
+```
+
+Keys: `interval`, `jitter`, `distance`, `pattern`, `duration`.
+
+## Platform support
+
+- **Linux:** needs `xdotool` (X11) or `ydotool` (Wayland).
+- **Windows:** works out of the box (PowerShell).
+- **macOS:** works out of the box; grant Accessibility permission to your terminal.
+
+## License
+
+[MIT](LICENSE)

package/bin/nonap.js

@@ -0,0 +1,112 @@
+#!/usr/bin/env node
+'use strict';
+
+const { parseArgs } = require('util');
+const cfg = require('../src/config');
+const { createMouse } = require('../src/mouse');
+const { wiggle, nextDelay, sleep } = require('../src/wiggle');
+const HELP = require('../src/help');
+const pkg = require('../package.json');
+
+const options = {
+  start: { type: 'boolean', short: 's' },
+  help: { type: 'boolean', short: 'h' },
+  version: { type: 'boolean', short: 'v' },
+  quiet: { type: 'boolean', short: 'q' },
+  interval: { type: 'string', short: 'i' },
+  jitter: { type: 'string', short: 'j' },
+  distance: { type: 'string', short: 'd' },
+  pattern: { type: 'string', short: 'p' },
+  duration: { type: 'string', short: 't' },
+};
+
+function fail(msg) {
+  console.error(`nonap: ${msg}\nTry "nonap --help".`);
+  process.exit(1);
+}
+
+function configCommand(args) {
+  const [sub, key, value] = args;
+  if (!sub || sub === 'show') {
+    console.log(`${cfg.CONFIG_PATH}\n${JSON.stringify(cfg.load(), null, 2)}`);
+  } else if (sub === 'set') {
+    if (!key || value === undefined) fail('usage: nonap config set <key> <value>');
+    const next = cfg.load();
+    next[key] = cfg.coerce(key, value);
+    cfg.save(next);
+    console.log(`saved ${key} = ${next[key]}`);
+  } else if (sub === 'reset') {
+    cfg.save({ ...cfg.DEFAULTS });
+    console.log('config reset to defaults');
+  } else {
+    fail(`unknown config command "${sub}"`);
+  }
+}
+
+async function run(settings, quiet) {
+  const mouse = createMouse();
+  const log = quiet ? () => {} : (m) => console.log(m);
+  const startedAt = Date.now();
+  const endAt = settings.duration ? startedAt + settings.duration * 1000 : Infinity;
+  let stopping = false;
+  let count = 0;
+
+  const stop = () => {
+    stopping = true;
+  };
+  process.on('SIGINT', stop);
+  process.on('SIGTERM', stop);
+
+  log(
+    `NoNap running: every ~${cfg.format(settings.interval)} (+/-${cfg.format(settings.jitter)}), ` +
+      `${settings.pattern} ${settings.distance}px` +
+      (settings.duration ? `, for ${cfg.format(settings.duration)}` : '') +
+      '. Ctrl+C to stop.',
+  );
+
+  while (!stopping && Date.now() < endAt) {
+    // Sleep in 250ms slices so Ctrl+C and the duration limit react quickly.
+    const wakeAt = Date.now() + nextDelay(settings) * 1000;
+    while (!stopping && Date.now() < Math.min(wakeAt, endAt)) await sleep(250);
+    if (stopping || Date.now() >= endAt) break;
+    await wiggle(mouse, settings);
+    count++;
+    log(`[${new Date().toLocaleTimeString()}] wiggle #${count}`);
+  }
+
+  log(`Stopped after ${cfg.format((Date.now() - startedAt) / 1000)}, ${count} wiggles.`);
+}
+
+async function main() {
+  let parsed;
+  try {
+    parsed = parseArgs({ options, allowPositionals: true });
+  } catch (e) {
+    fail(e.message);
+  }
+  const { values, positionals } = parsed;
+
+  if (values.help) return console.log(HELP);
+  if (values.version) return console.log(pkg.version);
+  if (positionals[0] === 'config') {
+    try {
+      return configCommand(positionals.slice(1));
+    } catch (e) {
+      fail(e.message);
+    }
+  }
+  if (positionals.length) fail(`unknown command "${positionals[0]}"`);
+  if (!values.start) return console.log(HELP);
+
+  const settings = cfg.load();
+  try {
+    for (const key of ['interval', 'jitter', 'distance', 'pattern', 'duration']) {
+      if (values[key] !== undefined) settings[key] = cfg.coerce(key, values[key]);
+    }
+    await run(settings, values.quiet);
+  } catch (e) {
+    fail(e.message);
+  }
+}
+
+main();

package/package.json

@@ -1,6 +1,30 @@
 {
   "name": "@aiyu-ayaan/nonap",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.0.1-alpha.1",
+  "description": "Tiny, zero-dependency CLI mouse wiggler that keeps your machine awake",
+  "author": "aiyu-ayaan",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/aiyu-ayaan/Nonap.git"
+  },
+  "homepage": "https://github.com/aiyu-ayaan/Nonap#readme",
+  "bugs": "https://github.com/aiyu-ayaan/Nonap/issues",
+  "bin": {
+    "nonap": "bin/nonap.js"
+  },
+  "files": [
+    "bin",
+    "src"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "keywords": [
+    "mouse",
+    "jiggler",
+    "wiggler",
+    "keep-awake",
+    "cli"
+  ],
+  "license": "MIT"
+}

package/src/config.js

@@ -0,0 +1,80 @@
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const CONFIG_PATH = path.join(os.homedir(), '.nonap', 'config.json');
+
+const DEFAULTS = {
+  interval: 30, // seconds between wiggles
+  jitter: 5, // random +/- seconds added to interval
+  distance: 1, // max pixels moved per wiggle
+  pattern: 'nudge', // nudge | random
+  duration: 0, // seconds to run, 0 = until stopped
+};
+
+const PATTERNS = ['nudge', 'random'];
+
+function load() {
+  try {
+    return { ...DEFAULTS, ...JSON.parse(fs.readFileSync(CONFIG_PATH, 'utf8')) };
+  } catch {
+    return { ...DEFAULTS };
+  }
+}
+
+function save(cfg) {
+  fs.mkdirSync(path.dirname(CONFIG_PATH), { recursive: true });
+  fs.writeFileSync(CONFIG_PATH, JSON.stringify(cfg, null, 2) + '\n');
+}
+
+// "90", "90s", "30m", "2h", "1h30m" -> seconds
+function parseDuration(value) {
+  if (typeof value === 'number') return value;
+  const str = String(value).trim().toLowerCase();
+  if (/^\d+(\.\d+)?$/.test(str)) return Number(str);
+  const re = /(\d+(?:\.\d+)?)([hms])/g;
+  const units = { h: 3600, m: 60, s: 1 };
+  let total = 0;
+  let matched = '';
+  let m;
+  while ((m = re.exec(str))) {
+    total += Number(m[1]) * units[m[2]];
+    matched += m[0];
+  }
+  if (!matched || matched !== str) throw new Error(`invalid duration: "${value}" (try 90, 30m, 2h, 1h30m)`);
+  return total;
+}
+
+function format(seconds) {
+  const h = Math.floor(seconds / 3600);
+  const m = Math.floor((seconds % 3600) / 60);
+  const s = Math.floor(seconds % 60);
+  return [h && `${h}h`, m && `${m}m`, (s || (!h && !m)) && `${s}s`].filter(Boolean).join('');
+}
+
+// Validate + normalise a single key/value pair.
+function coerce(key, value) {
+  switch (key) {
+    case 'interval':
+    case 'jitter':
+    case 'duration': {
+      const n = parseDuration(value);
+      if (n < 0 || (key === 'interval' && n < 1)) throw new Error(`${key} out of range`);
+      return n;
+    }
+    case 'distance': {
+      const n = Number(value);
+      if (!Number.isInteger(n) || n < 1 || n > 50) throw new Error('distance must be an integer 1-50');
+      return n;
+    }
+    case 'pattern':
+      if (!PATTERNS.includes(value)) throw new Error(`pattern must be one of: ${PATTERNS.join(', ')}`);
+      return value;
+    default:
+      throw new Error(`unknown key "${key}" (keys: ${Object.keys(DEFAULTS).join(', ')})`);
+  }
+}
+
+module.exports = { CONFIG_PATH, DEFAULTS, PATTERNS, load, save, coerce, parseDuration, format };

package/src/help.js

@@ -0,0 +1,34 @@
+'use strict';
+
+const { DEFAULTS } = require('./config');
+
+module.exports = `
+NoNap - tiny CLI mouse wiggler. Keeps your machine awake.
+
+Usage
+  nonap --start [options]        start wiggling (alias: -s)
+  nonap config                   show saved config
+  nonap config set <key> <val>   save a default (interval, jitter, distance, pattern, duration)
+  nonap config reset             restore defaults
+
+Options
+  -s, --start               start wiggling until Ctrl+C
+  -i, --interval <time>     time between wiggles        (default ${DEFAULTS.interval}s)
+  -j, --jitter <time>       random +/- on the interval  (default ${DEFAULTS.jitter}s)
+  -d, --distance <px>       max pixels per wiggle, 1-50 (default ${DEFAULTS.distance})
+  -p, --pattern <name>      nudge | random             (default ${DEFAULTS.pattern})
+  -t, --duration <time>     stop after this long, 0 = never (default 0)
+  -q, --quiet               no output while running
+  -h, --help                show this help
+  -v, --version             show version
+
+Time values: 90, 90s, 30m, 2h, 1h30m
+
+Examples
+  nonap -s
+  nonap -s -i 20 -t 2h
+  nonap config set interval 45
+
+Requires xdotool or ydotool on Linux. Works out of the box on Windows and macOS
+(macOS: grant Accessibility permission to your terminal).
+`.trimStart();

package/src/mouse.js

@@ -0,0 +1,49 @@
+'use strict';
+
+const { execFileSync, spawnSync } = require('child_process');
+
+function has(cmd) {
+  return spawnSync(process.platform === 'win32' ? 'where' : 'which', [cmd], { stdio: 'ignore' }).status === 0;
+}
+
+// Each backend exposes move(dx, dy): relative cursor move in pixels.
+function linux() {
+  if (has('xdotool') && process.env.DISPLAY) {
+    return (dx, dy) => execFileSync('xdotool', ['mousemove_relative', '--', String(dx), String(dy)], { stdio: 'ignore' });
+  }
+  if (has('ydotool')) {
+    return (dx, dy) => execFileSync('ydotool', ['mousemove', '-x', String(dx), '-y', String(dy)], { stdio: 'ignore' });
+  }
+  throw new Error('need `xdotool` (X11) or `ydotool` (Wayland): e.g. sudo apt install xdotool');
+}
+
+function windows() {
+  const ps = (dx, dy) =>
+    "Add-Type -MemberDefinition '[DllImport(\"user32.dll\")] public static extern void mouse_event(int f,int x,int y,int d,int e);' " +
+    `-Name M -Namespace N; [N.M]::mouse_event(1,${dx},${dy},0,0)`;
+  return (dx, dy) => execFileSync('powershell', ['-NoProfile', '-NonInteractive', '-Command', ps(dx, dy)], { stdio: 'ignore' });
+}
+
+function mac() {
+  const js = (dx, dy) =>
+    "ObjC.import('CoreGraphics');" +
+    "var p=$.CGEventGetLocation($.CGEventCreate($()));" +
+    `var e=$.CGEventCreateMouseEvent($(),$.kCGEventMouseMoved,{x:p.x+(${dx}),y:p.y+(${dy})},0);` +
+    '$.CGEventPost($.kCGHIDEventTap,e);';
+  return (dx, dy) => execFileSync('osascript', ['-l', 'JavaScript', '-e', js(dx, dy)], { stdio: 'ignore' });
+}
+
+function createMouse() {
+  switch (process.platform) {
+    case 'linux':
+      return { move: linux() };
+    case 'win32':
+      return { move: windows() };
+    case 'darwin':
+      return { move: mac() };
+    default:
+      throw new Error(`unsupported platform: ${process.platform}`);
+  }
+}
+
+module.exports = { createMouse };

package/src/wiggle.js

@@ -0,0 +1,30 @@
+'use strict';
+
+const rand = (min, max) => Math.floor(Math.random() * (max - min + 1)) + min;
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+
+const DIRS = [
+  [1, 0],
+  [-1, 0],
+  [0, 1],
+  [0, -1],
+];
+
+// One wiggle: step away, then straight back, so the cursor ends where it began.
+async function wiggle(mouse, { pattern, distance }) {
+  const [ux, uy] = DIRS[rand(0, DIRS.length - 1)];
+  const step = pattern === 'random' ? rand(1, distance) : distance;
+  const dx = ux * step;
+  const dy = uy * step;
+  mouse.move(dx, dy);
+  await sleep(rand(30, 90));
+  mouse.move(-dx, -dy);
+  return { dx, dy };
+}
+
+// Seconds until the next wiggle, interval +/- jitter (never below 1s).
+function nextDelay({ interval, jitter }) {
+  return Math.max(1, interval + rand(-jitter, jitter));
+}
+
+module.exports = { wiggle, nextDelay, sleep };