pingthings 0.3.0 → 0.5.0

package/src/cli/select.js

@@ -45,37 +45,41 @@ export default async function select(args) {
     output: process.stdout,
   });
 
-  const ask = () => {
-    rl.question('> ', (answer) => {
-      const trimmed = answer.trim().toLowerCase();
-
-      if (trimmed === 'q' || trimmed === 'quit' || trimmed === '') {
+  await new Promise((resolve) => {
+    const ask = () => {
+      rl.question('> ', (answer) => {
+        const trimmed = answer.trim().toLowerCase();
+
+        if (trimmed === 'q' || trimmed === 'quit' || trimmed === '') {
+          rl.close();
+          resolve();
+          return;
+        }
+
+        const num = parseInt(trimmed, 10);
+        if (isNaN(num) || num < 1 || num > packs.length) {
+          console.log(`Enter 1-${packs.length} or q to quit.`);
+          ask();
+          return;
+        }
+
+        const chosen = packs[num - 1];
+        config.activePack = chosen.name;
+        writeConfig(config);
+
+        // Preview a sound from the chosen pack
+        const sounds = getPackSounds(chosen.name);
+        if (sounds.length > 0) {
+          const sample = sounds[Math.floor(Math.random() * sounds.length)];
+          playSound(sample, config.volume);
+        }
+
+        console.log(`\nActive pack set to: ${chosen.name}`);
         rl.close();
-        return;
-      }
-
-      const num = parseInt(trimmed, 10);
-      if (isNaN(num) || num < 1 || num > packs.length) {
-        console.log(`Enter 1-${packs.length} or q to quit.`);
-        ask();
-        return;
-      }
-
-      const chosen = packs[num - 1];
-      config.activePack = chosen.name;
-      writeConfig(config);
-
-      // Preview a sound from the chosen pack
-      const sounds = getPackSounds(chosen.name);
-      if (sounds.length > 0) {
-        const sample = sounds[Math.floor(Math.random() * sounds.length)];
-        playSound(sample, config.volume);
-      }
-
-      console.log(`\nActive pack set to: ${chosen.name}`);
-      rl.close();
-    });
-  };
-
-  ask();
+        resolve();
+      });
+    };
+
+    ask();
+  });
 }

package/src/cli/sounds.js

@@ -0,0 +1,76 @@
+import { readConfig } from '../config.js';
+import { getPackSounds, resolvePack, getPackEvents, getEventSounds } from '../packs.js';
+import { basename } from 'node:path';
+
+function showHelp() {
+  console.log(`
+Usage: pingthings sounds [pack]
+
+List all individual sounds in a pack.
+
+Arguments:
+  pack    Pack to list sounds from (defaults to active pack)
+
+Options:
+  --events    Show sounds grouped by event mapping
+
+Examples:
+  pingthings sounds                      List sounds in active pack
+  pingthings sounds openarena-announcer  List sounds in a specific pack
+  pingthings sounds --events             Show event mappings
+`);
+}
+
+export default function sounds(args) {
+  if (args.includes('--help') || args.includes('-h')) {
+    showHelp();
+    return;
+  }
+
+  const showEvents = args.includes('--events');
+  const packName = args.find(a => !a.startsWith('-')) || readConfig().activePack;
+
+  const pack = resolvePack(packName);
+  if (!pack) {
+    console.error(`Pack not found: ${packName}`);
+    console.error('Run "pingthings list" to see available packs.');
+    process.exit(1);
+  }
+
+  const allSounds = getPackSounds(packName);
+
+  if (showEvents) {
+    const events = getPackEvents(packName);
+    console.log(`\n${packName} — sounds by event:\n`);
+
+    for (const event of events) {
+      const eventSounds = getEventSounds(packName, event);
+      console.log(`  ${event}:`);
+      for (const s of eventSounds) {
+        console.log(`    ${basename(s)}`);
+      }
+    }
+
+    // Show unmapped sounds
+    const mappedPaths = new Set();
+    for (const event of events) {
+      for (const s of getEventSounds(packName, event)) {
+        mappedPaths.add(s);
+      }
+    }
+    const unmapped = allSounds.filter(s => !mappedPaths.has(s));
+    if (unmapped.length > 0) {
+      console.log('  (unmapped):');
+      for (const s of unmapped) {
+        console.log(`    ${basename(s)}`);
+      }
+    }
+  } else {
+    console.log(`\n${packName} — ${allSounds.length} sounds:\n`);
+    for (const s of allSounds) {
+      console.log(`  ${basename(s)}`);
+    }
+  }
+
+  console.log('');
+}

package/src/cli/theme.js

@@ -57,11 +57,44 @@ const THEMES = {
       blocked: '0ad-civilizations',
     },
   },
+  'professional': {
+    description: 'Clean and minimal — Kenney UI sounds for everything',
+    activePack: 'kenney-interface',
+    eventPacks: {
+      done: 'kenney-interface',
+      permission: 'kenney-interface',
+      complete: 'kenney-interface',
+      error: 'kenney-interface',
+      blocked: 'kenney-interface',
+    },
+  },
+  '8bit': {
+    description: 'Pure retro — 8-bit chiptune for everything',
+    activePack: 'retro-8bit',
+    eventPacks: {
+      done: 'retro-8bit',
+      permission: 'retro-8bit',
+      complete: 'retro-8bit',
+      error: 'retro-8bit',
+      blocked: 'retro-8bit',
+    },
+  },
+  'space': {
+    description: 'Space station — Warzone 2100 + Kenney sci-fi',
+    activePack: 'kenney-scifi',
+    eventPacks: {
+      done: 'kenney-scifi',
+      permission: 'warzone2100-command',
+      complete: 'warzone2100-command',
+      error: 'kenney-scifi',
+      blocked: 'kenney-scifi',
+    },
+  },
   'chaos': {
     description: 'Random pack for every event — maximum variety',
     activePack: '7kaa-soldiers',
     eventPacks: {
-      done: '7kaa-soldiers',
+      done: 'retro-8bit',
       permission: 'openarena-announcer',
       complete: 'warzone2100-command',
       error: 'freedoom-arsenal',

package/src/cli/uninstall.js

@@ -25,6 +25,11 @@ export default function uninstall(args) {
     return;
   }
 
+  if (packName.includes('..') || packName.includes('/') || packName.includes('\\')) {
+    console.error('Invalid pack name.');
+    process.exit(1);
+  }
+
   const userPackDir = join(getConfigDir(), 'packs', packName);
 
   if (!existsSync(userPackDir)) {

package/src/config.js

@@ -8,6 +8,8 @@ const DEFAULTS = {
   specificSound: null,
   volume: 100,
   eventPacks: {},
+  cooldown: true,
+  quietHours: null,
 };
 
 export function getConfigDir() {
@@ -45,6 +47,34 @@ export function getDefaults() {
   return { ...DEFAULTS };
 }
 
+export function getLastPlayed() {
+  const path = join(getConfigDir(), '.last-played');
+  try {
+    return readFileSync(path, 'utf8').trim();
+  } catch {
+    return null;
+  }
+}
+
+export function setLastPlayed(soundPath) {
+  const path = join(getConfigDir(), '.last-played');
+  try {
+    writeFileSync(path, soundPath, 'utf8');
+  } catch {}
+}
+
+export function isQuietHours(config) {
+  if (!config.quietHours) return false;
+  const [start, end] = config.quietHours.split('-').map(Number);
+  if (isNaN(start) || isNaN(end)) return false;
+  const hour = new Date().getHours();
+  if (start < end) {
+    return hour >= start && hour < end;
+  }
+  // Wraps midnight (e.g., 22-7)
+  return hour >= start || hour < end;
+}
+
 export const VALID_MODES = ['random', 'specific', 'informational'];
 
 export const VALID_EVENTS = ['done', 'permission', 'complete', 'error', 'blocked'];

package/src/packs.js

@@ -57,6 +57,7 @@ function scanDirectory(dir, isBuiltIn) {
         description: manifest?.description || '',
         license: manifest?.license || 'Unknown',
         credits: manifest?.credits || '',
+        category: manifest?.category || 'other',
         location: packDir,
         soundCount: sounds.length,
         isBuiltIn,

package/src/player.js

@@ -2,17 +2,23 @@ import { spawn, execFileSync } from 'node:child_process';
 import { existsSync } from 'node:fs';
 import { platform } from 'node:os';
 
+function commandExists(cmd) {
+  try {
+    execFileSync('which', [cmd], { stdio: 'pipe' });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
 function getPlayerCommand() {
   switch (platform()) {
     case 'darwin':
       return 'afplay';
     case 'linux': {
-      try {
-        execFileSync('which', ['paplay'], { stdio: 'pipe' });
-        return 'paplay';
-      } catch {
-        return 'aplay';
-      }
+      if (commandExists('paplay')) return 'paplay';
+      if (commandExists('aplay')) return 'aplay';
+      return null;
     }
     case 'win32':
       return 'powershell';
@@ -26,20 +32,16 @@ function buildArgs(cmd, filePath, volume) {
 
   switch (cmd) {
     case 'afplay': {
-      // afplay volume: 0.0 to 1.0
       const afplayVol = (vol / 100).toFixed(2);
       return ['-v', afplayVol, filePath];
     }
     case 'paplay': {
-      // paplay volume: 0 to 65536 (100% = 65536)
       const paplayVol = Math.round((vol / 100) * 65536).toString();
       return ['--volume', paplayVol, filePath];
     }
     case 'aplay':
-      // aplay doesn't support volume natively
       return [filePath];
     case 'powershell': {
-      // PowerShell SoundPlayer doesn't support volume, but it plays the file
       const script = `(New-Object System.Media.SoundPlayer '${filePath.replace(/'/g, "''")}').PlaySync()`;
       return ['-NoProfile', '-Command', script];
     }
@@ -55,7 +57,8 @@ export function playSound(filePath, volume) {
 
   const cmd = getPlayerCommand();
   if (!cmd) {
-    throw new Error(`Unsupported platform: ${platform()}. Supported: macOS, Linux, Windows.`);
+    // No audio player available — skip silently (e.g. CI environments)
+    return;
   }
 
   const args = buildArgs(cmd, filePath, volume);
@@ -65,6 +68,8 @@ export function playSound(filePath, volume) {
     stdio: 'ignore',
   });
 
+  // Handle spawn errors gracefully (command not found, permission denied)
+  child.on('error', () => {});
   child.unref();
 }
 
@@ -75,7 +80,7 @@ export function playSoundSync(filePath, volume) {
 
   const cmd = getPlayerCommand();
   if (!cmd) {
-    throw new Error(`Unsupported platform: ${platform()}. Supported: macOS, Linux, Windows.`);
+    return;
   }
 
   const args = buildArgs(cmd, filePath, volume);