klaudio 0.13.0 → 0.13.2

package/bin/cli.js

@@ -52,6 +52,27 @@ if (["help", "--help", "-h"].includes(process.argv[2])) {
   process.exit(0);
 }
 
+// Auto-update: check npm for a newer version and install it before showing UI
+async function autoUpdate() {
+  try {
+    const { createRequire } = await import("node:module");
+    const pkg = createRequire(import.meta.url)("../package.json");
+    const res = await fetch(`https://registry.npmjs.org/${pkg.name}/latest`, {
+      signal: AbortSignal.timeout(3000),
+    });
+    if (!res.ok) return;
+    const { version: latest } = await res.json();
+    if (latest === pkg.version) return;
+    console.log(`\n  Updating klaudio ${pkg.version} → ${latest}...\n`);
+    const { spawnSync } = await import("node:child_process");
+    spawnSync("npm", ["install", "-g", "klaudio@latest"], { stdio: "inherit" });
+    // Re-exec so the UI runs under the new version
+    const result = spawnSync("npx", ["--yes", "klaudio"], { stdio: "inherit" });
+    process.exit(result.status ?? 0);
+  } catch { /* ignore network/registry errors */ }
+}
+await autoUpdate();
+
 // Default: interactive installer UI
 const { run } = await import("../src/cli.js");
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "klaudio",
-  "version": "0.13.0",
+  "version": "0.13.2",
   "description": "Add sound effects to your coding sessions — play sounds when tasks complete, notifications arrive, and more",
   "type": "module",
   "bin": {

package/src/cli.js

@@ -294,7 +294,7 @@ const PresetScreen = ({ existingSounds, outdatedReasons, onNext, onReapply, onBa
 
 // ── Screen: Preview ─────────────────────────────────────────────
 const PreviewScreen = ({ presetId, sounds, onAccept, onBack, onUpdateSound }) => {
-  const preset = PRESETS[presetId];
+  const preset = PRESETS[presetId] ?? PRESETS[Object.keys(PRESETS)[0]];
   const eventIds = Object.keys(EVENTS);
   const [currentEvent, setCurrentEvent] = useState(0);
   const [playing, setPlaying] = useState(false);
@@ -1808,7 +1808,8 @@ const InstallApp = () => {
           onConfirm: () => setScreen(SCREEN.INSTALLING),
           onBack: () => {
             if (selectedGame) setScreen(SCREEN.GAME_SOUNDS);
-            else setScreen(SCREEN.PREVIEW);
+            else if (presetId) setScreen(SCREEN.PREVIEW);
+            else setScreen(SCREEN.PRESET);
           },
         });
 

package/src/installer.js

@@ -1,13 +1,9 @@
 import { readFile, writeFile, mkdir, copyFile } from "node:fs/promises";
 import { join, basename, extname } from "node:path";
 import { homedir } from "node:os";
-import { createRequire } from "node:module";
 import { getHookPlayCommand, processSound } from "./player.js";
 import { EVENTS } from "./presets.js";
 
-const _require = createRequire(import.meta.url);
-const KLAUDIO_VERSION = _require("../package.json").version;
-
 /**
  * Get the target directory based on install scope.
  */
@@ -39,7 +35,10 @@ export async function install({ scope, sounds, tts = false, voice, speed } = {})
   const installedSounds = {};
   for (const [eventId, sourcePath] of Object.entries(sounds)) {
     const processedPath = await processSound(sourcePath);
-    const srcName = basename(sourcePath, extname(sourcePath));
+    // Strip any accumulated eventId prefixes from previous installs
+    let srcName = basename(sourcePath, extname(sourcePath));
+    const prefixRe = new RegExp(`^(${Object.keys(EVENTS).join("|")})-`, "i");
+    while (prefixRe.test(srcName)) srcName = srcName.replace(prefixRe, "");
     const outExt = extname(processedPath) || ".wav";
     const fileName = `${eventId}-${srcName}${outExt}`;
     const destPath = join(soundsDir, fileName);
@@ -88,8 +87,6 @@ export async function install({ scope, sounds, tts = false, voice, speed } = {})
 
     // Add our hook
     settings.hooks[hookEvent].push({
-      _klaudio: true,
-      _klaudioVersion: KLAUDIO_VERSION,
       matcher: "",
       hooks: [
         {
@@ -119,37 +116,47 @@ export async function install({ scope, sounds, tts = false, voice, speed } = {})
  */
 async function installApprovalHooks(settings, soundPath, claudeDir) {
   const normalized = soundPath.replace(/\\/g, "/");
-  const scriptPath = join(claudeDir, "approval-notify.sh").replace(/\\/g, "/");
-
-  // Write the timer script
-  const script = `#!/usr/bin/env bash
-# klaudio: approval notification timer
-# Plays a sound + sends a system notification if a tool isn't approved within DELAY seconds.
-DELAY=120
-MARKER="/tmp/.claude-approval-pending"
-SOUND="${normalized}"
-
-case "$1" in
-  start)
-    TOKEN="$$-$(date +%s%N)"
-    # Store token and CWD so the delayed notification knows the project name
-    echo "$TOKEN" > "$MARKER"
-    echo "$PWD" >> "$MARKER"
-    (
-      sleep "$DELAY"
-      if [ -f "$MARKER" ] && [ "$(head -1 "$MARKER" 2>/dev/null)" = "$TOKEN" ]; then
-        PROJECT=$(tail -1 "$MARKER" 2>/dev/null | sed 's|.*[/\\\\]||')
-        rm -f "$MARKER"
-        npx klaudio play "$SOUND" 2>/dev/null
-        npx klaudio notify "\${PROJECT:-project}" "Waiting for your approval" 2>/dev/null
-        npx klaudio say "\${PROJECT:-project} needs your attention" 2>/dev/null
-      fi
-    ) &
-    ;;
-  cancel)
-    rm -f "$MARKER"
-    ;;
-esac
+  const scriptPath = join(claudeDir, "klaudio-approval-notify.js").replace(/\\/g, "/");
+
+  // Write the timer script (CJS so it works outside any module context)
+  const script = `#!/usr/bin/env node
+'use strict';
+const { writeFileSync, readFileSync, unlinkSync } = require('node:fs');
+const { tmpdir } = require('node:os');
+const { join } = require('node:path');
+const { spawn, spawnSync } = require('node:child_process');
+
+const DELAY_MS = 120000;
+const MARKER = join(tmpdir(), '.claude-approval-pending');
+const SOUND = "${normalized}";
+
+const action = process.argv[2];
+
+if (action === 'start') {
+  const token = process.pid + '-' + Date.now();
+  writeFileSync(MARKER, token + '\\n' + process.cwd() + '\\n', 'utf-8');
+  const child = spawn(process.execPath, [__filename, 'timer', token], {
+    detached: true,
+    stdio: 'ignore',
+  });
+  child.unref();
+} else if (action === 'cancel') {
+  try { unlinkSync(MARKER); } catch (_) {}
+} else if (action === 'timer') {
+  const token = process.argv[3];
+  setTimeout(function () {
+    try {
+      const content = readFileSync(MARKER, 'utf-8');
+      const lines = content.trim().split('\\n');
+      if (lines[0] !== token) return;
+      unlinkSync(MARKER);
+      const project = (lines[1] || '').split(/[\\/\\\\]/).pop() || 'project';
+      spawnSync('npx', ['--yes', 'klaudio', 'play', SOUND], { stdio: 'ignore' });
+      spawnSync('npx', ['--yes', 'klaudio', 'notify', project, 'Waiting for your approval'], { stdio: 'ignore' });
+      spawnSync('npx', ['--yes', 'klaudio', 'say', project + ' needs your attention'], { stdio: 'ignore' });
+    } catch (_) {}
+  }, DELAY_MS);
+}
 `;
   await writeFile(scriptPath, script, "utf-8");
 
@@ -159,9 +166,8 @@ esac
     (e) => !e._klaudio && !e._klonk
   );
   settings.hooks.PreToolUse.push({
-    _klaudio: true,
     matcher: "",
-    hooks: [{ type: "command", command: `bash "${scriptPath}" start` }],
+    hooks: [{ type: "command", command: `node "${scriptPath}" start` }],
   });
 
   // Add PostToolUse hook
@@ -170,9 +176,8 @@ esac
     (e) => !e._klaudio && !e._klonk
   );
   settings.hooks.PostToolUse.push({
-    _klaudio: true,
     matcher: "",
-    hooks: [{ type: "command", command: `bash "${scriptPath}" cancel` }],
+    hooks: [{ type: "command", command: `node "${scriptPath}" cancel` }],
   });
 }
 
@@ -216,7 +221,6 @@ async function installCopilotHooks(installedSounds, scope) {
     );
 
     config.hooks[event.copilotHookEvent].push({
-      _klaudio: true,
       type: "command",
       bash: bashCmd,
       powershell: psCmd,
@@ -243,12 +247,12 @@ export async function getExistingSounds(scope) {
     if (!settings.hooks) return sounds;
 
     for (const [eventId, event] of Object.entries(EVENTS)) {
-      // Approval event: read sound from the approval-notify.sh script
+      // Approval event: read sound from the klaudio-approval-notify.js script
       if (eventId === "approval") {
-        const scriptPath = join(claudeDir, "approval-notify.sh");
+        const scriptPath = join(claudeDir, "klaudio-approval-notify.js");
         try {
           const script = await readFile(scriptPath, "utf-8");
-          const m = script.match(/SOUND="([^"]+\.(wav|mp3|ogg|flac|aac))"/);
+          const m = script.match(/SOUND\s*=\s*"([^"]+\.(wav|mp3|ogg|flac|aac))"/);
           if (m) {
             sounds[eventId] = m[1].replace(/\//g, join("a", "b").includes("\\") ? "\\" : "/");
           }
@@ -292,18 +296,6 @@ export async function checkHooksOutdated(scope) {
 
     const isOurs = (e) => e._klaudio || e._klonk || e.hooks?.[0]?.command?.includes("klaudio") || e.hooks?.[0]?.command?.includes(".claude/sounds/");
 
-    // Check if any klaudio hook was installed with an older version
-    const allKlaudioHooks = Object.values(settings.hooks).flat().filter(isOurs);
-    if (allKlaudioHooks.length > 0) {
-      const hasVersionMismatch = allKlaudioHooks.some((e) => e._klaudioVersion !== KLAUDIO_VERSION);
-      if (hasVersionMismatch) {
-        const installedVer = allKlaudioHooks.find((e) => e._klaudioVersion)?._klaudioVersion;
-        reasons.push(installedVer
-          ? `Hooks from v${installedVer} → v${KLAUDIO_VERSION}`
-          : `Hooks need update to v${KLAUDIO_VERSION}`);
-      }
-    }
-
     // Check Stop hook for --notify flag
     const stopEntries = settings.hooks.Stop || [];
     const stopHook = stopEntries.find(isOurs);
@@ -318,22 +310,25 @@ export async function checkHooksOutdated(scope) {
       reasons.push("System notifications on background task");
     }
 
-    // Check approval script for notify command and timer delay
-    const scriptPath = join(claudeDir, "approval-notify.sh");
+    // Check approval script exists as the new Node.js version
+    const oldScriptPath = join(claudeDir, "approval-notify.sh");
+    const newScriptPath = join(claudeDir, "klaudio-approval-notify.js");
     try {
-      const script = await readFile(scriptPath, "utf-8");
-      if (!script.includes("klaudio notify")) {
-        reasons.push("System notifications on approval wait");
-      }
-      const delayMatch = script.match(/DELAY=(\d+)/);
-      if (delayMatch && parseInt(delayMatch[1]) < 120) {
+      await readFile(oldScriptPath, "utf-8");
+      // Old bash script still present — needs upgrade
+      reasons.push("Approval timer upgraded to cross-platform Node.js");
+    } catch { /* old script gone, good */ }
+    try {
+      const script = await readFile(newScriptPath, "utf-8");
+      const delayMatch = script.match(/DELAY_MS\s*=\s*(\d+)/);
+      if (delayMatch && parseInt(delayMatch[1]) < 120000) {
         reasons.push("Approval timer too short (now 120s)");
       }
     } catch { /* no script */ }
 
     // Check for duplicate hooks (old bug)
     for (const [event, entries] of Object.entries(settings.hooks)) {
-      const klaudioEntries = entries.filter((e) => e._klaudio || e._klonk);
+      const klaudioEntries = entries.filter(isOurs);
       if (klaudioEntries.length > 1) {
         reasons.push(`Duplicate ${event} hooks`);
       }

package/src/player.js

@@ -371,20 +371,22 @@ export async function handlePlayCommand(args) {
   const soundFile = args.find((a) => !a.startsWith("-"));
   const tts = args.includes("--tts");
 
-  // Read stdin (hook JSON) non-blocking
+  // Read stdin (hook JSON) only when TTS or notifications need it
   let hookData = {};
-  try {
-    const chunks = [];
-    process.stdin.setEncoding("utf-8");
-    // Read whatever is available with a short timeout
-    const stdinData = await new Promise((res) => {
-      const timer = setTimeout(() => { process.stdin.pause(); res(chunks.join("")); }, 500);
-      process.stdin.on("data", (chunk) => chunks.push(chunk));
-      process.stdin.on("end", () => { clearTimeout(timer); res(chunks.join("")); });
-      process.stdin.resume();
-    });
-    if (stdinData.trim()) hookData = JSON.parse(stdinData);
-  } catch { /* no stdin or invalid JSON */ }
+  if (tts || args.includes("--notify")) {
+    try {
+      const chunks = [];
+      process.stdin.setEncoding("utf-8");
+      // Read whatever is available with a short timeout
+      const stdinData = await new Promise((res) => {
+        const timer = setTimeout(() => { process.stdin.pause(); res(chunks.join("")); }, 500);
+        process.stdin.on("data", (chunk) => chunks.push(chunk));
+        process.stdin.on("end", () => { clearTimeout(timer); res(chunks.join("")); });
+        process.stdin.resume();
+      });
+      if (stdinData.trim()) hookData = JSON.parse(stdinData);
+    } catch { /* no stdin or invalid JSON */ }
+  }
 
   const notify = args.includes("--notify");
 
@@ -497,5 +499,5 @@ export function getHookPlayCommand(soundFilePath, { tts = false, voice, speed, n
   const voiceFlag = tts && voice ? ` --voice ${voice}` : "";
   const speedFlag = tts && speed && speed !== 1.0 ? ` --speed ${speed}` : "";
   const notifyFlag = notify ? " --notify" : "";
-  return `npx klaudio play "${normalized}"${ttsFlag}${voiceFlag}${speedFlag}${notifyFlag}`;
+  return `npx --yes klaudio play "${normalized}"${ttsFlag}${voiceFlag}${speedFlag}${notifyFlag}`;
 }