claude-code-notify-lite 1.0.1 → 1.0.3

package/README.md

@@ -120,12 +120,35 @@ Claude Code Notify Lite integrates with Claude Code's hook system:
 
 ## Troubleshooting
 
+### Debug Logs
+
+View debug logs to diagnose issues:
+
+```bash
+# Show recent logs
+ccnotify logs
+
+# Show more lines
+ccnotify logs -n 100
+
+# Clear logs
+ccnotify logs -c
+```
+
+Log file locations:
+- **Windows:** `%APPDATA%\claude-code-notify-lite\debug.log`
+- **macOS:** `~/Library/Logs/claude-code-notify-lite/debug.log`
+- **Linux:** `~/.local/state/claude-code-notify-lite/debug.log`
+
 ### Command 'ccnotify' not found
 
 After npm global install, if `ccnotify` is not recognized:
 
 ```bash
-# Use npx instead
+# Use npx instead (short form)
+npx ccnotify install
+
+# Or use full package name
 npx claude-code-notify-lite install
 
 # Or find npm global bin location
@@ -133,6 +156,18 @@ npm root -g
 # Then add the parent bin directory to PATH
 ```
 
+### Hook error: "path not found"
+
+If you see garbled text like "ϵͳ找不到指定的路径" in hook errors:
+
+```bash
+# Reinstall to update hook command with absolute paths
+npx ccnotify uninstall
+npx ccnotify install
+```
+
+The latest version uses absolute paths (node.exe + cli.js) instead of npx, which resolves PATH issues in hook execution environment.
+
 ### Notification not showing
 
 **macOS:**

package/bin/cli.js

@@ -2,8 +2,15 @@
 
 const { program } = require('commander');
 const chalk = require('chalk');
+const fs = require('fs');
 const pkg = require('../package.json');
 
+function formatTime() {
+  const now = new Date();
+  const pad = (n) => String(n).padStart(2, '0');
+  return `${now.getFullYear()}-${pad(now.getMonth() + 1)}-${pad(now.getDate())} ${pad(now.getHours())}:${pad(now.getMinutes())}:${pad(now.getSeconds())}`;
+}
+
 program
   .name('ccnotify')
   .description('Task completion notifications for Claude Code')
@@ -45,6 +52,9 @@ program
 
     const { notify } = require('../src/notifier');
     const { playSound } = require('../src/audio');
+    const logger = require('../src/logger');
+
+    logger.info('Test started');
 
     try {
       await Promise.all([
@@ -52,7 +62,7 @@ program
           title: 'Claude Code Notify',
           message: 'Test notification successful!',
           workDir: process.cwd(),
-          time: new Date().toLocaleString()
+          time: formatTime()
         }),
         playSound()
       ]);
@@ -60,9 +70,13 @@ program
       console.log(chalk.green('  [OK] Notification sent'));
       console.log(chalk.green('  [OK] Sound played'));
       console.log(chalk.green('\nTest completed successfully!\n'));
+      logger.info('Test completed successfully');
     } catch (err) {
       console.log(chalk.red(`  [ERROR] ${err.message}`));
+      logger.error('Test failed', err);
     }
+
+    console.log(chalk.gray(`Log file: ${logger.getLogPath()}\n`));
   });
 
 program
@@ -70,6 +84,7 @@ program
   .description('Check installation status')
   .action(() => {
     const { checkInstallation } = require('../src/installer');
+    const logger = require('../src/logger');
     const status = checkInstallation();
 
     console.log(chalk.blue('Installation Status:\n'));
@@ -83,8 +98,10 @@ program
     console.log(`  Hook configured: ${status.hasHook ? chalk.green('Yes') : chalk.red('No')}`);
     console.log(`  Config exists: ${status.hasConfig ? chalk.green('Yes') : chalk.red('No')}`);
 
+    console.log(chalk.gray(`\n  Log file: ${logger.getLogPath()}`));
+
     if (!status.installed) {
-      console.log(chalk.yellow('\nRun "ccnotify install" to complete installation.\n'));
+      console.log(chalk.yellow('\nRun "npx claude-code-notify-lite install" to complete installation.\n'));
     }
   });
 
@@ -175,4 +192,64 @@ program
     console.log('');
   });
 
+program
+  .command('logs')
+  .description('Show debug logs')
+  .option('-n, --lines <number>', 'Number of lines to show', '50')
+  .option('-f, --follow', 'Follow log file (like tail -f)')
+  .option('-c, --clear', 'Clear log file')
+  .action((options) => {
+    const logger = require('../src/logger');
+    const logPath = logger.getLogPath();
+
+    if (options.clear) {
+      try {
+        if (fs.existsSync(logPath)) {
+          fs.unlinkSync(logPath);
+          console.log(chalk.green('Log file cleared.\n'));
+        } else {
+          console.log(chalk.yellow('Log file does not exist.\n'));
+        }
+      } catch (err) {
+        console.log(chalk.red(`Failed to clear log: ${err.message}\n`));
+      }
+      return;
+    }
+
+    console.log(chalk.blue(`Log file: ${logPath}\n`));
+
+    if (!fs.existsSync(logPath)) {
+      console.log(chalk.yellow('No logs yet.\n'));
+      return;
+    }
+
+    try {
+      const content = fs.readFileSync(logPath, 'utf8');
+      const lines = content.trim().split('\n');
+      const numLines = parseInt(options.lines, 10) || 50;
+      const lastLines = lines.slice(-numLines);
+
+      if (lastLines.length === 0) {
+        console.log(chalk.yellow('Log file is empty.\n'));
+        return;
+      }
+
+      console.log(chalk.gray('--- Recent logs ---\n'));
+      lastLines.forEach(line => {
+        if (line.includes('[ERROR]')) {
+          console.log(chalk.red(line));
+        } else if (line.includes('[WARN]')) {
+          console.log(chalk.yellow(line));
+        } else if (line.includes('[INFO]')) {
+          console.log(chalk.white(line));
+        } else {
+          console.log(chalk.gray(line));
+        }
+      });
+      console.log('');
+    } catch (err) {
+      console.log(chalk.red(`Failed to read log: ${err.message}\n`));
+    }
+  });
+
 program.parse();

package/package.json

@@ -1,9 +1,10 @@
 {
   "name": "claude-code-notify-lite",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "description": "Task completion notifications for Claude Code - Cross-platform, lightweight, and easy to use",
   "main": "src/index.js",
   "bin": {
+    "claude-code-notify-lite": "./bin/cli.js",
     "ccnotify": "./bin/cli.js"
   },
   "scripts": {

package/src/audio.js

@@ -3,6 +3,7 @@ const fs = require('fs');
 const os = require('os');
 const { exec } = require('child_process');
 const { loadConfig, getSoundsDir } = require('./config');
+const logger = require('./logger');
 
 const BUILT_IN_SOUNDS = {
   default: 'default.mp3'
@@ -33,10 +34,13 @@ function getSoundPath(soundName) {
 
 function playWithAfplay(soundPath, volume) {
   return new Promise((resolve) => {
+    logger.info('Playing sound with afplay', { soundPath, volume });
     const volumeArg = volume < 100 ? `-v ${volume / 100}` : '';
     exec(`afplay ${volumeArg} "${soundPath}"`, (err) => {
-      if (err && process.env.DEBUG) {
-        console.warn('afplay error:', err.message);
+      if (err) {
+        logger.error('afplay error', err);
+      } else {
+        logger.info('afplay completed');
       }
       resolve();
     });
@@ -45,6 +49,7 @@ function playWithAfplay(soundPath, volume) {
 
 function playWithPowershell(soundPath) {
   return new Promise((resolve) => {
+    logger.info('Playing sound with PowerShell', { soundPath });
     const escapedPath = soundPath.replace(/\\/g, '\\\\');
     const psScript = [
       'Add-Type -AssemblyName PresentationCore',
@@ -57,18 +62,25 @@ function playWithPowershell(soundPath) {
 
     exec(`powershell -NoProfile -ExecutionPolicy Bypass -Command "${psScript}"`,
       { encoding: 'utf8', windowsHide: true },
-      () => resolve()
+      (err) => {
+        if (err) {
+          logger.error('PowerShell audio error', err);
+        } else {
+          logger.info('PowerShell audio completed');
+        }
+        resolve();
+      }
     );
   });
 }
 
 function playWithLinuxPlayer(soundPath) {
   return new Promise((resolve) => {
+    logger.info('Playing sound on Linux', { soundPath });
+
     const tryPlayers = (players) => {
       if (players.length === 0) {
-        if (process.env.DEBUG) {
-          console.warn('No audio player available on Linux');
-        }
+        logger.warn('No audio player available on Linux');
         resolve();
         return;
       }
@@ -98,10 +110,14 @@ function playWithLinuxPlayer(soundPath) {
             cmd = `${player} "${soundPath}"`;
         }
 
+        logger.debug('Using player', { player, cmd });
+
         exec(cmd, (err) => {
           if (err) {
+            logger.warn(`${player} failed, trying next`, err);
             tryPlayers(rest);
           } else {
+            logger.info(`${player} completed successfully`);
             resolve();
           }
         });
@@ -113,24 +129,28 @@ function playWithLinuxPlayer(soundPath) {
 }
 
 function playSound(soundFile) {
+  logger.debug('playSound called', { soundFile });
+
   const config = loadConfig();
 
   if (!config.sound || !config.sound.enabled) {
+    logger.info('Sound disabled in config');
     return Promise.resolve();
   }
 
   const soundPath = getSoundPath(soundFile || config.sound.file);
+  logger.info('Sound path resolved', { soundPath });
 
   if (!fs.existsSync(soundPath)) {
-    if (process.env.DEBUG) {
-      console.warn(`Sound file not found: ${soundPath}`);
-    }
+    logger.error('Sound file not found', { soundPath });
     return Promise.resolve();
   }
 
   const platform = os.platform();
   const volume = config.sound.volume || 80;
 
+  logger.info('Playing sound', { platform, volume });
+
   if (platform === 'darwin') {
     return playWithAfplay(soundPath, volume);
   } else if (platform === 'win32') {
@@ -157,9 +177,7 @@ function listSounds() {
         }
       });
     } catch (err) {
-      if (process.env.DEBUG) {
-        console.warn('Failed to read sounds directory:', err.message);
-      }
+      logger.error('Failed to read sounds directory', err);
     }
   }
 

package/src/index.js

@@ -1,6 +1,7 @@
 const { notify } = require('./notifier');
 const { playSound } = require('./audio');
 const { loadConfig } = require('./config');
+const logger = require('./logger');
 
 function formatTime() {
   const now = new Date();
@@ -9,8 +10,11 @@ function formatTime() {
 }
 
 async function run(options = {}) {
+  logger.info('Run started', { options, cwd: process.cwd(), claudePwd: process.env.CLAUDE_PWD });
+
   try {
     const config = loadConfig();
+    logger.debug('Config loaded', config);
 
     const workDir = process.env.CLAUDE_PWD || process.cwd();
     const time = formatTime();
@@ -18,7 +22,9 @@ async function run(options = {}) {
     const title = options.title || config.notification.title || 'Claude Code';
     const message = options.message || 'Task completed';
 
-    await Promise.all([
+    logger.info('Sending notification', { title, message, workDir, time });
+
+    const results = await Promise.allSettled([
       notify({
         title,
         message,
@@ -27,10 +33,19 @@ async function run(options = {}) {
       }),
       playSound()
     ]);
+
+    results.forEach((result, index) => {
+      const taskName = index === 0 ? 'notify' : 'playSound';
+      if (result.status === 'fulfilled') {
+        logger.info(`${taskName} completed successfully`);
+      } else {
+        logger.error(`${taskName} failed`, result.reason);
+      }
+    });
+
+    logger.info('Run completed');
   } catch (err) {
-    if (process.env.DEBUG) {
-      console.error('Run error:', err.message);
-    }
+    logger.error('Run error', err);
   }
 }
 

package/src/installer.js

@@ -1,40 +1,118 @@
 const fs = require('fs');
 const path = require('path');
+const os = require('os');
 const { getClaudeConfigDir, getConfigDir, ensureConfigDir, saveConfig, getDefaultConfig } = require('./config');
+const logger = require('./logger');
 
 function getClaudeSettingsPath() {
   return path.join(getClaudeConfigDir(), 'settings.json');
 }
 
-function getHookCommand() {
-  try {
-    const { execSync } = require('child_process');
-    const npmRoot = execSync('npm root -g', { encoding: 'utf8', stdio: ['pipe', 'pipe', 'ignore'] }).trim();
-    const notifyScript = path.join(npmRoot, 'claude-code-notify-lite', 'bin', 'notify.js');
+function isNpxCache(filePath) {
+  const normalizedPath = filePath.toLowerCase().replace(/\\/g, '/');
+  return normalizedPath.includes('npm-cache/_npx') ||
+         normalizedPath.includes('npm-cache\\_npx') ||
+         normalizedPath.includes('.npm/_npx');
+}
+
+function copyCliToConfigDir() {
+  const configDir = getConfigDir();
+
+  ensureConfigDir();
+
+  const srcDir = path.join(configDir, 'src');
+  if (!fs.existsSync(srcDir)) {
+    fs.mkdirSync(srcDir, { recursive: true });
+  }
+
+  const filesToCopy = [
+    { src: path.resolve(__dirname, 'index.js'), dest: path.join(srcDir, 'index.js') },
+    { src: path.resolve(__dirname, 'notifier.js'), dest: path.join(srcDir, 'notifier.js') },
+    { src: path.resolve(__dirname, 'audio.js'), dest: path.join(srcDir, 'audio.js') },
+    { src: path.resolve(__dirname, 'config.js'), dest: path.join(srcDir, 'config.js') },
+    { src: path.resolve(__dirname, 'logger.js'), dest: path.join(srcDir, 'logger.js') }
+  ];
+
+  for (const file of filesToCopy) {
+    if (fs.existsSync(file.src)) {
+      fs.copyFileSync(file.src, file.dest);
+      logger.debug('Copied file', { src: file.src, dest: file.dest });
+    }
+  }
 
-    if (fs.existsSync(notifyScript)) {
-      const normalizedPath = notifyScript.replace(/\\/g, '/');
-      return `node "${normalizedPath}"`;
+  const assetsDir = path.resolve(__dirname, '..', 'assets');
+  const targetAssetsDir = path.join(configDir, 'assets');
+  if (!fs.existsSync(targetAssetsDir)) {
+    fs.mkdirSync(targetAssetsDir, { recursive: true });
+  }
+
+  const soundsDir = path.join(assetsDir, 'sounds');
+  const targetSoundsDir = path.join(targetAssetsDir, 'sounds');
+  if (fs.existsSync(soundsDir)) {
+    if (!fs.existsSync(targetSoundsDir)) {
+      fs.mkdirSync(targetSoundsDir, { recursive: true });
     }
-  } catch (e) {}
+    const sounds = fs.readdirSync(soundsDir);
+    for (const sound of sounds) {
+      fs.copyFileSync(path.join(soundsDir, sound), path.join(targetSoundsDir, sound));
+    }
+  }
 
-  return 'node -e "require(\'claude-code-notify-lite\').run()"';
+  const runScript = `const path = require('path');
+const srcDir = path.join(__dirname, 'src');
+const { run } = require(path.join(srcDir, 'index.js'));
+run().catch(err => {
+  console.error('Notification error:', err.message);
+  process.exit(1);
+});
+`;
+  const runScriptPath = path.join(configDir, 'run.js');
+  fs.writeFileSync(runScriptPath, runScript, 'utf8');
+
+  logger.info('Copied CLI files to config directory', { configDir });
+  return runScriptPath;
+}
+
+function getHookCommand() {
+  logger.info('Generating hook command');
+
+  const nodePath = process.execPath;
+  const originalCliPath = path.resolve(__dirname, '..', 'bin', 'cli.js');
+
+  let cliPath = originalCliPath;
+  let useLocalCopy = false;
+  let command;
+
+  if (isNpxCache(originalCliPath)) {
+    logger.warn('Running from npx cache, copying files to config directory');
+    console.log('  [INFO] Detected npx execution, copying files for persistence...');
+    cliPath = copyCliToConfigDir();
+    useLocalCopy = true;
+    command = `"${nodePath}" "${cliPath}"`;
+  } else {
+    command = `"${nodePath}" "${cliPath}" run`;
+  }
+
+  logger.info('Using absolute path command', { command, nodePath, cliPath, useLocalCopy });
+  return command;
 }
 
 function readClaudeSettings() {
   const settingsPath = getClaudeSettingsPath();
+  logger.debug('Reading Claude settings', { settingsPath });
 
   if (!fs.existsSync(settingsPath)) {
+    logger.debug('Settings file not found, returning empty object');
     return {};
   }
 
   try {
     const content = fs.readFileSync(settingsPath, 'utf8');
-    return JSON.parse(content);
+    const settings = JSON.parse(content);
+    logger.debug('Settings loaded successfully');
+    return settings;
   } catch (err) {
-    if (process.env.DEBUG) {
-      console.warn('Failed to read Claude settings:', err.message);
-    }
+    logger.error('Failed to read Claude settings', err);
     return {};
   }
 }
@@ -43,11 +121,14 @@ function writeClaudeSettings(settings) {
   const settingsPath = getClaudeSettingsPath();
   const claudeDir = getClaudeConfigDir();
 
+  logger.debug('Writing Claude settings', { settingsPath });
+
   if (!fs.existsSync(claudeDir)) {
     fs.mkdirSync(claudeDir, { recursive: true });
   }
 
   fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2), 'utf8');
+  logger.info('Settings written successfully');
 }
 
 function backupClaudeSettings() {
@@ -56,6 +137,7 @@ function backupClaudeSettings() {
   if (fs.existsSync(settingsPath)) {
     const backupPath = settingsPath + '.backup';
     fs.copyFileSync(settingsPath, backupPath);
+    logger.info('Settings backed up', { backupPath });
     return backupPath;
   }
 
@@ -71,101 +153,126 @@ function isOurHook(command) {
 
 function install(options = {}) {
   console.log('Installing claude-code-notify-lite...\n');
+  logger.info('Install started', { options });
 
-  ensureConfigDir();
-  saveConfig(getDefaultConfig());
-  console.log('  [OK] Created config file');
-
-  if (options.skipHooks) {
-    console.log('  [SKIP] Hook installation skipped');
-    return { success: true, message: 'Installed without hooks' };
-  }
-
-  const backupPath = backupClaudeSettings();
-  if (backupPath) {
-    console.log(`  [OK] Backed up existing settings to ${backupPath}`);
-  }
-
-  const settings = readClaudeSettings();
-
-  if (!settings.hooks) {
-    settings.hooks = {};
-  }
+  try {
+    ensureConfigDir();
+    saveConfig(getDefaultConfig());
+    console.log('  [OK] Created config file');
+    logger.info('Config file created');
+
+    if (options.skipHooks) {
+      console.log('  [SKIP] Hook installation skipped');
+      logger.info('Hook installation skipped');
+      return { success: true, message: 'Installed without hooks' };
+    }
 
-  const hookCommand = getHookCommand();
+    const backupPath = backupClaudeSettings();
+    if (backupPath) {
+      console.log(`  [OK] Backed up existing settings to ${backupPath}`);
+    }
 
-  const stopHook = {
-    hooks: [
-      {
-        type: 'command',
-        command: hookCommand,
-        timeout: 10
-      }
-    ]
-  };
+    const settings = readClaudeSettings();
 
-  if (!settings.hooks.Stop) {
-    settings.hooks.Stop = [stopHook];
-  } else {
-    const exists = settings.hooks.Stop.some(h =>
-      h.hooks && h.hooks.some(hh => isOurHook(hh.command))
-    );
+    if (!settings.hooks) {
+      settings.hooks = {};
+    }
 
-    if (!exists) {
-      settings.hooks.Stop.push(stopHook);
+    const hookCommand = getHookCommand();
+    logger.info('Hook command generated', { hookCommand });
+
+    const stopHook = {
+      hooks: [
+        {
+          type: 'command',
+          command: hookCommand,
+          timeout: 30
+        }
+      ]
+    };
+
+    if (!settings.hooks.Stop) {
+      settings.hooks.Stop = [stopHook];
+      logger.info('Created new Stop hook');
     } else {
-      console.log('  [OK] Hook already configured');
+      const existingIndex = settings.hooks.Stop.findIndex(h =>
+        h.hooks && h.hooks.some(hh => isOurHook(hh.command))
+      );
+
+      if (existingIndex === -1) {
+        settings.hooks.Stop.push(stopHook);
+        logger.info('Added Stop hook');
+      } else {
+        settings.hooks.Stop[existingIndex] = stopHook;
+        console.log('  [OK] Updated existing hook');
+        logger.info('Updated existing Stop hook');
+      }
     }
-  }
 
-  writeClaudeSettings(settings);
-  console.log('  [OK] Configured Claude Code hooks');
+    writeClaudeSettings(settings);
+    console.log('  [OK] Configured Claude Code hooks');
 
-  console.log('\nInstallation complete!');
-  console.log('Run "ccnotify test" to verify.\n');
+    console.log('\nInstallation complete!');
+    console.log('Run "ccnotify test" or "npx ccnotify test" to verify.\n');
 
-  return { success: true };
+    logger.info('Install completed successfully');
+    return { success: true };
+  } catch (err) {
+    logger.error('Install failed', err);
+    console.error(`  [ERROR] ${err.message}`);
+    return { success: false, error: err.message };
+  }
 }
 
 function uninstall(options = {}) {
   console.log('Uninstalling claude-code-notify-lite...\n');
+  logger.info('Uninstall started', { options });
 
-  const settings = readClaudeSettings();
+  try {
+    const settings = readClaudeSettings();
+
+    if (settings.hooks && settings.hooks.Stop) {
+      settings.hooks.Stop = settings.hooks.Stop.filter(h => {
+        if (h.hooks) {
+          h.hooks = h.hooks.filter(hh => !isOurHook(hh.command));
+          return h.hooks.length > 0;
+        }
+        return true;
+      });
+
+      if (settings.hooks.Stop.length === 0) {
+        delete settings.hooks.Stop;
+      }
 
-  if (settings.hooks && settings.hooks.Stop) {
-    settings.hooks.Stop = settings.hooks.Stop.filter(h => {
-      if (h.hooks) {
-        h.hooks = h.hooks.filter(hh => !isOurHook(hh.command));
-        return h.hooks.length > 0;
+      if (Object.keys(settings.hooks).length === 0) {
+        delete settings.hooks;
       }
-      return true;
-    });
 
-    if (settings.hooks.Stop.length === 0) {
-      delete settings.hooks.Stop;
+      writeClaudeSettings(settings);
+      console.log('  [OK] Removed Claude Code hooks');
+      logger.info('Hooks removed');
     }
 
-    if (Object.keys(settings.hooks).length === 0) {
-      delete settings.hooks;
+    if (!options.keepConfig) {
+      const configDir = getConfigDir();
+      if (fs.existsSync(configDir)) {
+        fs.rmSync(configDir, { recursive: true, force: true });
+        console.log('  [OK] Removed config directory');
+        logger.info('Config directory removed', { configDir });
+      }
+    } else {
+      console.log('  [SKIP] Kept config directory');
     }
 
-    writeClaudeSettings(settings);
-    console.log('  [OK] Removed Claude Code hooks');
-  }
+    console.log('\nUninstallation complete!\n');
+    logger.info('Uninstall completed');
 
-  if (!options.keepConfig) {
-    const configDir = getConfigDir();
-    if (fs.existsSync(configDir)) {
-      fs.rmSync(configDir, { recursive: true, force: true });
-      console.log('  [OK] Removed config directory');
-    }
-  } else {
-    console.log('  [SKIP] Kept config directory');
+    return { success: true };
+  } catch (err) {
+    logger.error('Uninstall failed', err);
+    console.error(`  [ERROR] ${err.message}`);
+    return { success: false, error: err.message };
   }
-
-  console.log('\nUninstallation complete!\n');
-
-  return { success: true };
 }
 
 function checkInstallation() {
@@ -180,6 +287,8 @@ function checkInstallation() {
   const configDir = getConfigDir();
   const hasConfig = fs.existsSync(path.join(configDir, 'config.json'));
 
+  logger.debug('Installation check', { hasHook, hasConfig });
+
   return {
     installed: hasHook && hasConfig,
     hasHook,

package/src/logger.js

@@ -0,0 +1,105 @@
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const LOG_DIR_NAME = 'claude-code-notify-lite';
+const LOG_FILE_NAME = 'debug.log';
+const MAX_LOG_SIZE = 1024 * 1024;
+
+function getLogDir() {
+  const platform = os.platform();
+
+  if (platform === 'win32') {
+    return path.join(process.env.APPDATA || path.join(os.homedir(), 'AppData', 'Roaming'), LOG_DIR_NAME);
+  } else if (platform === 'darwin') {
+    return path.join(os.homedir(), 'Library', 'Logs', LOG_DIR_NAME);
+  } else {
+    return path.join(process.env.XDG_STATE_HOME || path.join(os.homedir(), '.local', 'state'), LOG_DIR_NAME);
+  }
+}
+
+function getLogPath() {
+  return path.join(getLogDir(), LOG_FILE_NAME);
+}
+
+function ensureLogDir() {
+  const logDir = getLogDir();
+  if (!fs.existsSync(logDir)) {
+    fs.mkdirSync(logDir, { recursive: true });
+  }
+  return logDir;
+}
+
+function rotateLogIfNeeded() {
+  const logPath = getLogPath();
+  if (fs.existsSync(logPath)) {
+    try {
+      const stats = fs.statSync(logPath);
+      if (stats.size > MAX_LOG_SIZE) {
+        const backupPath = logPath + '.old';
+        if (fs.existsSync(backupPath)) {
+          fs.unlinkSync(backupPath);
+        }
+        fs.renameSync(logPath, backupPath);
+      }
+    } catch (e) {}
+  }
+}
+
+function formatTime() {
+  const now = new Date();
+  const pad = (n) => String(n).padStart(2, '0');
+  return `${now.getFullYear()}-${pad(now.getMonth() + 1)}-${pad(now.getDate())} ${pad(now.getHours())}:${pad(now.getMinutes())}:${pad(now.getSeconds())}`;
+}
+
+function log(level, message, data = null) {
+  try {
+    ensureLogDir();
+    rotateLogIfNeeded();
+
+    const logPath = getLogPath();
+    let logLine = `[${formatTime()}] [${level.toUpperCase()}] ${message}`;
+
+    if (data !== null) {
+      if (data instanceof Error) {
+        logLine += ` | Error: ${data.message}`;
+        if (data.stack) {
+          logLine += ` | Stack: ${data.stack.replace(/\n/g, ' -> ')}`;
+        }
+      } else if (typeof data === 'object') {
+        logLine += ` | Data: ${JSON.stringify(data)}`;
+      } else {
+        logLine += ` | ${data}`;
+      }
+    }
+
+    logLine += '\n';
+
+    fs.appendFileSync(logPath, logLine, 'utf8');
+  } catch (e) {}
+}
+
+function info(message, data = null) {
+  log('info', message, data);
+}
+
+function error(message, data = null) {
+  log('error', message, data);
+}
+
+function debug(message, data = null) {
+  log('debug', message, data);
+}
+
+function warn(message, data = null) {
+  log('warn', message, data);
+}
+
+module.exports = {
+  info,
+  error,
+  debug,
+  warn,
+  getLogPath,
+  getLogDir
+};

package/src/notifier.js

@@ -4,6 +4,7 @@ const fs = require('fs');
 const os = require('os');
 const { exec } = require('child_process');
 const { loadConfig } = require('./config');
+const logger = require('./logger');
 
 function getIconPath() {
   const iconPath = path.join(__dirname, '..', 'assets', 'icon.png');
@@ -12,6 +13,8 @@ function getIconPath() {
 
 function notifyWindows(title, message) {
   return new Promise((resolve) => {
+    logger.info('Sending Windows notification', { title, messageLength: message.length });
+
     const escapedTitle = title.replace(/"/g, '\\"');
     const escapedMessage = message.replace(/"/g, '\\"').replace(/\n/g, '`n');
 
@@ -38,6 +41,7 @@ function notifyWindows(title, message) {
       { encoding: 'utf8', windowsHide: true },
       (err) => {
         if (err) {
+          logger.warn('Windows Toast failed, falling back to node-notifier', err);
           notifier.notify({
             title: title,
             message: message,
@@ -45,8 +49,16 @@ function notifyWindows(title, message) {
             wait: false,
             timeout: 5,
             appID: 'Claude Code'
-          }, () => resolve());
+          }, (notifyErr) => {
+            if (notifyErr) {
+              logger.error('node-notifier also failed', notifyErr);
+            } else {
+              logger.info('Fallback notification sent');
+            }
+            resolve();
+          });
         } else {
+          logger.info('Windows Toast notification sent successfully');
           resolve();
         }
       }
@@ -55,9 +67,12 @@ function notifyWindows(title, message) {
 }
 
 function notify(options = {}) {
+  logger.debug('notify called', options);
+
   const config = loadConfig();
 
   if (!config.notification || !config.notification.enabled) {
+    logger.info('Notification disabled in config');
     return Promise.resolve();
   }
 
@@ -73,12 +88,14 @@ function notify(options = {}) {
   }
 
   const platform = os.platform();
+  logger.info('Platform detected', { platform });
 
   if (platform === 'win32') {
     return notifyWindows(title, message);
   }
 
   const iconPath = getIconPath();
+  logger.debug('Icon path', { iconPath });
 
   const notificationOptions = {
     title: title,
@@ -101,11 +118,17 @@ function notify(options = {}) {
 
   return new Promise((resolve) => {
     const timeoutId = setTimeout(() => {
+      logger.warn('Notification timed out');
       resolve();
     }, 10000);
 
     notifier.notify(notificationOptions, (err, response) => {
       clearTimeout(timeoutId);
+      if (err) {
+        logger.error('Notification error', err);
+      } else {
+        logger.info('Notification sent', { response });
+      }
       resolve(response);
     });
   });