claude-mem 2.1.2 → 3.0.2

package/hooks/pre-compact.js

@@ -1,58 +1,211 @@
 #!/usr/bin/env node
 
 /**
- * Claude Memory System - Pre-Compact Hook (Refactored)
- * Uses shared utilities to eliminate code duplication
+ * 🔒 LOCKED by @docs-agent | Change to 🔑 to allow @docs-agent edits
+ * 
+ * OFFICIAL DOCS: Claude Code Hooks API v2025
+ * Last Verified: 2025-08-31
+ * @see https://docs.anthropic.com/en/docs/claude-code/hooks
+ * 
+ * Claude Memory System - Pre-Compact Hook
+ * 
+ * CRITICAL REQUIREMENTS:
+ * - Hook responses MUST use 'continue' field (boolean)
+ * - When continue is false, MUST provide 'stopReason' field
+ * - DO NOT use 'decision' or 'reason' fields (deprecated pattern)
+ * - PreCompact hooks DO NOT support hookSpecificOutput field
+ * - Exit codes: 0=success, 1=error shown to user, 2=error with stderr shown
+ * 
+ * Valid Response Format:
+ * Success: { "continue": true }
+ * Failure: { "continue": false, "stopReason": "error message" }
+ * 
+ * @docs-ref: Official hook response format specification
+ * @see https://docs.anthropic.com/claude-code/hooks#response-format
  */
 
-import { loadHookConfig, readStdinJson, HookResponse, spawnCLI } from './hook-utils.js';
+import { spawn } from 'child_process';
+import { join, dirname, resolve, isAbsolute } from 'path';
+import { fileURLToPath } from 'url';
+import { readFileSync, existsSync } from 'fs';
 
-async function preCompactHook() {
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+// Load configuration to get the CLI command name
+let cliCommand = 'claude-mem';  // Default fallback
+const configPath = join(__dirname, 'config.json');
+if (existsSync(configPath)) {
   try {
-    // Load config and read input using utilities
-    const config = loadHookConfig();
-    const data = await readStdinJson();
-    
-    const transcriptPath = data.transcript_path;
-    
-    if (!transcriptPath) {
-      console.log(JSON.stringify(HookResponse.error("No transcript path provided")));
-      process.exit(2);
-    }
-    
-    // Use spawnCLI utility for compression
-    const cliCommand = config.cliCommand || 'claude-mem';
-    
+    const config = JSON.parse(readFileSync(configPath, 'utf-8'));
+    cliCommand = config.cliCommand || 'claude-mem';
+  } catch (e) {
+    // Fallback to default if config read fails
+  }
+}
+
+/**
+ * Sanitizes and validates file path to prevent command injection
+ */
+function sanitizeFilePath(filePath) {
+  if (!filePath || typeof filePath !== 'string') {
+    return null;
+  }
+  
+  // Remove any null bytes or control characters
+  const cleanPath = filePath.replace(/[\x00-\x1f\x7f-\x9f]/g, '');
+  
+  // Reject paths with shell metacharacters that could be used for injection
+  const dangerousChars = /[;&|`$(){}[\]<>]/;
+  if (dangerousChars.test(cleanPath)) {
+    return null;
+  }
+  
+  // Convert to absolute path to prevent directory traversal
+  let safePath;
+  try {
+    safePath = isAbsolute(cleanPath) ? resolve(cleanPath) : resolve(process.cwd(), cleanPath);
+  } catch (error) {
+    return null;
+  }
+  
+  // Basic path validation - must be a reasonable file path
+  if (safePath.length > 4096) { // Reasonable path length limit
+    return null;
+  }
+  
+  return safePath;
+}
+
+async function preCompactHook() {
+  let input = '';
+  
+  // Read JSON input from stdin
+  process.stdin.on('data', chunk => {
+    input += chunk;
+  });
+  
+  process.stdin.on('end', async () => {
     try {
-      await spawnCLI(cliCommand, ['compress', transcriptPath]);
+      const data = JSON.parse(input);
+      const transcriptPath = data.transcript_path;
       
-      // Success - output response
-      console.log(JSON.stringify({
-        continue: true,
-        suppressOutput: true
-      }));
-      process.exit(0);
+      if (!transcriptPath) {
+        // Output error in Claude Code expected format
+        // @docs-ref: continue: false with stopReason for blocking operations
+        console.log(JSON.stringify({
+          continue: false,
+          stopReason: "No transcript path provided"
+        }));
+        process.exit(2); // Exit 2 tells Claude Code to show error
+      }
       
-    } catch (error) {
-      // Check for expected Claude SDK error
-      if (error.message.includes('Claude Code executable not found')) {
+      // SECURITY: Sanitize transcript path to prevent command injection
+      const sanitizedPath = sanitizeFilePath(transcriptPath);
+      if (!sanitizedPath) {
         console.log(JSON.stringify({
-          continue: true,
-          suppressOutput: true,
-          systemMessage: "Memory compression skipped - Claude SDK not available in this context"
+          continue: false,
+          stopReason: "Invalid or potentially unsafe transcript path"
         }));
-        process.exit(0);
-      } else {
-        // Real error
-        console.log(JSON.stringify(HookResponse.error(`Compression failed: ${error.message}`)));
         process.exit(2);
       }
+      
+      // Call the CLI compress command using configured name with sanitized path
+      const compressor = spawn(cliCommand, ['compress', sanitizedPath], {
+        stdio: ['ignore', 'pipe', 'pipe'] // Capture output instead of inherit
+      });
+      
+      let stdout = '';
+      let stderr = '';
+      let isCompleted = false;
+      
+      // Add timeout to prevent hanging hooks
+      const hookTimeout = setTimeout(() => {
+        if (!isCompleted) {
+          compressor.kill('SIGTERM');
+          console.log(JSON.stringify({
+            continue: true,
+            suppressOutput: true,
+            systemMessage: "Memory compression timed out - continuing with compaction"
+          }));
+          process.exit(0);
+        }
+      }, 10000); // 10 second timeout
+      
+      compressor.stdout.on('data', (data) => {
+        stdout += data.toString();
+      });
+      
+      compressor.stderr.on('data', (data) => {
+        stderr += data.toString();
+      });
+      
+      compressor.on('close', (code) => {
+        isCompleted = true;
+        clearTimeout(hookTimeout);
+        if (code !== 0) {
+          // Check if it's the Claude Code executable error
+          if (stderr.includes('Claude Code executable not found')) {
+            // This is expected when running outside Claude Code context
+            // Just output success since we can't compress without Claude SDK
+            // @docs-ref: PreCompact hooks should only use continue field, not hookSpecificOutput
+            console.log(JSON.stringify({
+              continue: true,
+              suppressOutput: true,
+              systemMessage: "Memory compression skipped - Claude SDK not available in this context"
+            }));
+            process.exit(0);
+          } else {
+            // Real error - report it
+            // @docs-ref: Use continue: false with stopReason for errors
+            console.log(JSON.stringify({
+              continue: false,
+              stopReason: `Compression failed: ${stderr}`
+            }));
+            process.exit(2);
+          }
+        } else {
+          // Success! Output confirmation
+          // @docs-ref: PreCompact hooks should only use continue field for success
+          console.log(JSON.stringify({
+            continue: true,
+            suppressOutput: true
+          }));
+          process.exit(0);
+        }
+      });
+      
+      compressor.on('error', (error) => {
+        isCompleted = true;
+        clearTimeout(hookTimeout);
+        
+        // Handle common error cases gracefully
+        if (error.code === 'ENOENT') {
+          // CLI command not found - likely running in test environment
+          console.log(JSON.stringify({
+            continue: true,
+            suppressOutput: true,
+            systemMessage: "Memory compression skipped - CLI not available in test environment"
+          }));
+          process.exit(0);
+        } else {
+          // @docs-ref: Use continue: false with stopReason for errors
+          console.log(JSON.stringify({
+            continue: false,
+            stopReason: `Failed to start compression: ${error.message}`
+          }));
+          process.exit(2);
+        }
+      });
+      
+    } catch (error) {
+      // @docs-ref: Use continue: false with stopReason for errors
+      console.log(JSON.stringify({
+        continue: false,
+        stopReason: `Hook error: ${error.message}`
+      }));
+      process.exit(2);
     }
-    
-  } catch (error) {
-    console.log(JSON.stringify(HookResponse.error(`Hook error: ${error.message}`)));
-    process.exit(2);
-  }
+  });
 }
 
 preCompactHook();

package/hooks/session-end.js

@@ -1,77 +1,157 @@
 #!/usr/bin/env node
 
 /**
- * Claude Memory System - Session-End Hook (Refactored)
- * Uses shared utilities to eliminate code duplication
+ * 🔑 LOCKED by @docs-agent | Change to 🔑 to allow @docs-agent edits
  * 
+ * OFFICIAL DOCS: Claude Code SessionEnd Hook v2025
+ * Last Verified: 2025-08-31
+ * @see https://docs.anthropic.com/en/docs/claude-code/hooks
+ * 
+ * Claude Memory System - Session End Hook
  * Triggers compression when session ends with reason 'clear'
- * Always returns continue: true to avoid blocking session termination
+ * 
+ * SessionEnd Hook Payload:
+ * {
+ *   "session_id": "string",
+ *   "transcript_path": "string",
+ *   "cwd": "string",
+ *   "hook_event_name": "SessionEnd",
+ *   "reason": "exit" | "clear" | "error" | ...
+ * }
+ * 
+ * Valid Response Format:
+ * Success: { "continue": true }
+ * Success with message: { "continue": true, "systemMessage": "string" }
+ * Failure: { "continue": false, "stopReason": "error message" }
+ * 
+ * Note: SessionEnd hooks should generally always return continue: true
+ * to avoid blocking session termination.
+ * 
+ * @docs-ref: SessionEnd hook should not block session ending
+ * @see https://docs.anthropic.com/claude-code/hooks#sessionend
  */
 
-import { loadHookConfig, readStdinJson, HookResponse, spawnCLI } from './hook-utils.js';
+import { spawn } from 'child_process';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { readFileSync, existsSync } from 'fs';
 
-async function sessionEndHook() {
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+// Load configuration to get the CLI command name
+let cliCommand = 'claude-mem';  // Default fallback
+const configPath = join(__dirname, 'config.json');
+if (existsSync(configPath)) {
   try {
-    // Load config and read input using utilities
-    const config = loadHookConfig();
-    const data = await readStdinJson();
-    
-    const { reason, transcript_path } = data;
-    
-    // Only proceed if reason is 'clear'
-    if (reason !== 'clear') {
-      console.log(JSON.stringify({ continue: true }));
-      process.exit(0);
-    }
-    
-    // Validate transcript path
-    if (!transcript_path) {
-      console.log(JSON.stringify({
-        continue: true,
-        systemMessage: "Warning: No transcript path provided for compression"
-      }));
-      process.exit(0);
-    }
-    
-    // Use spawnCLI utility for compression
-    const cliCommand = config.cliCommand || 'claude-mem';
-    
+    const config = JSON.parse(readFileSync(configPath, 'utf-8'));
+    cliCommand = config.cliCommand || 'claude-mem';
+  } catch (e) {
+    // Fallback to default if config read fails
+  }
+}
+
+async function sessionEndHook() {
+  let input = '';
+  
+  // Read JSON input from stdin
+  process.stdin.on('data', chunk => {
+    input += chunk;
+  });
+  
+  process.stdin.on('end', async () => {
     try {
-      await spawnCLI(cliCommand, ['compress', transcript_path]);
+      const data = JSON.parse(input);
+      const { reason, transcript_path, session_id } = data;
       
-      // Success! Memory compressed before session clear
-      console.log(JSON.stringify({
-        continue: true,
-        suppressOutput: true,
-        systemMessage: "Memory compressed successfully before session clear"
-      }));
+      // Only proceed if reason is 'clear'
+      if (reason !== 'clear') {
+        // For other reasons, just continue without action
+        // @docs-ref: SessionEnd hooks should not use hookSpecificOutput
+        console.log(JSON.stringify({
+          continue: true
+        }));
+        process.exit(0);
+      }
       
-    } catch (error) {
-      // Check for expected Claude SDK error
-      if (error.message.includes('Claude Code executable not found')) {
+      // Validate transcript path
+      if (!transcript_path) {
+        // @docs-ref: SessionEnd should not block session ending
+        // Just continue even if we can't compress
         console.log(JSON.stringify({
           continue: true,
-          suppressOutput: true
+          systemMessage: "Warning: No transcript path provided for compression"
         }));
-      } else {
-        // Real error - report it but allow session to end
+        process.exit(0);
+      }
+      
+      // Call the CLI compress command (same as pre-compact)
+      const compressor = spawn(cliCommand, ['compress', transcript_path], {
+        stdio: ['ignore', 'pipe', 'pipe']
+      });
+      
+      let stdout = '';
+      let stderr = '';
+      
+      compressor.stdout.on('data', (data) => {
+        stdout += data.toString();
+      });
+      
+      compressor.stderr.on('data', (data) => {
+        stderr += data.toString();
+      });
+      
+      compressor.on('close', (code) => {
+        if (code !== 0) {
+          // Check if it's the Claude Code executable error
+          if (stderr.includes('Claude Code executable not found')) {
+            // This is expected when running outside Claude Code context
+            // @docs-ref: SessionEnd hooks should not use hookSpecificOutput
+            console.log(JSON.stringify({
+              continue: true,
+              suppressOutput: true
+            }));
+            process.exit(0);
+          } else {
+            // Real error - report it but allow session to end
+            // @docs-ref: Always allow session to end, use systemMessage for errors
+            console.log(JSON.stringify({
+              continue: true,
+              systemMessage: `Memory compression failed: ${stderr}`
+            }));
+            process.exit(0);
+          }
+        } else {
+          // Success! Memory compressed before session clear
+          // @docs-ref: SessionEnd hooks should not use hookSpecificOutput
+          console.log(JSON.stringify({
+            continue: true,
+            suppressOutput: true,
+            systemMessage: "Memory compressed successfully before session clear"
+          }));
+          process.exit(0);
+        }
+      });
+      
+      compressor.on('error', (error) => {
+        // Report error but allow session to end
+        // @docs-ref: Always allow session to end, use systemMessage for errors
         console.log(JSON.stringify({
           continue: true,
-          systemMessage: `Memory compression failed: ${error.message}`
+          systemMessage: `Failed to start compression: ${error.message}`
         }));
-      }
+        process.exit(0);
+      });
+      
+    } catch (error) {
+      // Report error but allow session to end
+      // @docs-ref: Always allow session to end, use systemMessage for errors
+      console.log(JSON.stringify({
+        continue: true,
+        systemMessage: `Hook error: ${error.message}`
+      }));
+      process.exit(0);
     }
-    
-    process.exit(0);
-    
-  } catch (error) {
-    // Report error but allow session to end
-    console.log(JSON.stringify({
-      continue: true,
-      systemMessage: `Hook error: ${error.message}`
-    }));
-    process.exit(0);
-  }
+  });
 }
 
 sessionEndHook();