klaudio 0.1.0

package/src/extractor.js

@@ -0,0 +1,203 @@
+import { execFile } from "node:child_process";
+import { readdir, mkdir, stat, chmod } from "node:fs/promises";
+import { createWriteStream } from "node:fs";
+import { join, extname, basename, resolve as resolvePath } from "node:path";
+import { platform, homedir, tmpdir } from "node:os";
+import { pipeline } from "node:stream/promises";
+
+const TOOLS_DIR = join(homedir(), ".klonk", "tools");
+
+// Packed audio formats that vgmstream-cli can convert to WAV
+const PACKED_EXTENSIONS = new Set([".wem", ".bnk", ".bank", ".fsb", ".pck"]);
+
+/**
+ * Check if a file is a packed audio format we can extract.
+ */
+export function isPackedAudio(filePath) {
+  return PACKED_EXTENSIONS.has(extname(filePath).toLowerCase());
+}
+
+/**
+ * Check if a game directory has extractable packed audio.
+ */
+export async function hasPackedAudio(gamePath) {
+  const formats = { wem: 0, bnk: 0, bank: 0, fsb: 0, pck: 0 };
+  await scanForPackedAudio(gamePath, formats, 0);
+  return {
+    total: Object.values(formats).reduce((a, b) => a + b, 0),
+    formats,
+  };
+}
+
+async function scanForPackedAudio(dir, formats, depth) {
+  if (depth > 5) return;
+  try {
+    const entries = await readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        await scanForPackedAudio(join(dir, entry.name), formats, depth + 1);
+      } else if (entry.isFile()) {
+        const ext = extname(entry.name).toLowerCase().slice(1);
+        if (ext in formats) formats[ext]++;
+      }
+      // Stop early if we found enough
+      if (Object.values(formats).reduce((a, b) => a + b, 0) > 100) return;
+    }
+  } catch { /* skip */ }
+}
+
+/**
+ * Get the path to vgmstream-cli, downloading it if needed.
+ */
+export async function getVgmstreamPath(onProgress) {
+  const os = platform();
+  const exeName = os === "win32" ? "vgmstream-cli.exe" : "vgmstream-cli";
+  const toolPath = join(TOOLS_DIR, exeName);
+
+  // Check if already downloaded
+  try {
+    await stat(toolPath);
+    return toolPath;
+  } catch { /* not found, need to download */ }
+
+  if (onProgress) onProgress("Downloading vgmstream-cli...");
+
+  await mkdir(TOOLS_DIR, { recursive: true });
+
+  // Download the appropriate release
+  const releaseUrl = os === "win32"
+    ? "https://github.com/vgmstream/vgmstream-releases/releases/download/nightly/vgmstream-win64.zip"
+    : os === "darwin"
+      ? "https://github.com/vgmstream/vgmstream-releases/releases/download/nightly/vgmstream-macos.zip"
+      : "https://github.com/vgmstream/vgmstream-releases/releases/download/nightly/vgmstream-linux.zip";
+
+  const zipPath = join(tmpdir(), "vgmstream.zip");
+
+  // Download using Node.js fetch
+  const response = await fetch(releaseUrl, { redirect: "follow" });
+  if (!response.ok) throw new Error(`Failed to download vgmstream: ${response.status}`);
+
+  const fileStream = createWriteStream(zipPath);
+  await pipeline(response.body, fileStream);
+
+  if (onProgress) onProgress("Extracting vgmstream-cli...");
+
+  // Extract using tar (handles zip on modern systems) or PowerShell on Windows
+  if (os === "win32") {
+    await new Promise((resolve, reject) => {
+      execFile("powershell.exe", [
+        "-NoProfile", "-Command",
+        `Expand-Archive -Path '${zipPath}' -DestinationPath '${TOOLS_DIR}' -Force`,
+      ], { windowsHide: true }, (err) => {
+        if (err) reject(err);
+        else resolve();
+      });
+    });
+  } else {
+    await new Promise((resolve, reject) => {
+      execFile("unzip", ["-o", zipPath, "-d", TOOLS_DIR], (err) => {
+        if (err) reject(err);
+        else resolve();
+      });
+    });
+    // Make executable
+    try { await chmod(toolPath, 0o755); } catch { /* ignore */ }
+  }
+
+  // Verify it exists
+  await stat(toolPath);
+  return toolPath;
+}
+
+/**
+ * Find all extractable audio files in a game directory.
+ */
+export async function findPackedAudioFiles(gamePath, maxFiles = 50) {
+  const results = [];
+
+  async function scan(dir, depth = 0) {
+    if (depth > 5 || results.length >= maxFiles) return;
+    try {
+      const entries = await readdir(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (results.length >= maxFiles) break;
+        const fullPath = join(dir, entry.name);
+        if (entry.isDirectory()) {
+          const lower = entry.name.toLowerCase();
+          if (["__pycache__", "node_modules", ".git"].some(s => lower.includes(s))) continue;
+          await scan(fullPath, depth + 1);
+        } else if (entry.isFile()) {
+          const ext = extname(entry.name).toLowerCase();
+          // Formats vgmstream-cli can convert directly
+          // (.bnk needs bnkextr preprocessing — skip for now)
+          if (ext === ".wem" || ext === ".fsb" || ext === ".bank") {
+            results.push({ path: fullPath, name: entry.name, dir });
+          }
+        }
+      }
+    } catch { /* skip */ }
+  }
+
+  await scan(gamePath);
+  return results;
+}
+
+/**
+ * Extract/convert a packed audio file to WAV using vgmstream-cli.
+ *
+ * @param {string} inputPath - Path to .wem/.bnk/.bank/.fsb file
+ * @param {string} outputDir - Directory to write WAV files to
+ * @param {string} vgmstreamPath - Path to vgmstream-cli binary
+ * @returns {string[]} Array of output WAV file paths
+ */
+export async function extractToWav(inputPath, outputDir, vgmstreamPath) {
+  await mkdir(outputDir, { recursive: true });
+
+  // Resolve to absolute OS-native paths (critical on Windows where
+  // MSYS uses forward slashes but native exes need backslashes)
+  const absInput = resolvePath(inputPath);
+  const ext = extname(absInput).toLowerCase();
+  const baseName = basename(absInput, ext);
+  const outputPath = resolvePath(join(outputDir, `${baseName}.wav`));
+
+  return new Promise((resolve, reject) => {
+    // For .bnk files, vgmstream can extract subsongs
+    // First try with -S flag to get subsong count
+    execFile(vgmstreamPath, ["-m", absInput], { windowsHide: true, timeout: 10000 }, (err, stdout) => {
+      if (err) {
+        // Single file conversion
+        execFile(vgmstreamPath, ["-o", outputPath, absInput], { windowsHide: true, timeout: 30000 }, (err2) => {
+          if (err2) reject(new Error(`Failed to convert ${basename(absInput)}: ${err2.message}`));
+          else resolve([outputPath]);
+        });
+        return;
+      }
+
+      // Check if it has multiple subsongs
+      const subsongMatch = stdout.match(/stream count:\s*(\d+)/i) || stdout.match(/subsong count:\s*(\d+)/i);
+      const subsongCount = subsongMatch ? parseInt(subsongMatch[1]) : 1;
+
+      if (subsongCount <= 1) {
+        // Single conversion
+        execFile(vgmstreamPath, ["-o", outputPath, absInput], { windowsHide: true, timeout: 30000 }, (err2) => {
+          if (err2) reject(new Error(`Failed to convert ${basename(absInput)}: ${err2.message}`));
+          else resolve([outputPath]);
+        });
+      } else {
+        // Extract each subsong (up to 20)
+        const count = Math.min(subsongCount, 20);
+        const outputs = [];
+        let done = 0;
+
+        for (let i = 1; i <= count; i++) {
+          const subOutput = join(outputDir, `${baseName}_${String(i).padStart(3, "0")}.wav`);
+          execFile(vgmstreamPath, ["-o", resolvePath(subOutput), "-s", String(i), absInput], { windowsHide: true, timeout: 30000 }, (err2) => {
+            if (!err2) outputs.push(subOutput);
+            done++;
+            if (done === count) resolve(outputs);
+          });
+        }
+      }
+    });
+  });
+}

package/src/installer.js

@@ -0,0 +1,128 @@
+import { readFile, writeFile, mkdir, copyFile } from "node:fs/promises";
+import { join, basename, extname } from "node:path";
+import { homedir } from "node:os";
+import { getHookPlayCommand, processSound } from "./player.js";
+import { EVENTS } from "./presets.js";
+
+/**
+ * Get the target directory based on install scope.
+ */
+function getTargetDir(scope) {
+  if (scope === "global") {
+    return join(homedir(), ".claude");
+  }
+  return join(process.cwd(), ".claude");
+}
+
+/**
+ * Install sounds and configure hooks.
+ *
+ * @param {object} options
+ * @param {string} options.scope - "global" or "project"
+ * @param {Record<string, string>} options.sounds - Map of event ID -> source sound file path
+ */
+export async function install({ scope, sounds }) {
+  const claudeDir = getTargetDir(scope);
+  const soundsDir = join(claudeDir, "sounds");
+  const settingsFile = join(claudeDir, "settings.json");
+
+  // Create sounds directory
+  await mkdir(soundsDir, { recursive: true });
+
+  // Process and copy sound files (clamp to 10s with fadeout via ffmpeg)
+  const installedSounds = {};
+  for (const [eventId, sourcePath] of Object.entries(sounds)) {
+    const processedPath = await processSound(sourcePath);
+    const srcName = basename(sourcePath, extname(sourcePath));
+    const outExt = extname(processedPath) || ".wav";
+    const fileName = `${eventId}-${srcName}${outExt}`;
+    const destPath = join(soundsDir, fileName);
+    await copyFile(processedPath, destPath);
+    installedSounds[eventId] = destPath;
+  }
+
+  // Read existing settings
+  let settings = {};
+  try {
+    const existing = await readFile(settingsFile, "utf-8");
+    settings = JSON.parse(existing);
+  } catch {
+    // File doesn't exist or is invalid — start fresh
+  }
+
+  // Build hooks config
+  if (!settings.hooks) {
+    settings.hooks = {};
+  }
+
+  for (const [eventId, soundPath] of Object.entries(installedSounds)) {
+    const event = EVENTS[eventId];
+    if (!event) continue;
+
+    const hookEvent = event.hookEvent;
+    const playCommand = getHookPlayCommand(soundPath);
+
+    // Check if there's already a klonk hook for this event
+    if (!settings.hooks[hookEvent]) {
+      settings.hooks[hookEvent] = [];
+    }
+
+    // Remove any existing klonk entries
+    settings.hooks[hookEvent] = settings.hooks[hookEvent].filter(
+      (entry) => !entry._klonk
+    );
+
+    // Add our hook
+    settings.hooks[hookEvent].push({
+      _klonk: true,
+      matcher: "",
+      hooks: [
+        {
+          type: "command",
+          command: playCommand,
+        },
+      ],
+    });
+  }
+
+  // Write settings
+  await writeFile(settingsFile, JSON.stringify(settings, null, 2) + "\n", "utf-8");
+
+  return {
+    soundsDir,
+    settingsFile,
+    installedSounds,
+  };
+}
+
+/**
+ * Uninstall klonk hooks from settings.
+ */
+export async function uninstall(scope) {
+  const claudeDir = getTargetDir(scope);
+  const settingsFile = join(claudeDir, "settings.json");
+
+  try {
+    const existing = await readFile(settingsFile, "utf-8");
+    const settings = JSON.parse(existing);
+
+    if (settings.hooks) {
+      for (const [event, entries] of Object.entries(settings.hooks)) {
+        settings.hooks[event] = entries.filter(
+          (entry) => !entry._klonk
+        );
+        if (settings.hooks[event].length === 0) {
+          delete settings.hooks[event];
+        }
+      }
+      if (Object.keys(settings.hooks).length === 0) {
+        delete settings.hooks;
+      }
+    }
+
+    await writeFile(settingsFile, JSON.stringify(settings, null, 2) + "\n", "utf-8");
+    return true;
+  } catch {
+    return false;
+  }
+}

package/src/player.js

@@ -0,0 +1,359 @@
+import { execFile, spawn } from "node:child_process";
+import { platform } from "node:os";
+import { resolve, extname, basename, join } from "node:path";
+import { open, mkdir, stat } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { createHash } from "node:crypto";
+
+const MAX_PLAY_SECONDS = 10;
+const FADE_SECONDS = 2; // fade out over last 2 seconds
+
+// Formats that Windows MediaPlayer (PresentationCore) can play natively
+const MEDIA_PLAYER_FORMATS = new Set([".wav", ".mp3", ".wma", ".aac"]);
+
+/**
+ * Determine the best playback strategy for a file on the current OS.
+ */
+function getPlaybackCommand(absPath, { withFade = false } = {}) {
+  const os = platform();
+  const ext = extname(absPath).toLowerCase();
+
+  // ffplay args with optional fade-out and silence-skip
+  const ffplayArgs = ["-nodisp", "-autoexit", "-loglevel", "quiet"];
+  if (withFade) {
+    // silenceremove strips leading silence (below -50dB threshold)
+    // afade fades out over last FADE_SECONDS before the MAX_PLAY_SECONDS cut
+    const fadeStart = MAX_PLAY_SECONDS - FADE_SECONDS;
+    const filters = [
+      "silenceremove=start_periods=1:start_silence=0.1:start_threshold=-50dB",
+      `afade=t=out:st=${fadeStart}:d=${FADE_SECONDS}`,
+    ];
+    ffplayArgs.push("-af", filters.join(","));
+    ffplayArgs.push("-t", String(MAX_PLAY_SECONDS));
+  }
+  ffplayArgs.push(absPath);
+
+  if (os === "darwin") {
+    // afplay doesn't support filters — use ffplay if fade needed, fall back to afplay
+    if (withFade) {
+      return { type: "exec", cmd: "ffplay", args: ffplayArgs, fallback: "afplay" };
+    }
+    return { type: "exec", cmd: "afplay", args: [absPath] };
+  }
+
+  if (os === "win32") {
+    if (withFade || !MEDIA_PLAYER_FORMATS.has(ext)) {
+      // Prefer ffplay for fade support and non-native formats; fall back to PowerShell
+      return {
+        type: "exec",
+        cmd: "ffplay",
+        args: ffplayArgs,
+        fallback: "powershell",
+      };
+    }
+    return { type: "powershell", absPath };
+  }
+
+  // Linux
+  if (ext === ".wav" && !withFade) {
+    return { type: "exec", cmd: "aplay", args: [absPath] };
+  }
+  return {
+    type: "exec",
+    cmd: "ffplay",
+    args: ffplayArgs,
+  };
+}
+
+function buildPsCommand(absPath, maxSeconds = 0) {
+  const limit = maxSeconds > 0 ? maxSeconds : 30;
+  const fadeStart = (limit - FADE_SECONDS) * 10; // in 100ms ticks
+  return `
+    Add-Type -AssemblyName PresentationCore
+    $player = New-Object System.Windows.Media.MediaPlayer
+    $player.Open([System.Uri]::new("${absPath.replace(/\\/g, "/")}"))
+    Start-Sleep -Milliseconds 300
+    $player.Play()
+    $player.Volume = 1.0
+    $elapsed = 0
+    while ($player.Position -lt $player.NaturalDuration.TimeSpan -and $player.NaturalDuration.HasTimeSpan -and $elapsed -lt ${limit * 10}) {
+      Start-Sleep -Milliseconds 100
+      $elapsed++
+      if ($elapsed -gt ${fadeStart} -and ${limit * 10} -gt ${fadeStart}) {
+        $remaining = ${limit * 10} - $elapsed
+        $total = ${FADE_SECONDS * 10}
+        if ($total -gt 0) { $player.Volume = [Math]::Max(0, [double]$remaining / [double]$total) }
+      }
+    }
+    $player.Stop()
+    $player.Close()
+  `.trim();
+}
+
+/**
+ * Get the duration of a WAV file in seconds by reading its header.
+ * Returns null if unable to determine.
+ */
+export async function getWavDuration(filePath) {
+  const absPath = resolve(filePath);
+  const ext = extname(absPath).toLowerCase();
+
+  // Try ffprobe first (handles all formats and non-standard WAV headers)
+  const ffDuration = await getFFprobeDuration(absPath);
+  if (ffDuration != null) return ffDuration;
+
+  // Fallback: parse WAV header directly
+  if (ext === ".wav") {
+    return getWavDurationFromHeader(absPath);
+  }
+
+  return null;
+}
+
+async function getWavDurationFromHeader(absPath) {
+  let fh;
+  try {
+    fh = await open(absPath, "r");
+    const header = Buffer.alloc(44);
+    await fh.read(header, 0, 44, 0);
+
+    // Verify RIFF/WAVE
+    if (header.toString("ascii", 0, 4) !== "RIFF") return null;
+    if (header.toString("ascii", 8, 12) !== "WAVE") return null;
+
+    // Read fmt chunk (assuming standard PCM at offset 20)
+    const channels = header.readUInt16LE(22);
+    const sampleRate = header.readUInt32LE(24);
+    const bitsPerSample = header.readUInt16LE(34);
+
+    if (sampleRate === 0 || channels === 0 || bitsPerSample === 0) return null;
+
+    // Data chunk size is at offset 40 in standard WAV
+    const dataSize = header.readUInt32LE(40);
+    const bytesPerSecond = sampleRate * channels * (bitsPerSample / 8);
+
+    if (bytesPerSecond === 0) return null;
+    return Math.round((dataSize / bytesPerSecond) * 10) / 10;
+  } catch {
+    return null;
+  } finally {
+    if (fh) await fh.close();
+  }
+}
+
+function getFFprobeDuration(absPath) {
+  return new Promise((res) => {
+    execFile(
+      "ffprobe",
+      ["-v", "quiet", "-show_entries", "format=duration", "-of", "csv=p=0", absPath],
+      { windowsHide: true, timeout: 5000 },
+      (err, stdout) => {
+        if (err) return res(null);
+        const val = parseFloat(stdout.trim());
+        if (isNaN(val)) return res(null);
+        res(Math.round(val * 10) / 10);
+      }
+    );
+  });
+}
+
+/**
+ * Play a sound file. Returns a promise that resolves when playback starts
+ * (not when it finishes — we don't want to block).
+ */
+export function playSound(filePath) {
+  const absPath = resolve(filePath);
+  const strategy = getPlaybackCommand(absPath);
+
+  return new Promise((resolvePromise) => {
+    if (strategy.type === "exec") {
+      const child = spawn(strategy.cmd, strategy.args, {
+        stdio: "ignore",
+        detached: true,
+        windowsHide: true,
+      });
+      child.unref();
+      resolvePromise();
+      child.on("error", () => {
+        if (strategy.fallback === "powershell") {
+          const ps = spawn("powershell.exe", ["-NoProfile", "-Command", buildPsCommand(absPath)], {
+            stdio: "ignore", detached: true, windowsHide: true,
+          });
+          ps.unref();
+        }
+      });
+    } else if (strategy.type === "powershell") {
+      const child = spawn("powershell.exe", ["-NoProfile", "-Command", buildPsCommand(absPath)], {
+        stdio: "ignore", detached: true, windowsHide: true,
+      });
+      child.unref();
+      resolvePromise();
+    }
+  });
+}
+
+/**
+ * Play a sound and wait for it to finish (for preview mode).
+ * Returns { promise, cancel } — call cancel() to stop playback immediately.
+ * Playback is clamped to MAX_PLAY_SECONDS.
+ */
+export function playSoundWithCancel(filePath) {
+  const absPath = resolve(filePath);
+  const strategy = getPlaybackCommand(absPath, { withFade: true });
+  let childProcess = null;
+  let timer = null;
+  let cancelled = false;
+
+  function killChild() {
+    if (childProcess && !childProcess.killed) {
+      try {
+        // On Windows, spawned processes need taskkill for the process tree
+        if (platform() === "win32") {
+          spawn("taskkill", ["/pid", String(childProcess.pid), "/f", "/t"], {
+            stdio: "ignore", windowsHide: true,
+          });
+        } else {
+          childProcess.kill("SIGTERM");
+        }
+      } catch { /* ignore */ }
+    }
+    if (timer) clearTimeout(timer);
+  }
+
+  const cancel = () => {
+    cancelled = true;
+    killChild();
+  };
+
+  const promise = new Promise((resolvePromise, reject) => {
+    function onDone(err) {
+      if (timer) clearTimeout(timer);
+      if (cancelled) return resolvePromise(); // cancelled — resolve, don't reject
+      if (err) reject(err);
+      else resolvePromise();
+    }
+
+    function startExec(cmd, args) {
+      childProcess = execFile(cmd, args, { windowsHide: true, timeout: (MAX_PLAY_SECONDS + 2) * 1000 }, (err) => {
+        if (err && strategy.fallback && !cancelled) {
+          if (strategy.fallback === "powershell") {
+            childProcess = execFile(
+              "powershell.exe",
+              ["-NoProfile", "-Command", buildPsCommand(absPath, MAX_PLAY_SECONDS)],
+              { windowsHide: true, timeout: (MAX_PLAY_SECONDS + 2) * 1000 },
+              (psErr) => onDone(psErr)
+            );
+          } else if (strategy.fallback === "afplay") {
+            // macOS: ffplay not available, fall back to afplay (no fade)
+            childProcess = execFile("afplay", [absPath], { timeout: (MAX_PLAY_SECONDS + 2) * 1000 }, (afErr) => onDone(afErr));
+          }
+        } else {
+          onDone(err);
+        }
+      });
+
+      // Set a hard timeout to kill after MAX_PLAY_SECONDS
+      timer = setTimeout(() => {
+        killChild();
+        resolvePromise();
+      }, MAX_PLAY_SECONDS * 1000);
+    }
+
+    if (strategy.type === "exec") {
+      startExec(strategy.cmd, strategy.args);
+    } else if (strategy.type === "powershell") {
+      childProcess = execFile(
+        "powershell.exe",
+        ["-NoProfile", "-Command", buildPsCommand(absPath, MAX_PLAY_SECONDS)],
+        { windowsHide: true, timeout: (MAX_PLAY_SECONDS + 2) * 1000 },
+        (err) => onDone(err)
+      );
+      timer = setTimeout(() => {
+        killChild();
+        resolvePromise();
+      }, MAX_PLAY_SECONDS * 1000);
+    }
+  });
+
+  return { promise, cancel };
+}
+
+/**
+ * Play a sound and wait for it to finish (legacy — no cancel support).
+ */
+export function playSoundSync(filePath) {
+  return playSoundWithCancel(filePath).promise;
+}
+
+/**
+ * Process a sound file with ffmpeg: strip leading silence, clamp to MAX_PLAY_SECONDS,
+ * and fade out over the last FADE_SECONDS. Returns the path to the processed WAV file.
+ * If ffmpeg is not available or the file is already short enough, returns the original path.
+ */
+export async function processSound(filePath) {
+  const absPath = resolve(filePath);
+
+  // First check duration — skip processing if already short
+  const duration = await getWavDuration(absPath);
+  if (duration != null && duration <= MAX_PLAY_SECONDS) {
+    return absPath; // Already short enough, no processing needed
+  }
+
+  // Build a deterministic output path based on input file hash
+  const hash = createHash("md5").update(absPath).digest("hex").slice(0, 12);
+  const outDir = join(tmpdir(), "klonk-processed");
+  const outName = `${basename(absPath, extname(absPath))}_${hash}.wav`;
+  const outPath = join(outDir, outName);
+
+  // Check if already processed
+  try {
+    await stat(outPath);
+    return outPath; // Already exists
+  } catch { /* needs processing */ }
+
+  await mkdir(outDir, { recursive: true });
+
+  // Build ffmpeg filter chain: silence strip → fade out → clamp duration
+  const fadeStart = MAX_PLAY_SECONDS - FADE_SECONDS;
+  const filters = [
+    "silenceremove=start_periods=1:start_silence=0.1:start_threshold=-50dB",
+    `afade=t=out:st=${fadeStart}:d=${FADE_SECONDS}`,
+  ].join(",");
+
+  return new Promise((res) => {
+    execFile(
+      "ffmpeg",
+      [
+        "-y", "-i", absPath,
+        "-af", filters,
+        "-t", String(MAX_PLAY_SECONDS),
+        "-ar", "44100", "-ac", "2",
+        outPath,
+      ],
+      { windowsHide: true, timeout: 30000 },
+      (err) => {
+        if (err) {
+          // ffmpeg not available or failed — return original
+          res(absPath);
+        } else {
+          res(outPath);
+        }
+      },
+    );
+  });
+}
+
+/**
+ * Generate the shell command string for use in Claude Code hooks.
+ */
+export function getHookPlayCommand(soundFilePath) {
+  const normalized = soundFilePath.replace(/\\/g, "/");
+  const ext = extname(normalized).toLowerCase();
+  const needsFfplay = !MEDIA_PLAYER_FORMATS.has(ext);
+
+  if (needsFfplay) {
+    return `if command -v ffplay &>/dev/null; then ffplay -nodisp -autoexit -loglevel quiet "${normalized}" & elif [[ "$OSTYPE" == "darwin"* ]]; then afplay "${normalized}" & elif [[ "$OSTYPE" == "msys"* ]] || [[ "$OSTYPE" == "cygwin"* ]]; then powershell.exe -NoProfile -Command "Add-Type -AssemblyName PresentationCore; \\$p = New-Object System.Windows.Media.MediaPlayer; \\$p.Open([System.Uri]::new('$(cygpath -w "${normalized}")')); Start-Sleep -Milliseconds 200; \\$p.Play(); Start-Sleep -Seconds 2" & else aplay "${normalized}" & fi`;
+  }
+
+  return `if [[ "$OSTYPE" == "darwin"* ]]; then afplay "${normalized}" & elif [[ "$OSTYPE" == "msys"* ]] || [[ "$OSTYPE" == "cygwin"* ]]; then powershell.exe -NoProfile -Command "Add-Type -AssemblyName PresentationCore; \\$p = New-Object System.Windows.Media.MediaPlayer; \\$p.Open([System.Uri]::new('$(cygpath -w "${normalized}")')); Start-Sleep -Milliseconds 200; \\$p.Play(); Start-Sleep -Seconds 2" & else aplay "${normalized}" & fi`;
+}