@delorenj/claude-notifications 1.0.2 → 1.2.0

package/.github/workflows/npm-publish-github-packages.yml

@@ -0,0 +1,36 @@
+# This workflow will run tests using node and then publish a package to GitHub Packages when a release is created
+# For more information see: https://docs.github.com/en/actions/publishing-packages/publishing-nodejs-packages
+
+name: Node.js Package
+
+on:
+  release:
+    types: [created]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 20
+      - run: npm ci
+      - run: npm test
+
+  publish-gpr:
+    needs: build
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      packages: write
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 20
+          registry-url: https://npm.pkg.github.com/
+      - run: npm ci
+      - run: npm publish
+        env:
+          NODE_AUTH_TOKEN: ${{secrets.GITHUB_TOKEN}}

package/README.md

@@ -20,10 +20,12 @@ That's it! 🎉 The package will automatically:
 ## Features
 
 - 🎵 **Final Fantasy Dream Harp** - Classic C-D-E-G ascending/(optional)descending pattern
+- 🔔 **Service Desk Bell** - Optional short, crisp bell sound for a quick "done!" signal
 - 🔊 **Cross-Platform Audio** - Works on Linux and macOS
-- 🖥️ **Desktop Notifications** - Visual notifications with Claude Code branding
+- 🖥️ **Desktop Notifications** - Visual notifications with Claude Code branding (optional)
 - 🪝 **Auto-Integration** - Automatically configures Claude Code hooks
 - ⚡ **Zero Configuration** - Works out of the box
+-  webhook **Webhook Support** - Trigger a webhook in addition to or instead of the sound
 - 🎨 **Customizable** - Easy to modify sounds and settings
 
 ## Usage
@@ -36,9 +38,15 @@ After installation, Claude Code will begin notifying you when it finishes or is
 # Trigger notification manually
 claude-notify
 
+# Trigger bell notification manually
+claude-notify --bell
+
 # Test the system
 claude-notifications test
 
+# Test the bell sound
+claude-notifications test-bell
+
 # Reinstall/repair
 claude-notifications install
 
@@ -109,6 +117,50 @@ ls ~/.local/share/sounds/claude-notification.wav
 cp your-custom-sound.wav ~/.local/share/sounds/claude-notification.wav
 ```
 
+### Configure Webhooks
+
+You can configure a webhook to be triggered when a notification occurs. This is useful for integrating with other services, such as IFTTT, Zapier, or a custom server.
+
+Create a configuration file at `~/.config/claude-notifications/settings.json`.
+
+**Example `settings.json`:**
+
+```json
+{
+  "sound": true,
+  "soundType": "claude-notification",
+  "desktopNotification": false,
+  "webhook": {
+    "enabled": true,
+    "url": "https://maker.ifttt.com/trigger/claude_notification/with/key/YOUR_KEY",
+    "replaceSound": false
+  }
+}
+```
+
+**Configuration Options:**
+
+- `sound`: (boolean) Whether to play notification sounds. Defaults to `true`.
+- `soundType`: (string) Which sound to play. Available options:
+  - `"claude-notification"` - Final Fantasy dream harp (default)
+  - `"claude-notification-bell"` - Service desk bell
+- `desktopNotification`: (boolean) Whether to show desktop notification banners. Defaults to `false`.
+- `webhook.enabled`: (boolean) Whether to trigger the webhook. Defaults to `false`.
+- `webhook.url`: (string) The URL to send the POST request to.
+- `webhook.replaceSound`: (boolean) If `true`, the sound will not play when a webhook is triggered. Defaults to `false`.
+
+The webhook will be sent as a `POST` request with a JSON payload:
+
+```json
+{
+  "message": "Claude is waiting for you..."
+}
+```
+
+### Sound Files
+
+Sound files are stored in `~/.config/claude-notifications/sounds/` and can be customized by replacing the `.wav` files in that directory.
+
 ### Create Custom Patterns
 
 Use `sox` to create new victory fanfares:

package/bin/claude-notifications.js

@@ -4,6 +4,7 @@ const { execSync, spawn } = require("child_process");
 const fs = require("fs");
 const path = require("path");
 const os = require("os");
+const { ensureSoundsDirectory, getSoundPath, SOUND_TYPES, soundsDir } = require("../lib/config");
 
 const colors = {
   red: "\x1b[31m",
@@ -106,13 +107,8 @@ function updateClaudeCodeConfig() {
 }
 
 function createSoundFile() {
-  const soundDir = path.join(os.homedir(), ".local", "share", "sounds");
-  const soundFile = path.join(soundDir, "claude-notification.wav");
-
-  // Create directory if it doesn't exist
-  if (!fs.existsSync(soundDir)) {
-    fs.mkdirSync(soundDir, { recursive: true });
-  }
+  ensureSoundsDirectory();
+  const soundFile = getSoundPath(SOUND_TYPES.HARP);
 
   // Check if sox is available
   try {
@@ -136,33 +132,146 @@ function createSoundFile() {
   // Generate pleasant notification scale
   log("blue", "🎼 Generating a pleasant notification scale...");
 
-  const soxCommand =
-    `sox -n "${soundFile}" ` +
-    "synth 0.12 sine 523.25 fade 0.01 0.12 0.01 : " +
-    "synth 0.12 sine 587.33 fade 0.01 0.12 0.01 : " +
-    "synth 0.12 sine 659.25 fade 0.01 0.12 0.01 : " +
-    "synth 0.12 sine 783.99 fade 0.01 0.12 0.01 : " +
-    "synth 0.12 sine 1046.50 fade 0.01 0.12 0.01 : " +
-    "synth 0.12 sine 1174.66 fade 0.01 0.12 0.01 : " +
-    "synth 0.12 sine 1318.51 fade 0.01 0.12 0.01 : " +
-    "synth 0.12 sine 1567.98 fade 0.01 0.12 0.01 : " +
-    "synth 0.12 sine 2093.00 fade 0.01 0.12 0.01 : " +
-    "synth 0.12 sine 1567.98 fade 0.01 0.12 0.01 : " +
-    "synth 0.12 sine 1318.51 fade 0.01 0.12 0.01 : " +
-    "synth 0.12 sine 1174.66 fade 0.01 0.12 0.01 : " +
-    "synth 0.12 sine 1046.50 fade 0.01 0.12 0.01 : " +
-    "synth 0.12 sine 783.99 fade 0.01 0.12 0.01 : " +
-    "synth 0.12 sine 659.25 fade 0.01 0.12 0.01 : " +
-    "synth 0.12 sine 587.33 fade 0.01 0.12 0.01 : " +
-    "synth 0.12 sine 523.25 fade 0.01 0.12 0.01 " +
-    "vol 0.7";
+  // Create individual note files first (safer approach)
+  const tempDir = path.join(os.tmpdir(), "claude-notifications");
+  if (!fs.existsSync(tempDir)) {
+    fs.mkdirSync(tempDir, { recursive: true });
+  }
+
+  const notes = [
+    { freq: 523.25, name: "C5" }, // C5
+    { freq: 587.33, name: "D5" }, // D5
+    { freq: 659.25, name: "E5" }, // E5
+    { freq: 783.99, name: "G5" }, // G5
+    { freq: 1046.5, name: "C6" }, // C6
+    { freq: 1174.66, name: "D6" }, // D6
+    { freq: 1318.51, name: "E6" }, // E6
+    { freq: 1567.98, name: "G6" }, // G6
+    { freq: 2093.0, name: "C7" }, // C7
+  ];
 
   try {
-    execSync(soxCommand, { stdio: "ignore" });
+    const noteFiles = [];
+
+    // Generate each note individually (much safer)
+    for (let i = 0; i < notes.length; i++) {
+      const noteFile = path.join(tempDir, `note_${i}.wav`);
+      const noteCommand = `sox -n "${noteFile}" synth 0.08 sine ${notes[i].freq} fade 0.01 0.08 0.01 vol 0.7`;
+      execSync(noteCommand, { stdio: "ignore", timeout: 5000 }); // 5 second timeout per note
+      noteFiles.push(noteFile);
+    }
+
+    // Concatenate all notes into final file
+    const concatCommand = `sox ${noteFiles.map((f) => `"${f}"`).join(" ")} "${soundFile}"`;
+    execSync(concatCommand, { stdio: "ignore", timeout: 10000 }); // 10 second timeout for concat
+
+    // Clean up temp files
+    noteFiles.forEach((file) => {
+      if (fs.existsSync(file)) {
+        fs.unlinkSync(file);
+      }
+    });
+
+    // Remove temp directory if empty
+    try {
+      fs.rmdirSync(tempDir);
+    } catch (e) {
+      // Directory might not be empty, that's ok
+    }
+
     log("green", "✅ Sound file created successfully!");
     return true;
   } catch (error) {
     log("red", `❌ Error creating sound file: ${error.message}`);
+
+    // Clean up any temp files on error
+    try {
+      const tempFiles = fs
+        .readdirSync(tempDir)
+        .filter((f) => f.startsWith("note_"));
+      tempFiles.forEach((file) => {
+        const filePath = path.join(tempDir, file);
+        if (fs.existsSync(filePath)) {
+          fs.unlinkSync(filePath);
+        }
+      });
+    } catch (cleanupError) {
+      // Ignore cleanup errors
+    }
+
+    return false;
+  }
+}
+
+function generateBellSoxCommand(outputFile) {
+  // Bell sound parameters - adjust these to customize the bell
+  const bellParams = {
+    // Base tone generation
+    duration: 0.1, // Length of the initial bell strike (seconds)
+    frequency: 1600, // Pitch of the bell (Hz) - higher = more "ting", lower = more "dong"
+
+    // Fade envelope
+    fadeIn: 0, // Fade in time (seconds) - 0 for immediate attack
+    fadeDuration: 0.1, // Total fade duration (seconds)
+    fadeOut: 0.05, // Fade out time (seconds) - creates the bell decay
+
+    // Volume
+    volume: 0.9, // Master volume (0.0 to 1.0)
+
+    // Echo effect parameters (creates the "ringing" quality)
+    echoGain: 0.5, // Overall echo volume (0.0 to 1.0)
+    echoDecay: 0.5, // How quickly echoes fade (0.0 to 1.0)
+
+    // Individual echo delays and volumes (milliseconds, volume)
+    echo1: { delay: 250, volume: 0.2 }, // First echo - quarter second delay
+    echo2: { delay: 500, volume: 0.05 }, // Second echo - half second delay
+    echo3: { delay: 750, volume: 0.01 }, // Third echo - three quarter second delay
+
+    // Reverb parameters (adds spatial depth)
+    reverb: {
+      roomSize: 40, // Room size percentage (0-100) - larger = more spacious
+      preDelay: 65, // Pre-delay in ms - time before reverb starts
+      reverbTime: 100, // Reverb decay time percentage (0-100)
+      wetGain: 100, // Wet signal gain percentage (0-100) - reverb volume
+      dryGain: 12, // Dry signal gain percentage (0-100) - original signal volume
+      stereoDepth: 0, // Stereo depth (0-100) - 0 = mono, higher = wider stereo
+    },
+  };
+
+  // Build the sox command with clear parameter mapping
+  const command = [
+    "sox -n", // Generate from nothing (null input)
+    `"${outputFile}"`, // Output file
+    `synth ${bellParams.duration} sine ${bellParams.frequency}`, // Generate sine wave
+    `fade ${bellParams.fadeIn} ${bellParams.fadeDuration} ${bellParams.fadeOut}`, // Apply fade envelope
+    `vol ${bellParams.volume}`, // Set volume
+    `echos ${bellParams.echoGain} ${bellParams.echoDecay}`, // Echo effect base settings
+    `${bellParams.echo1.delay} ${bellParams.echo1.volume}`, // Echo 1: 250ms delay, 0.2 volume
+    `${bellParams.echo2.delay} ${bellParams.echo2.volume}`, // Echo 2: 500ms delay, 0.1 volume
+    `${bellParams.echo3.delay} ${bellParams.echo3.volume}`, // Echo 3: 750ms delay, 0.05 volume
+    `reverb ${bellParams.reverb.roomSize} ${bellParams.reverb.preDelay}`, // Reverb room & pre-delay
+    `${bellParams.reverb.reverbTime} ${bellParams.reverb.wetGain}`, // Reverb time & wet gain
+    `${bellParams.reverb.dryGain} ${bellParams.reverb.stereoDepth}`, // Dry gain & stereo depth
+  ].join(" ");
+
+  return command;
+}
+
+function createBellSoundFile() {
+  ensureSoundsDirectory();
+  const soundFile = getSoundPath(SOUND_TYPES.BELL);
+
+  log("blue", "🔔 Generating service desk bell sound...");
+
+  try {
+    // Generate the bell sound using our documented sox command builder
+    const bellCommand = generateBellSoxCommand(soundFile);
+    execSync(bellCommand, { stdio: "ignore", timeout: 5000 });
+
+    log("green", "✅ Bell sound file created successfully!");
+    return true;
+  } catch (error) {
+    log("red", `❌ Error creating bell sound file: ${error.message}`);
     return false;
   }
 }
@@ -175,7 +284,7 @@ function main() {
     case undefined:
       log("blue", "🎵 Installing Claude Notifications...");
 
-      if (createSoundFile()) {
+      if (createSoundFile() && createBellSoundFile()) {
         updateClaudeCodeConfig();
         log("green", "🎉 Installation complete!");
         log("blue", "🧪 Testing notification...");
@@ -216,21 +325,36 @@ function main() {
       });
       break;
 
+    case "test-bell":
+      log("blue", "🔔 Testing bell notification...");
+      spawn("node", [path.join(__dirname, "claude-notify.js"), "--bell"], {
+        stdio: "inherit",
+      });
+      break;
+
     case "uninstall":
       log("blue", "🗑️  Uninstalling Claude Notifications...");
 
-      const soundFile = path.join(
-        os.homedir(),
-        ".local",
-        "share",
-        "sounds",
-        "claude-notification.wav",
-      );
-      if (fs.existsSync(soundFile)) {
-        fs.unlinkSync(soundFile);
-        log("green", "✅ Removed sound file");
+      // Remove sounds directory
+      if (fs.existsSync(soundsDir)) {
+        fs.rmSync(soundsDir, { recursive: true, force: true });
+        log("green", "✅ Removed sounds directory");
       }
 
+      // Also clean up old sound files if they exist
+      const oldSoundDir = path.join(os.homedir(), ".local", "share", "sounds");
+      const oldSoundFiles = [
+        path.join(oldSoundDir, "claude-notification.wav"),
+        path.join(oldSoundDir, "claude-notification-bell.wav")
+      ];
+      
+      oldSoundFiles.forEach(file => {
+        if (fs.existsSync(file)) {
+          fs.unlinkSync(file);
+          log("green", `✅ Removed old sound file: ${path.basename(file)}`);
+        }
+      });
+
       log(
         "yellow",
         "⚠️  Please manually remove the stop hook from your Claude Code config",
@@ -249,6 +373,7 @@ function main() {
       console.log("Commands:");
       console.log("  install    Install notifications (default)");
       console.log("  test       Test the notification");
+      console.log("  test-bell  Test the bell notification");
       console.log("  uninstall  Remove notifications");
       console.log("  help       Show this help");
       break;

package/bin/claude-notify.js

@@ -1,79 +1,192 @@
 #!/usr/bin/env node
 
-const { execSync, spawn } = require('child_process');
+const { execSync } = require('child_process');
 const fs = require('fs');
 const path = require('path');
 const os = require('os');
+const http = require('http');
+const https = require('https');
+const { getConfig, getSoundPath, SOUND_TYPES } = require('../lib/config');
+
+const config = getConfig();
+
+// Check for command line arguments
+const args = process.argv.slice(2);
+const useBell = args.includes('--bell') || args.includes('-b');
+const showConfig = args.includes('-c') || args.includes('--config');
 
 function playSound() {
-  const soundFile = path.join(os.homedir(), '.local', 'share', 'sounds', 'claude-notification.wav');
+  if (!config.sound) {
+    return;
+  }
+
+  // Determine which sound to play
+  let soundType = config.soundType;
+  if (useBell) {
+    soundType = SOUND_TYPES.BELL;
+  }
+
+  const soundFile = getSoundPath(soundType);
   
   if (!fs.existsSync(soundFile)) {
-    // Fallback to system bell
-    process.stdout.write('\x07');
+    console.warn(`Sound file not found: ${soundFile}`);
+    process.stdout.write('\x07'); // Fallback to system beep
     return;
   }
 
   try {
-    // Try different audio players based on platform
     if (process.platform === 'linux') {
-      // Try paplay first (PulseAudio)
       try {
         execSync(`paplay "${soundFile}"`, { stdio: 'ignore' });
-        return;
       } catch (e) {
-        // Try aplay (ALSA)
         try {
           execSync(`aplay "${soundFile}"`, { stdio: 'ignore' });
-          return;
         } catch (e2) {
-          // Try play (sox)
           try {
             execSync(`play "${soundFile}"`, { stdio: 'ignore' });
-            return;
           } catch (e3) {
-            // Fallback to system bell
             process.stdout.write('\x07');
           }
         }
       }
     } else if (process.platform === 'darwin') {
-      // macOS
       try {
         execSync(`afplay "${soundFile}"`, { stdio: 'ignore' });
-        return;
       } catch (e) {
-        // Fallback to system bell
         process.stdout.write('\x07');
       }
     } else {
-      // Other platforms - just system bell
       process.stdout.write('\x07');
     }
   } catch (error) {
-    // Final fallback
     process.stdout.write('\x07');
   }
 }
 
+function triggerWebhook() {
+  if (!config.webhook || !config.webhook.enabled || !config.webhook.url) {
+    return;
+  }
+
+  const { url } = config.webhook;
+  const data = JSON.stringify({ message: 'Claude is waiting for you...' });
+
+  const protocol = url.startsWith('https') ? https : http;
+
+  const options = {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      'Content-Length': data.length
+    }
+  };
+
+  const req = protocol.request(url, options, (res) => {
+    // We don't really care about the response, but it's good practice to handle it
+    res.on('data', () => {});
+    res.on('end', () => {});
+  });
+
+  req.on('error', (error) => {
+    console.error('Error triggering webhook:', error);
+  });
+
+  req.write(data);
+  req.end();
+}
+
 function showNotification() {
   const notifier = require('node-notifier');
   
   notifier.notify({
     title: 'Claude Code',
     message: 'Waiting for you...',
-    icon: path.join(os.homedir(), 'Pictures', 'claude.png'), // Will fallback gracefully if not found
-    sound: false, // We handle sound separately
-    urgency: 'critical'
+    icon: path.join(os.homedir(), 'Pictures', 'claude.png'),
+    sound: false,
+    urgency: 'critical',
+    id: 'claude-code-notification',
+    replaceId: 'claude-code-notification'
+  });
+}
+
+function showConfigInfo() {
+  const configPath = path.join(os.homedir(), '.config', 'claude-notifications', 'settings.json');
+  const soundsDir = path.join(os.homedir(), '.config', 'claude-notifications', 'sounds');
+  
+  console.log('🔍 Claude Notifications Config Debug Info:');
+  console.log('');
+  console.log('📁 Config file location:');
+  console.log(`   ${configPath}`);
+  console.log(`   Exists: ${fs.existsSync(configPath) ? '✅' : '❌'}`);
+  
+  if (fs.existsSync(configPath)) {
+    try {
+      const configContent = fs.readFileSync(configPath, 'utf-8');
+      console.log('   Content:');
+      console.log(`   ${configContent.split('\n').map(line => `   ${line}`).join('\n')}`);
+    } catch (error) {
+      console.log(`   Error reading: ${error.message}`);
+    }
+  }
+  
+  console.log('');
+  console.log('🔊 Sounds directory:');
+  console.log(`   ${soundsDir}`);
+  console.log(`   Exists: ${fs.existsSync(soundsDir) ? '✅' : '❌'}`);
+  
+  if (fs.existsSync(soundsDir)) {
+    try {
+      const soundFiles = fs.readdirSync(soundsDir);
+      console.log('   Files:');
+      soundFiles.forEach(file => {
+        const filePath = path.join(soundsDir, file);
+        const stats = fs.statSync(filePath);
+        console.log(`   - ${file} (${Math.round(stats.size / 1024)}KB)`);
+      });
+    } catch (error) {
+      console.log(`   Error reading directory: ${error.message}`);
+    }
+  }
+  
+  console.log('');
+  console.log('⚙️  Current config values:');
+  console.log(`   sound: ${config.sound}`);
+  console.log(`   soundType: ${config.soundType}`);
+  console.log(`   desktopNotification: ${config.desktopNotification}`);
+  console.log(`   webhook.enabled: ${config.webhook.enabled}`);
+  
+  console.log('');
+  console.log('🎵 Sound file paths:');
+  const { SOUND_TYPES, getSoundPath } = require('../lib/config');
+  Object.values(SOUND_TYPES).forEach(soundType => {
+    const soundPath = getSoundPath(soundType);
+    console.log(`   ${soundType}: ${soundPath}`);
+    console.log(`   Exists: ${fs.existsSync(soundPath) ? '✅' : '❌'}`);
   });
+  
+  console.log('');
+  console.log('🔧 Command line args:');
+  console.log(`   useBell: ${useBell}`);
+  console.log(`   showConfig: ${showConfig}`);
 }
 
 function main() {
-  // Play sound in background
-  playSound();
+  if (showConfig) {
+    showConfigInfo();
+    return;
+  }
   
-  // Show desktop notification
-  showNotification();
+  if (config.webhook.enabled) {
+    triggerWebhook();
+    if (!config.webhook.replaceSound) {
+      playSound();
+    }
+  } else {
+    playSound();
+    if (config.desktopNotification) {
+      showNotification();
+    }
+  }
 }
 
 if (require.main === module) {

package/lib/config.js

@@ -0,0 +1,63 @@
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const configPath = path.join(os.homedir(), '.config', 'claude-notifications', 'settings.json');
+const soundsDir = path.join(os.homedir(), '.config', 'claude-notifications', 'sounds');
+
+// Available sound types (filenames without extension)
+const SOUND_TYPES = {
+  HARP: 'claude-notification',
+  BELL: 'claude-notification-bell'
+};
+
+function getConfig() {
+  const defaultConfig = {
+    sound: true,
+    soundType: SOUND_TYPES.HARP,  // Default to harp sound
+    desktopNotification: false,
+    webhook: {
+      enabled: false,
+      url: null,
+      replaceSound: false
+    }
+  };
+
+  if (!fs.existsSync(configPath)) {
+    return defaultConfig;
+  }
+
+  try {
+    const configContent = fs.readFileSync(configPath, 'utf-8');
+    const userConfig = JSON.parse(configContent);
+    
+    // Handle migration from old 'secondSound' config
+    if (userConfig.secondSound === true && !userConfig.soundType) {
+      userConfig.soundType = SOUND_TYPES.BELL;
+      delete userConfig.secondSound;
+    }
+    
+    return { ...defaultConfig, ...userConfig };
+  } catch (error) {
+    console.error('Error reading or parsing config file:', error);
+    return defaultConfig;
+  }
+}
+
+function getSoundPath(soundType) {
+  return path.join(soundsDir, `${soundType}.wav`);
+}
+
+function ensureSoundsDirectory() {
+  if (!fs.existsSync(soundsDir)) {
+    fs.mkdirSync(soundsDir, { recursive: true });
+  }
+}
+
+module.exports = { 
+  getConfig, 
+  getSoundPath, 
+  ensureSoundsDirectory,
+  SOUND_TYPES,
+  soundsDir 
+};

package/mise.toml

@@ -0,0 +1,3 @@
+[tasks.play-sound]
+description = "Play the Claude notification sound"
+run = "node bin/claude-notify.js"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@delorenj/claude-notifications",
-  "version": "1.0.2",
+  "version": "1.2.0",
   "description": "Delightful Notification for Claude Code",
   "main": "index.js",
   "bin": {

package/install.sh

@@ -1,161 +0,0 @@
-#!/bin/bash
-
-# Claude Code Notifications Installer
-# Installs a much needed notification system for Claude Code
-
-set -e
-
-echo "🎵 Installing Claude Code Notifications..."
-
-# Colors for output
-RED='\033[0;31m'
-GREEN='\033[0;32m'
-YELLOW='\033[1;33m'
-BLUE='\033[0;34m'
-NC='\033[0m' # No Color
-
-# Check if we're on Linux
-if [[ "$OSTYPE" != "linux-gnu"* ]]; then
-  echo -e "${RED}❌ This installer is currently Linux-only. macOS support coming soon!${NC}"
-  exit 1
-fi
-
-# Create necessary directories
-echo -e "${BLUE}📁 Creating directories...${NC}"
-mkdir -p ~/.local/bin
-mkdir -p ~/.local/share/sounds
-
-# Check for required tools and install if needed
-echo -e "${BLUE}🔧 Checking dependencies...${NC}"
-
-# Check for sox
-if ! command -v sox &>/dev/null; then
-  echo -e "${YELLOW}⚠️  sox not found. Installing...${NC}"
-  if command -v apt &>/dev/null; then
-    sudo apt update && sudo apt install -y sox
-  elif command -v dnf &>/dev/null; then
-    sudo dnf install -y sox
-  elif command -v pacman &>/dev/null; then
-    sudo pacman -S sox
-  else
-    echo -e "${RED}❌ Could not install sox. Please install it manually.${NC}"
-    exit 1
-  fi
-fi
-
-# Check for notify-send
-if ! command -v notify-send &>/dev/null; then
-  echo -e "${YELLOW}⚠️  notify-send not found. Installing...${NC}"
-  if command -v apt &>/dev/null; then
-    sudo apt install -y libnotify-bin
-  elif command -v dnf &>/dev/null; then
-    sudo dnf install -y libnotify
-  elif command -v pacman &>/dev/null; then
-    sudo pacman -S libnotify
-  fi
-fi
-
-# Generate that sweet Final Fantasy scale
-echo -e "${BLUE}🎼 Generating dreamy notification sound...${NC}"
-sox -n ~/.local/share/sounds/claude-notification.wav \
-  synth 0.12 sine 523.25 fade 0.01 0.12 0.01 : \
-  synth 0.12 sine 587.33 fade 0.01 0.12 0.01 : \
-  synth 0.12 sine 659.25 fade 0.01 0.12 0.01 : \
-  synth 0.12 sine 783.99 fade 0.01 0.12 0.01 : \
-  synth 0.12 sine 1046.50 fade 0.01 0.12 0.01 : \
-  synth 0.12 sine 1174.66 fade 0.01 0.12 0.01 : \
-  synth 0.12 sine 1318.51 fade 0.01 0.12 0.01 : \
-  synth 0.12 sine 1567.98 fade 0.01 0.12 0.01 : \
-  synth 0.12 sine 2093.00 fade 0.01 0.12 0.01 :
-# Uncomment for the longer, more nostalgic version
-#    synth 0.12 sine 1567.98 fade 0.01 0.12 0.01 : \
-#    synth 0.12 sine 1318.51 fade 0.01 0.12 0.01 : \
-#    synth 0.12 sine 1174.66 fade 0.01 0.12 0.01 : \
-#    synth 0.12 sine 1046.50 fade 0.01 0.12 0.01 : \
-#    synth 0.12 sine 783.99 fade 0.01 0.12 0.01 : \
-#    synth 0.12 sine 659.25 fade 0.01 0.12 0.01 : \
-#    synth 0.12 sine 587.33 fade 0.01 0.12 0.01 : \
-#    synth 0.12 sine 523.25 fade 0.01 0.12 0.01 \
-vol 0.7
-
-# Create the claude-notify script
-echo -e "${BLUE}📝 Creating claude-notify script...${NC}"
-cat >~/.local/bin/claude-notify <<'EOF'
-#!/usr/bin/env bash
-
-# Claude Code notification script
-# Sends a desktop notification for Claude Code along with a dreamy notification sound
-
-# Play notification sound (try multiple methods for compatibility)
-play_sound() {
-    local sound_file="$HOME/.local/share/sounds/claude-notification.wav"
-    
-    # Try paplay first (PulseAudio - most common on Ubuntu)
-    if command -v paplay >/dev/null 2>&1 && [[ -f "$sound_file" ]]; then
-        paplay "$sound_file" 2>/dev/null &
-    # Fallback to aplay (ALSA)
-    elif command -v aplay >/dev/null 2>&1 && [[ -f "$sound_file" ]]; then
-        aplay "$sound_file" 2>/dev/null &
-    # Fallback to system sounds
-    elif command -v paplay >/dev/null 2>&1; then
-        paplay /usr/share/sounds/alsa/Front_Left.wav 2>/dev/null &
-    # Final fallback to system bell
-    else
-        printf '\a'
-    fi
-}
-
-# Play sound in background
-play_sound
-
-# Send desktop notification
-notify-send \
-    --app-name="Claude Code" \
-    --icon /home/clouedoc/Pictures/claude.png \
-    --urgency critical \
-    "Claude Code" \
-    "Waiting for you..."
-EOF
-
-# Make the script executable
-chmod +x ~/.local/bin/claude-notify
-
-# Add ~/.local/bin to PATH if not already there
-if [[ ":$PATH:" != *":$HOME/.local/bin:"* ]]; then
-  echo -e "${BLUE}🛤️  Adding ~/.local/bin to PATH...${NC}"
-
-  # Detect shell and add to appropriate config file
-  if [[ -n "$ZSH_VERSION" ]] || [[ "$SHELL" == *"zsh"* ]]; then
-    echo 'export PATH="$HOME/.local/bin:$PATH"' >>~/.zshrc
-    echo -e "${YELLOW}⚠️  Added to ~/.zshrc - restart your terminal or run: source ~/.zshrc${NC}"
-  elif [[ -n "$BASH_VERSION" ]] || [[ "$SHELL" == *"bash"* ]]; then
-    echo 'export PATH="$HOME/.local/bin:$PATH"' >>~/.bashrc
-    echo -e "${YELLOW}⚠️  Added to ~/.bashrc - restart your terminal or run: source ~/.bashrc${NC}"
-  else
-    echo -e "${YELLOW}⚠️  Please add ~/.local/bin to your PATH manually${NC}"
-  fi
-fi
-
-# Test the installation
-echo -e "${BLUE}🧪 Testing installation...${NC}"
-if command -v claude-notify &>/dev/null; then
-  echo -e "${GREEN}✅ claude-notify command is available!${NC}"
-  echo -e "${BLUE}🔊 Playing test notification...${NC}"
-  claude-notify
-else
-  echo -e "${YELLOW}⚠️  claude-notify not in PATH yet. Restart your terminal or source your shell config.${NC}"
-fi
-
-echo ""
-echo -e "${GREEN}🎉 Installation complete!${NC}"
-echo ""
-echo -e "${BLUE}Next steps:${NC}"
-echo "1. Test the notification: ${YELLOW}claude-notify${NC}"
-echo "2. Add to Claude Code settings (see README.md for JSON config)"
-echo "3. Never alt-tab back to a unexpected Y/n again! 🎵"
-echo ""
-echo -e "${BLUE}Configuration location:${NC}"
-echo "• Script: ~/.local/bin/claude-notify"
-echo "• Sound: ~/.local/share/sounds/claude-notification.wav"
-echo ""
-echo -e "${BLUE}Need help?${NC} Check the README.md for customization options!"