tonton-cli 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 tonton contributors
+
+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

@@ -0,0 +1,133 @@
+# tonton
+
+Play a notification sound from your terminal. Zero dependencies. ~15KB.
+
+Perfect for getting pinged when AI coding tools (Claude Code, Codex, etc.) finish a task — or need your attention.
+
+## Quick Start
+
+```bash
+npx tonton-cli --setup
+```
+
+That's it. Claude Code will now play:
+- A **done** sound when the agent finishes
+- An **input** sound when the agent needs you
+
+## Install
+
+```bash
+npm install -g tonton-cli
+```
+
+Or use without installing — `npx tonton-cli` works everywhere.
+
+## Two Sounds
+
+| Command | When | macOS | Cross-platform |
+|---------|------|-------|---------------|
+| `tonton --done` | Agent finished | Glass | Descending chime |
+| `tonton --input` | Agent needs you | Funk | Ascending chime |
+
+```bash
+tonton --done     # hear the "finished" sound
+tonton --input    # hear the "need attention" sound
+tonton            # default notification sound
+```
+
+## Use with AI CLI Tools
+
+### Claude Code — automatic setup
+
+```bash
+npx tonton-cli --setup
+```
+
+This adds hooks to `~/.claude/settings.json` so Claude Code plays distinct sounds when done vs. needing input. Run once, works forever.
+
+To remove: `npx tonton-cli --remove`
+
+### Claude Code — manual setup
+
+Add to `~/.claude/settings.json`:
+
+```json
+{
+  "hooks": {
+    "AfterAssistantTurn": [
+      { "type": "command", "command": "npx tonton-cli --done" }
+    ],
+    "Notification": [
+      { "type": "command", "command": "npx tonton-cli --input" }
+    ]
+  }
+}
+```
+
+### Codex CLI
+
+```bash
+codex "fix the bug" ; npx tonton-cli --done
+```
+
+### Any command
+
+```bash
+npm test ; npx tonton-cli --done
+long-running-task ; npx tonton-cli
+```
+
+### Shell alias
+
+```bash
+# Add to ~/.zshrc or ~/.bashrc
+notify() { "$@"; npx tonton-cli --done; }
+
+# Then use:
+notify npm test
+notify codex "refactor this"
+```
+
+## More Options
+
+```bash
+# Pick a specific sound (macOS system sounds)
+tonton --sound Glass
+tonton --sound Hero
+
+# Adjust volume (macOS only)
+tonton --volume 0.5
+
+# List available sounds
+tonton --list
+```
+
+## Programmatic API
+
+```js
+import { play, listSounds } from 'tonton-cli';
+
+await play();                          // default sound
+await play({ sound: 'done' });         // completion sound
+await play({ sound: 'input' });        // attention sound
+await play({ sound: 'Glass' });        // macOS system sound
+await play({ volume: 0.5 });           // half volume (macOS)
+
+const sounds = listSounds();           // available sound names
+```
+
+## Cross-Platform
+
+| Platform | Player | Sounds |
+|----------|--------|--------|
+| **macOS** | `afplay` (built-in) | 14 system sounds + synthesized chime |
+| **Linux** | `paplay` / `aplay` / `ffplay` | Freedesktop sounds + synthesized chime |
+| **Windows** | PowerShell SoundPlayer | Windows Media sounds + synthesized chime |
+
+Falls back to a synthesized two-tone chime, then terminal bell — always plays something.
+
+**Always exits 0.** A notification sound will never break your scripts, hooks, or CI.
+
+## License
+
+MIT

package/bin/tonton.js

@@ -0,0 +1,99 @@
+#!/usr/bin/env node
+'use strict';
+
+const { play, listSounds } = require('../lib/index');
+const { version } = require('../package.json');
+
+const args = process.argv.slice(2);
+let sound = undefined;
+let vol = undefined;
+
+for (let i = 0; i < args.length; i++) {
+  const arg = args[i];
+
+  if (arg === '-h' || arg === '--help') {
+    console.log(`tonton v${version} — notification sound for your terminal
+
+Usage: tonton [options]
+
+Setup:
+  --setup               Auto-configure Claude Code hooks (one-time)
+  --remove              Remove tonton hooks from Claude Code
+
+Presets:
+  -d, --done            Agent finished (descending chime)
+  -i, --input           Agent needs input (ascending chime)
+
+Options:
+  -s, --sound <name>    Sound to play (default: "Ping" on macOS, "chime" elsewhere)
+  -v, --volume <0-1>    Volume level, 0.0 to 1.0 (macOS only, default: 1.0)
+  -l, --list            List available sounds
+  -h, --help            Show this help
+  --version             Show version
+
+Quick start:
+  npx tonton-cli --setup                  Configure Claude Code hooks automatically
+
+Examples:
+  npx tonton-cli                          Play default notification sound
+  npx tonton-cli --done                   Agent finished working
+  npx tonton-cli --input                  Agent needs your attention
+  npx tonton-cli -s Glass                 Play the Glass sound (macOS)
+
+After any command:
+  codex "fix the bug" ; npx tonton-cli --done`);
+    process.exit(0);
+  }
+
+  if (arg === '--version') {
+    console.log(version);
+    process.exit(0);
+  }
+
+  if (arg === '--setup') {
+    console.log('Setting up Claude Code hooks...\n');
+    require('../lib/setup').setup();
+    process.exit(0);
+  }
+
+  if (arg === '--remove') {
+    console.log('Removing tonton hooks...\n');
+    require('../lib/setup').unsetup();
+    process.exit(0);
+  }
+
+  if (arg === '-l' || arg === '--list') {
+    const sounds = listSounds();
+    console.log('Available sounds:');
+    for (const s of sounds) {
+      console.log('  ' + s);
+    }
+    process.exit(0);
+  }
+
+  if (arg === '-d' || arg === '--done') {
+    sound = 'done';
+    continue;
+  }
+
+  if (arg === '-i' || arg === '--input') {
+    sound = 'input';
+    continue;
+  }
+
+  if ((arg === '-s' || arg === '--sound') && i + 1 < args.length) {
+    sound = args[++i];
+    continue;
+  }
+
+  if ((arg === '-v' || arg === '--volume') && i + 1 < args.length) {
+    vol = parseFloat(args[++i]);
+    continue;
+  }
+}
+
+play({ sound, volume: vol }).then(() => {
+  process.exit(0);
+}).catch(() => {
+  process.exit(0);
+});

package/lib/index.js

@@ -0,0 +1,18 @@
+'use strict';
+
+const { resolveSound, listSounds, generateWav } = require('./sounds');
+const { playSound } = require('./player');
+
+async function play(options = {}) {
+  const { sound = 'default', volume } = options;
+
+  try {
+    const soundInfo = resolveSound(sound);
+    await playSound(soundInfo, { volume });
+  } catch {
+    // Never throw — a notification sound failing is not an error
+    try { process.stdout.write('\x07'); } catch {}
+  }
+}
+
+module.exports = { play, listSounds, generateWav };

package/lib/index.mjs

@@ -0,0 +1,6 @@
+import { createRequire } from 'module';
+const require = createRequire(import.meta.url);
+const tonton = require('./index.js');
+
+export default tonton.play;
+export const { play, listSounds, generateWav } = tonton;

package/lib/player.js

@@ -0,0 +1,129 @@
+'use strict';
+
+const { execFile, exec } = require('child_process');
+const { execFileSync } = require('child_process');
+const fs = require('fs');
+
+const TIMEOUT = 5000;
+let cachedLinuxPlayer = undefined; // undefined = not detected yet
+
+function findLinuxPlayer() {
+  if (cachedLinuxPlayer !== undefined) return cachedLinuxPlayer;
+
+  const players = [
+    { cmd: 'paplay', args: (f) => [f] },
+    { cmd: 'pw-play', args: (f) => [f] },
+    { cmd: 'aplay', args: (f) => [f], wavOnly: true },
+    { cmd: 'ffplay', args: (f) => ['-nodisp', '-autoexit', '-loglevel', 'quiet', f] },
+    { cmd: 'play', args: (f) => ['-q', f] },
+    { cmd: 'mpg123', args: (f) => ['-q', f] },
+  ];
+
+  for (const player of players) {
+    try {
+      execFileSync('which', [player.cmd], { stdio: 'ignore' });
+      cachedLinuxPlayer = player;
+      return player;
+    } catch {}
+  }
+
+  cachedLinuxPlayer = null;
+  return null;
+}
+
+function cleanup(soundInfo) {
+  if (soundInfo.cleanup && soundInfo.filePath) {
+    fs.unlink(soundInfo.filePath, () => {}); // ignore errors
+  }
+}
+
+function playDarwin(soundInfo, options = {}) {
+  return new Promise((resolve) => {
+    const args = [soundInfo.filePath];
+    if (options.volume != null) {
+      args.push('-v', String(options.volume));
+    }
+
+    const child = execFile('afplay', args, { timeout: TIMEOUT }, (err) => {
+      cleanup(soundInfo);
+      resolve();
+    });
+
+    child.on('error', () => {
+      cleanup(soundInfo);
+      resolve();
+    });
+  });
+}
+
+function playLinux(soundInfo, options = {}) {
+  return new Promise((resolve) => {
+    const player = findLinuxPlayer();
+
+    if (!player) {
+      cleanup(soundInfo);
+      bellFallback();
+      resolve();
+      return;
+    }
+
+    // If player only supports wav but file isn't wav, need synthesized wav
+    if (player.wavOnly && !soundInfo.filePath.endsWith('.wav')) {
+      const { synthesizeToTemp } = require('./sounds');
+      cleanup(soundInfo);
+      soundInfo = synthesizeToTemp();
+    }
+
+    const args = player.args(soundInfo.filePath);
+    const child = execFile(player.cmd, args, { timeout: TIMEOUT }, (err) => {
+      cleanup(soundInfo);
+      resolve();
+    });
+
+    child.on('error', () => {
+      cleanup(soundInfo);
+      bellFallback();
+      resolve();
+    });
+  });
+}
+
+function playWindows(soundInfo, options = {}) {
+  return new Promise((resolve) => {
+    const escaped = soundInfo.filePath.replace(/'/g, "''");
+    const cmd = `powershell -Command "(New-Object System.Media.SoundPlayer '${escaped}').PlaySync()"`;
+
+    exec(cmd, { timeout: TIMEOUT }, (err) => {
+      cleanup(soundInfo);
+      if (err) {
+        // Fallback to Console.Beep
+        exec('powershell -Command "[System.Console]::Beep(880, 300)"', { timeout: TIMEOUT }, () => {
+          resolve();
+        });
+      } else {
+        resolve();
+      }
+    });
+  });
+}
+
+function bellFallback() {
+  try {
+    process.stdout.write('\x07');
+  } catch {}
+}
+
+function playSound(soundInfo, options = {}) {
+  const platform = process.platform;
+
+  if (platform === 'darwin') return playDarwin(soundInfo, options);
+  if (platform === 'linux') return playLinux(soundInfo, options);
+  if (platform === 'win32') return playWindows(soundInfo, options);
+
+  // Unknown platform
+  cleanup(soundInfo);
+  bellFallback();
+  return Promise.resolve();
+}
+
+module.exports = { playSound };

package/lib/setup.js

@@ -0,0 +1,103 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const CLAUDE_SETTINGS_PATH = path.join(os.homedir(), '.claude', 'settings.json');
+
+const HOOKS = {
+  Notification: { type: 'command', command: 'npx tonton-cli --input' },
+  AfterAssistantTurn: { type: 'command', command: 'npx tonton-cli --done' },
+};
+
+function readSettings() {
+  try {
+    const raw = fs.readFileSync(CLAUDE_SETTINGS_PATH, 'utf8');
+    return JSON.parse(raw);
+  } catch {
+    return {};
+  }
+}
+
+function writeSettings(settings) {
+  const dir = path.dirname(CLAUDE_SETTINGS_PATH);
+  fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(CLAUDE_SETTINGS_PATH, JSON.stringify(settings, null, 2) + '\n');
+}
+
+function hookExists(hooks, newHook) {
+  return hooks.some(h => h.command === newHook.command);
+}
+
+function setup() {
+  const settings = readSettings();
+
+  if (!settings.hooks) settings.hooks = {};
+
+  let added = 0;
+
+  for (const [event, hook] of Object.entries(HOOKS)) {
+    if (!settings.hooks[event]) settings.hooks[event] = [];
+
+    if (!hookExists(settings.hooks[event], hook)) {
+      settings.hooks[event].push(hook);
+      added++;
+      console.log(`  + ${event} → ${hook.command}`);
+    } else {
+      console.log(`  ~ ${event} → already configured`);
+    }
+  }
+
+  if (added > 0) {
+    writeSettings(settings);
+    console.log(`\nWrote ${CLAUDE_SETTINGS_PATH}`);
+  }
+
+  console.log('\nDone! Claude Code will now play:');
+  console.log('  --done sound   when the agent finishes');
+  console.log('  --input sound  when the agent needs you');
+}
+
+function unsetup() {
+  const settings = readSettings();
+
+  if (!settings.hooks) {
+    console.log('No hooks found — nothing to remove.');
+    return;
+  }
+
+  let removed = 0;
+
+  for (const [event, hook] of Object.entries(HOOKS)) {
+    if (!settings.hooks[event]) continue;
+
+    const before = settings.hooks[event].length;
+    settings.hooks[event] = settings.hooks[event].filter(h => h.command !== hook.command);
+    const after = settings.hooks[event].length;
+
+    if (before !== after) {
+      removed++;
+      console.log(`  - ${event} → removed`);
+    }
+
+    // Clean up empty arrays
+    if (settings.hooks[event].length === 0) {
+      delete settings.hooks[event];
+    }
+  }
+
+  // Clean up empty hooks object
+  if (Object.keys(settings.hooks).length === 0) {
+    delete settings.hooks;
+  }
+
+  if (removed > 0) {
+    writeSettings(settings);
+    console.log(`\nWrote ${CLAUDE_SETTINGS_PATH}`);
+  } else {
+    console.log('No tonton hooks found — nothing to remove.');
+  }
+}
+
+module.exports = { setup, unsetup };

package/lib/sounds.js

@@ -0,0 +1,248 @@
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const MACOS_SOUNDS_DIR = '/System/Library/Sounds';
+const FREEDESKTOP_DIRS = [
+  '/usr/share/sounds/freedesktop/stereo',
+  '/usr/share/sounds/gnome/default/alerts',
+  '/usr/share/sounds/ubuntu/stereo',
+];
+const WINDOWS_SOUNDS_DIR = 'C:\\Windows\\Media';
+
+// Presets: distinct sounds for different events
+const PRESETS = {
+  done: {
+    // Descending two-tone: satisfying "complete" feel
+    macos: 'Glass',
+    synth: { tones: [{ freq: 880, start: 0 }, { freq: 660, start: 0.15 }], duration: 0.35 },
+  },
+  input: {
+    // Ascending two-tone: questioning "hey, look here" feel
+    macos: 'Funk',
+    synth: { tones: [{ freq: 440, start: 0 }, { freq: 880, start: 0.12 }], duration: 0.4 },
+  },
+};
+
+function generateWav(options = {}) {
+  const {
+    frequency = 880,
+    frequency2 = 1320,
+    duration = 0.3,
+    sampleRate = 8000,
+    volume = 0.8,
+    tones = null,
+  } = options;
+
+  const numSamples = Math.floor(sampleRate * (tones ? duration : duration));
+  const dataSize = numSamples * 2; // 16-bit mono
+  const fileSize = 44 + dataSize;
+
+  const buf = Buffer.alloc(fileSize);
+
+  // RIFF header
+  buf.write('RIFF', 0);
+  buf.writeUInt32LE(fileSize - 8, 4);
+  buf.write('WAVE', 8);
+
+  // fmt chunk
+  buf.write('fmt ', 12);
+  buf.writeUInt32LE(16, 16);       // chunk size
+  buf.writeUInt16LE(1, 20);        // PCM format
+  buf.writeUInt16LE(1, 22);        // mono
+  buf.writeUInt32LE(sampleRate, 24);
+  buf.writeUInt32LE(sampleRate * 2, 28); // byte rate
+  buf.writeUInt16LE(2, 32);        // block align
+  buf.writeUInt16LE(16, 34);       // bits per sample
+
+  // data chunk
+  buf.write('data', 36);
+  buf.writeUInt32LE(dataSize, 40);
+
+  for (let i = 0; i < numSamples; i++) {
+    const t = i / sampleRate;
+    let sample;
+
+    if (tones) {
+      // Multi-tone mode: each tone starts at a given time offset
+      sample = 0;
+      for (const tone of tones) {
+        const tLocal = t - tone.start;
+        if (tLocal >= 0) {
+          const decay = Math.exp(-tLocal * 12);
+          sample += Math.sin(2 * Math.PI * tone.freq * tLocal) * decay;
+        }
+      }
+      sample = sample / tones.length * volume;
+    } else {
+      // Default: two simultaneous tones with decay
+      const decay = Math.exp(-t * 10);
+      const s1 = Math.sin(2 * Math.PI * frequency * t);
+      const s2 = Math.sin(2 * Math.PI * frequency2 * t) * 0.6;
+      sample = (s1 + s2) * decay * volume;
+    }
+
+    const value = Math.max(-1, Math.min(1, sample));
+    buf.writeInt16LE(Math.floor(value * 32767), 44 + i * 2);
+  }
+
+  return buf;
+}
+
+function synthesizePreset(presetName) {
+  const preset = PRESETS[presetName];
+  if (!preset) return null;
+  const wavBuf = generateWav(preset.synth);
+  const tmpPath = path.join(os.tmpdir(), 'tonton-' + presetName + '-' + process.pid + '.wav');
+  fs.writeFileSync(tmpPath, wavBuf);
+  return { filePath: tmpPath, cleanup: true };
+}
+
+function resolveMacosSound(name) {
+  if (name === 'default' || name === 'chime') name = 'Ping';
+
+  // Try exact match first
+  const filePath = path.join(MACOS_SOUNDS_DIR, name + '.aiff');
+  if (fs.existsSync(filePath)) {
+    return { filePath, cleanup: false };
+  }
+
+  // Try case-insensitive
+  try {
+    const files = fs.readdirSync(MACOS_SOUNDS_DIR);
+    const match = files.find(f => f.toLowerCase() === (name + '.aiff').toLowerCase());
+    if (match) {
+      return { filePath: path.join(MACOS_SOUNDS_DIR, match), cleanup: false };
+    }
+  } catch {}
+
+  return null;
+}
+
+function resolveLinuxSound(name) {
+  if (name !== 'default' && name !== 'chime') {
+    // Try to find a named sound in freedesktop dirs
+    for (const dir of FREEDESKTOP_DIRS) {
+      for (const ext of ['.oga', '.ogg', '.wav']) {
+        const filePath = path.join(dir, name + ext);
+        if (fs.existsSync(filePath)) {
+          return { filePath, cleanup: false };
+        }
+      }
+    }
+  }
+
+  // Try default freedesktop sounds
+  const defaults = ['complete.oga', 'bell.oga', 'message-new-instant.oga', 'message.oga'];
+  for (const dir of FREEDESKTOP_DIRS) {
+    for (const file of defaults) {
+      const filePath = path.join(dir, file);
+      if (fs.existsSync(filePath)) {
+        return { filePath, cleanup: false };
+      }
+    }
+  }
+
+  return null;
+}
+
+function resolveWindowsSound(name) {
+  if (name !== 'default' && name !== 'chime') {
+    const filePath = path.join(WINDOWS_SOUNDS_DIR, name + '.wav');
+    if (fs.existsSync(filePath)) {
+      return { filePath, cleanup: false };
+    }
+  }
+
+  const defaults = ['notify.wav', 'chimes.wav', 'tada.wav', 'Windows Notify System Generic.wav'];
+  for (const file of defaults) {
+    const filePath = path.join(WINDOWS_SOUNDS_DIR, file);
+    if (fs.existsSync(filePath)) {
+      return { filePath, cleanup: false };
+    }
+  }
+
+  return null;
+}
+
+function synthesizeToTemp() {
+  const wavBuf = generateWav();
+  const tmpPath = path.join(os.tmpdir(), 'tonton-chime-' + process.pid + '.wav');
+  fs.writeFileSync(tmpPath, wavBuf);
+  return { filePath: tmpPath, cleanup: true };
+}
+
+function resolveSound(name = 'default') {
+  const platform = process.platform;
+  const preset = PRESETS[name];
+
+  // If it's a preset (done/input), use platform-specific sound or synth
+  if (preset) {
+    if (platform === 'darwin') {
+      return resolveMacosSound(preset.macos) || synthesizePreset(name);
+    }
+    return synthesizePreset(name);
+  }
+
+  if (platform === 'darwin') {
+    return resolveMacosSound(name) || synthesizeToTemp();
+  }
+
+  if (platform === 'linux') {
+    return resolveLinuxSound(name) || synthesizeToTemp();
+  }
+
+  if (platform === 'win32') {
+    return resolveWindowsSound(name) || synthesizeToTemp();
+  }
+
+  // Unknown platform — synthesize
+  return synthesizeToTemp();
+}
+
+function listSounds() {
+  const platform = process.platform;
+  const sounds = [];
+
+  if (platform === 'darwin') {
+    try {
+      const files = fs.readdirSync(MACOS_SOUNDS_DIR);
+      for (const f of files) {
+        if (f.endsWith('.aiff')) {
+          sounds.push(f.replace('.aiff', ''));
+        }
+      }
+    } catch {}
+  } else if (platform === 'linux') {
+    for (const dir of FREEDESKTOP_DIRS) {
+      try {
+        const files = fs.readdirSync(dir);
+        for (const f of files) {
+          const name = f.replace(/\.(oga|ogg|wav)$/, '');
+          if (name !== f && !sounds.includes(name)) {
+            sounds.push(name);
+          }
+        }
+      } catch {}
+    }
+  } else if (platform === 'win32') {
+    try {
+      const files = fs.readdirSync(WINDOWS_SOUNDS_DIR);
+      for (const f of files) {
+        if (f.endsWith('.wav')) {
+          sounds.push(f.replace('.wav', ''));
+        }
+      }
+    } catch {}
+  }
+
+  if (!sounds.includes('chime')) {
+    sounds.push('chime');
+  }
+
+  return sounds.sort();
+}
+
+module.exports = { resolveSound, listSounds, generateWav };

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "tonton-cli",
+  "version": "1.0.0",
+  "description": "Play a notification sound from the CLI. Zero dependencies. Perfect for AI coding tool hooks.",
+  "keywords": [
+    "notification",
+    "sound",
+    "beep",
+    "alert",
+    "cli",
+    "claude-code",
+    "codex",
+    "hook",
+    "bell",
+    "ding"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/kyrolloszakaria/tonton.git"
+  },
+  "homepage": "https://github.com/kyrolloszakaria/tonton#readme",
+  "bugs": {
+    "url": "https://github.com/kyrolloszakaria/tonton/issues"
+  },
+  "bin": {
+    "tonton": "bin/tonton.js"
+  },
+  "main": "./lib/index.js",
+  "exports": {
+    ".": {
+      "import": "./lib/index.mjs",
+      "require": "./lib/index.js"
+    }
+  },
+  "files": [
+    "bin/",
+    "lib/",
+    "LICENSE",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=14.0.0"
+  },
+  "scripts": {
+    "test": "node test/test.js"
+  }
+}