claude-depester 1.3.6 → 1.4.0

package/lib/bun-binary.js

@@ -14,7 +14,11 @@ const BUN_TRAILER = Buffer.from('\n---- Bun! ----\n');
 // Size constants for binary structures
 const SIZEOF_OFFSETS = 32;
 const SIZEOF_STRING_POINTER = 8;
-const SIZEOF_MODULE = 4 * SIZEOF_STRING_POINTER + 4;
+// Module struct sizes vary by Bun version:
+// - Old format (pre-ESM bytecode, before Bun ~1.3.7): 4 StringPointers + 4 u8s = 36 bytes
+// - New format (ESM bytecode, Bun ~1.3.7+): 6 StringPointers + 4 u8s = 52 bytes
+const SIZEOF_MODULE_OLD = 4 * SIZEOF_STRING_POINTER + 4;
+const SIZEOF_MODULE_NEW = 6 * SIZEOF_STRING_POINTER + 4;
 
 /**
  * Parse a StringPointer from buffer at offset
@@ -48,14 +52,29 @@ function parseOffsets(buffer) {
   const entryPointId = buffer.readUInt32LE(pos);
   pos += 4;
   const compileExecArgvPtr = parseStringPointer(buffer, pos);
+  pos += 8;
+  const flags = buffer.readUInt32LE(pos);
   
-  return { byteCount, modulesPtr, entryPointId, compileExecArgvPtr };
+  return { byteCount, modulesPtr, entryPointId, compileExecArgvPtr, flags };
+}
+
+/**
+ * Detect the module struct size from the modules list byte length
+ */
+function detectModuleStructSize(modulesListLength) {
+  const fitsNew = modulesListLength % SIZEOF_MODULE_NEW === 0;
+  const fitsOld = modulesListLength % SIZEOF_MODULE_OLD === 0;
+  
+  if (fitsNew && !fitsOld) return SIZEOF_MODULE_NEW;
+  if (fitsOld && !fitsNew) return SIZEOF_MODULE_OLD;
+  // Ambiguous or neither - prefer new format for recent Bun versions
+  return SIZEOF_MODULE_NEW;
 }
 
 /**
  * Parse a compiled module from buffer
  */
-function parseCompiledModule(buffer, offset) {
+function parseCompiledModule(buffer, offset, moduleStructSize) {
   let pos = offset;
   const name = parseStringPointer(buffer, pos);
   pos += 8;
@@ -65,6 +84,18 @@ function parseCompiledModule(buffer, offset) {
   pos += 8;
   const bytecode = parseStringPointer(buffer, pos);
   pos += 8;
+  
+  let moduleInfo, bytecodeOriginPath;
+  if (moduleStructSize === SIZEOF_MODULE_NEW) {
+    moduleInfo = parseStringPointer(buffer, pos);
+    pos += 8;
+    bytecodeOriginPath = parseStringPointer(buffer, pos);
+    pos += 8;
+  } else {
+    moduleInfo = { offset: 0, length: 0 };
+    bytecodeOriginPath = { offset: 0, length: 0 };
+  }
+  
   const encoding = buffer.readUInt8(pos);
   pos += 1;
   const loader = buffer.readUInt8(pos);
@@ -73,31 +104,34 @@ function parseCompiledModule(buffer, offset) {
   pos += 1;
   const side = buffer.readUInt8(pos);
   
-  return { name, contents, sourcemap, bytecode, encoding, loader, moduleFormat, side };
+  return { name, contents, sourcemap, bytecode, moduleInfo, bytecodeOriginPath, encoding, loader, moduleFormat, side };
 }
 
 /**
  * Check if module name is the claude entrypoint
+ * Claude Code 2.0.69+ changed from '/claude' to 'file:///src/entrypoints/cli.js.jsc'
  */
 function isClaudeModule(moduleName) {
   return (
     moduleName.endsWith('/claude') ||
     moduleName === 'claude' ||
     moduleName.endsWith('/claude.exe') ||
-    moduleName === 'claude.exe'
+    moduleName === 'claude.exe' ||
+    moduleName.includes('/cli.js') ||
+    moduleName.endsWith('cli.js.jsc')
   );
 }
 
 /**
  * Iterate over modules in Bun data
  */
-function mapModules(bunData, bunOffsets, visitor) {
+function mapModules(bunData, bunOffsets, moduleStructSize, visitor) {
   const modulesListBytes = getStringPointerContent(bunData, bunOffsets.modulesPtr);
-  const modulesListCount = Math.floor(modulesListBytes.length / SIZEOF_MODULE);
+  const modulesListCount = Math.floor(modulesListBytes.length / moduleStructSize);
   
   for (let i = 0; i < modulesListCount; i++) {
-    const offset = i * SIZEOF_MODULE;
-    const module = parseCompiledModule(modulesListBytes, offset);
+    const offset = i * moduleStructSize;
+    const module = parseCompiledModule(modulesListBytes, offset, moduleStructSize);
     const moduleName = getStringPointerContent(bunData, module.name).toString('utf-8');
     
     const result = visitor(module, moduleName, i);
@@ -129,8 +163,9 @@ function parseBunDataBlob(bunDataContent) {
   const offsetsStart = bunDataContent.length - SIZEOF_OFFSETS - BUN_TRAILER.length;
   const offsetsBytes = bunDataContent.subarray(offsetsStart, offsetsStart + SIZEOF_OFFSETS);
   const bunOffsets = parseOffsets(offsetsBytes);
+  const moduleStructSize = detectModuleStructSize(bunOffsets.modulesPtr.length);
   
-  return { bunOffsets, bunData: bunDataContent };
+  return { bunOffsets, bunData: bunDataContent, moduleStructSize };
 }
 
 /**
@@ -163,9 +198,9 @@ function extractBunDataFromSection(sectionData) {
   }
   
   const bunDataContent = sectionData.subarray(headerSize, headerSize + bunDataSize);
-  const { bunOffsets, bunData } = parseBunDataBlob(bunDataContent);
+  const { bunOffsets, bunData, moduleStructSize } = parseBunDataBlob(bunDataContent);
   
-  return { bunOffsets, bunData, sectionHeaderSize: headerSize };
+  return { bunOffsets, bunData, sectionHeaderSize: headerSize, moduleStructSize };
 }
 
 /**
@@ -209,8 +244,9 @@ function extractBunDataFromELFOverlay(elfBinary) {
   
   // Reconstruct blob [data][offsets][trailer]
   const bunDataBlob = Buffer.concat([dataRegion, offsetsBytes, trailerBytes]);
+  const moduleStructSize = detectModuleStructSize(bunOffsets.modulesPtr.length);
   
-  return { bunOffsets, bunData: bunDataBlob };
+  return { bunOffsets, bunData: bunDataBlob, moduleStructSize };
 }
 
 /**
@@ -259,34 +295,16 @@ function extractClaudeJs(binaryPath) {
   try {
     LIEF.logging.disable();
     const binary = LIEF.parse(binaryPath);
-    const { bunOffsets, bunData } = getBunData(binary);
+    const { bunOffsets, bunData, moduleStructSize } = getBunData(binary);
     
-    let target = null;
-    
-    mapModules(bunData, bunOffsets, (module, moduleName) => {
-      // Check contents
-      const moduleContents = getStringPointerContent(bunData, module.contents);
-      if (moduleContents.includes('Flibbertigibbeting')) {
-        target = { content: moduleContents, moduleName, type: 'contents' };
-        return true;
-      }
-      
-      // Check bytecode (for new versions where source is embedded in bytecode)
-      const moduleBytecode = getStringPointerContent(bunData, module.bytecode);
-      if (moduleBytecode.includes('Flibbertigibbeting')) {
-        target = { content: moduleBytecode, moduleName, type: 'bytecode' };
-        return true;
-      }
+    const result = mapModules(bunData, bunOffsets, moduleStructSize, (module, moduleName) => {
+      if (!isClaudeModule(moduleName)) return undefined;
       
-      // Fallback
-      if (isClaudeModule(moduleName) && !target) {
-        target = { content: moduleContents, moduleName, type: 'contents' };
-      }
-      
-      return undefined;
+      const moduleContents = getStringPointerContent(bunData, module.contents);
+      return moduleContents.length > 0 ? moduleContents : undefined;
     });
     
-    return target;
+    return result || null;
   } catch (error) {
     return null;
   }
@@ -295,39 +313,46 @@ function extractClaudeJs(binaryPath) {
 /**
  * Rebuild Bun data with modified claude.js
  */
-function rebuildBunData(bunData, bunOffsets, modifiedClaudeJs, targetModuleName, targetType) {
+function rebuildBunData(bunData, bunOffsets, modifiedClaudeJs, moduleStructSize) {
   // Collect all string data and module metadata
   const stringsData = [];
   const modulesMetadata = [];
+  const stringsPerModule = moduleStructSize === SIZEOF_MODULE_NEW ? 6 : 4;
   
-  mapModules(bunData, bunOffsets, (module, moduleName) => {
+  mapModules(bunData, bunOffsets, moduleStructSize, (module, moduleName) => {
     const nameBytes = getStringPointerContent(bunData, module.name);
     
-    let contentsBytes = getStringPointerContent(bunData, module.contents);
-    let bytecodeBytes = getStringPointerContent(bunData, module.bytecode);
-    
-    if (modifiedClaudeJs && moduleName === targetModuleName) {
-      if (targetType === 'bytecode') {
-        bytecodeBytes = modifiedClaudeJs;
-      } else {
-        contentsBytes = modifiedClaudeJs;
-      }
+    // Use modified contents for claude module
+    let contentsBytes;
+    if (modifiedClaudeJs && isClaudeModule(moduleName)) {
+      contentsBytes = modifiedClaudeJs;
+    } else {
+      contentsBytes = getStringPointerContent(bunData, module.contents);
     }
     
     const sourcemapBytes = getStringPointerContent(bunData, module.sourcemap);
+    const bytecodeBytes = getStringPointerContent(bunData, module.bytecode);
+    const moduleInfoBytes = getStringPointerContent(bunData, module.moduleInfo);
+    const bytecodeOriginPathBytes = getStringPointerContent(bunData, module.bytecodeOriginPath);
     
     modulesMetadata.push({
       name: nameBytes,
       contents: contentsBytes,
       sourcemap: sourcemapBytes,
       bytecode: bytecodeBytes,
+      moduleInfo: moduleInfoBytes,
+      bytecodeOriginPath: bytecodeOriginPathBytes,
       encoding: module.encoding,
       loader: module.loader,
       moduleFormat: module.moduleFormat,
       side: module.side,
     });
     
-    stringsData.push(nameBytes, contentsBytes, sourcemapBytes, bytecodeBytes);
+    if (moduleStructSize === SIZEOF_MODULE_NEW) {
+      stringsData.push(nameBytes, contentsBytes, sourcemapBytes, bytecodeBytes, moduleInfoBytes, bytecodeOriginPathBytes);
+    } else {
+      stringsData.push(nameBytes, contentsBytes, sourcemapBytes, bytecodeBytes);
+    }
     return undefined;
   });
   
@@ -341,7 +366,7 @@ function rebuildBunData(bunData, bunOffsets, modifiedClaudeJs, targetModuleName,
   }
   
   const modulesListOffset = currentOffset;
-  const modulesListSize = modulesMetadata.length * SIZEOF_MODULE;
+  const modulesListSize = modulesMetadata.length * moduleStructSize;
   currentOffset += modulesListSize;
   
   const compileExecArgvBytes = getStringPointerContent(bunData, bunOffsets.compileExecArgvPtr);
@@ -377,8 +402,8 @@ function rebuildBunData(bunData, bunOffsets, modifiedClaudeJs, targetModuleName,
   
   // Write module structures
   for (let i = 0; i < modulesMetadata.length; i++) {
-    const baseStringIdx = i * 4;
-    const moduleOffset = modulesListOffset + i * SIZEOF_MODULE;
+    const baseStringIdx = i * stringsPerModule;
+    const moduleOffset = modulesListOffset + i * moduleStructSize;
     let pos = moduleOffset;
     
     // Write StringPointers
@@ -395,6 +420,16 @@ function rebuildBunData(bunData, bunOffsets, modifiedClaudeJs, targetModuleName,
     newBuffer.writeUInt32LE(stringOffsets[baseStringIdx + 3].length, pos + 4);
     pos += 8;
     
+    // Write new-format-only StringPointers
+    if (moduleStructSize === SIZEOF_MODULE_NEW) {
+      newBuffer.writeUInt32LE(stringOffsets[baseStringIdx + 4].offset, pos);
+      newBuffer.writeUInt32LE(stringOffsets[baseStringIdx + 4].length, pos + 4);
+      pos += 8;
+      newBuffer.writeUInt32LE(stringOffsets[baseStringIdx + 5].offset, pos);
+      newBuffer.writeUInt32LE(stringOffsets[baseStringIdx + 5].length, pos + 4);
+      pos += 8;
+    }
+    
     // Write flags
     newBuffer.writeUInt8(modulesMetadata[i].encoding, pos);
     newBuffer.writeUInt8(modulesMetadata[i].loader, pos + 1);
@@ -413,6 +448,8 @@ function rebuildBunData(bunData, bunOffsets, modifiedClaudeJs, targetModuleName,
   offsetsPos += 4;
   newBuffer.writeUInt32LE(compileExecArgvOffset, offsetsPos);
   newBuffer.writeUInt32LE(compileExecArgvLength, offsetsPos + 4);
+  offsetsPos += 8;
+  newBuffer.writeUInt32LE(bunOffsets.flags || 0, offsetsPos);
   
   // Write trailer
   BUN_TRAILER.copy(newBuffer, trailerOffset);
@@ -457,43 +494,55 @@ function repackELF(elfBinary, binaryPath, newBunBuffer, outputPath) {
 }
 
 /**
- * Repack MachO binary with modified Bun data
+ * Repack MachO binary with modified Bun data using raw file write.
+ * Bypasses LIEF write() which has a bug that bloats MachO binaries.
+ * Instead, writes the patched section data directly at the file offset.
  */
 function repackMachO(machoBinary, binaryPath, newBunBuffer, outputPath, sectionHeaderSize) {
   const fs = require('fs');
   const { execSync } = require('child_process');
   
-  // Remove code signature
-  if (machoBinary.hasCodeSignature) {
-    machoBinary.removeSignature();
-  }
-  
   const bunSegment = machoBinary.getSegment('__BUN');
   const bunSection = bunSegment.getSection('__bun');
   
+  const originalSectionSize = Number(bunSection.size);
+  const sectionFileOffset = Number(bunSection.offset);
+  
   const newSectionData = buildSectionData(newBunBuffer, sectionHeaderSize);
-  const sizeDiff = newSectionData.length - Number(bunSection.size);
   
-  if (sizeDiff > 0) {
-    const isARM64 = machoBinary.header.cpuType === LIEF.MachO.Header.CPU_TYPE.ARM64;
-    const PAGE_SIZE = isARM64 ? 16384 : 4096;
-    const alignedSizeDiff = Math.ceil(sizeDiff / PAGE_SIZE) * PAGE_SIZE;
-    
-    machoBinary.extendSegment(bunSegment, alignedSizeDiff);
+  if (newSectionData.length > originalSectionSize) {
+    throw new Error(
+      `Patched section data (${newSectionData.length}) is larger than original (${originalSectionSize}). ` +
+      'This should not happen since we only replace arrays with shorter content.'
+    );
   }
   
-  bunSection.content = newSectionData;
-  bunSection.size = BigInt(newSectionData.length);
+  // Pad new section data to original size so binary layout stays identical
+  const paddedSectionData = Buffer.alloc(originalSectionSize, 0);
+  newSectionData.copy(paddedSectionData, 0);
+  // Update the size header to reflect actual data size (not padded)
+  if (sectionHeaderSize === 8) {
+    paddedSectionData.writeBigUInt64LE(BigInt(newBunBuffer.length), 0);
+  } else {
+    paddedSectionData.writeUInt32LE(newBunBuffer.length, 0);
+  }
   
-  // Write atomically
+  // Raw file write: copy original binary, overwrite section bytes
   const tempPath = outputPath + '.tmp';
-  machoBinary.write(tempPath);
+  fs.copyFileSync(binaryPath, tempPath);
+  
+  const fd = fs.openSync(tempPath, 'r+');
+  try {
+    fs.writeSync(fd, paddedSectionData, 0, paddedSectionData.length, sectionFileOffset);
+  } finally {
+    fs.closeSync(fd);
+  }
   
   const origStat = fs.statSync(binaryPath);
   fs.chmodSync(tempPath, origStat.mode);
   fs.renameSync(tempPath, outputPath);
   
-  // Re-sign with ad-hoc signature
+  // Re-sign with ad-hoc signature (needed on macOS after modifying binary)
   try {
     execSync(`codesign -s - -f "${outputPath}"`, { stdio: 'ignore' });
   } catch (e) {
@@ -502,34 +551,59 @@ function repackMachO(machoBinary, binaryPath, newBunBuffer, outputPath, sectionH
 }
 
 /**
- * Repack PE binary with modified Bun data
+ * Repack PE binary with modified Bun data using raw file write.
+ * Bypasses LIEF write() to avoid potential binary corruption.
  */
 function repackPE(peBinary, binaryPath, newBunBuffer, outputPath, sectionHeaderSize) {
   const fs = require('fs');
   
   const bunSection = peBinary.sections().find(s => s.name === '.bun');
+  
+  const originalSectionSize = Number(bunSection.size);
+  // PE section file offset property name varies by node-lief version
+  const sectionFileOffset = Number(bunSection.pointerToRawData || bunSection.pointersToRawData || bunSection.offset);
+  
   const newSectionData = buildSectionData(newBunBuffer, sectionHeaderSize);
   
-  bunSection.content = newSectionData;
-  bunSection.virtualSize = BigInt(newSectionData.length);
-  bunSection.size = BigInt(newSectionData.length);
+  if (newSectionData.length > originalSectionSize) {
+    throw new Error(
+      `Patched section data (${newSectionData.length}) is larger than original (${originalSectionSize}). ` +
+      'This should not happen since we only replace arrays with shorter content.'
+    );
+  }
   
-  // Write atomically
+  // Pad new section data to original size so binary layout stays identical
+  const paddedSectionData = Buffer.alloc(originalSectionSize, 0);
+  newSectionData.copy(paddedSectionData, 0);
+  if (sectionHeaderSize === 8) {
+    paddedSectionData.writeBigUInt64LE(BigInt(newBunBuffer.length), 0);
+  } else {
+    paddedSectionData.writeUInt32LE(newBunBuffer.length, 0);
+  }
+  
+  // Raw file write: copy original binary, overwrite section bytes
   const tempPath = outputPath + '.tmp';
-  peBinary.write(tempPath);
+  fs.copyFileSync(binaryPath, tempPath);
+  
+  const fd = fs.openSync(tempPath, 'r+');
+  try {
+    fs.writeSync(fd, paddedSectionData, 0, paddedSectionData.length, sectionFileOffset);
+  } finally {
+    fs.closeSync(fd);
+  }
+  
   fs.renameSync(tempPath, outputPath);
 }
 
 /**
  * Repack native installation with modified claude.js
  */
-function repackNativeInstallation(binaryPath, modifiedClaudeJs, outputPath, targetModuleName, targetType) {
+function repackNativeInstallation(binaryPath, modifiedClaudeJs, outputPath) {
   LIEF.logging.disable();
   const binary = LIEF.parse(binaryPath);
   
-  const { bunOffsets, bunData, sectionHeaderSize } = getBunData(binary);
-  // Pass targetModuleName and targetType
-  const newBuffer = rebuildBunData(bunData, bunOffsets, modifiedClaudeJs, targetModuleName, targetType);
+  const { bunOffsets, bunData, sectionHeaderSize, moduleStructSize } = getBunData(binary);
+  const newBuffer = rebuildBunData(bunData, bunOffsets, modifiedClaudeJs, moduleStructSize);
   
   switch (binary.format) {
     case 'MachO':

package/lib/detector.js

@@ -153,9 +153,6 @@ function getPotentialPaths() {
     path.join(HOME, '.vscode', 'extensions'),           // VS Code (all platforms)
     path.join(HOME, '.vscode-oss', 'extensions'),       // VSCodium (Linux)
     path.join(HOME, '.vscode-insiders', 'extensions'),  // VS Code Insiders
-    path.join(HOME, '.vscode-server', 'extensions'),    // VS Code Remote Server
-    path.join(HOME, '.vscode-server-insiders', 'extensions'), // VS Code Remote Server (Insiders)
-    path.join(HOME, '.cursor-server', 'extensions'),    // Cursor Remote Server
   ];
   
   // Add Windows-specific paths

package/lib/hooks.js

@@ -15,13 +15,8 @@ const HOME = os.homedir();
 // (on Windows, ~ expands to %USERPROFILE%)
 const SETTINGS_PATH = path.join(HOME, '.claude', 'settings.json');
 
-// Log file for debugging hook execution
-const LOG_PATH = path.join(HOME, '.claude', 'depester.log');
-const MAX_LOG_ENTRIES = 50;
-
 // Use --all to patch all installations (CLI + VS Code binary + webview)
-// Use --log to write results to ~/.claude/depester.log for debugging
-const HOOK_COMMAND = 'npx claude-depester --all --silent --log';
+const HOOK_COMMAND = 'npx claude-depester --all --silent';
 
 /**
  * Read Claude Code settings
@@ -184,146 +179,11 @@ function getHookStatus() {
   };
 }
 
-/**
- * Search Claude debug logs for hook-related entries
- * @param {number} maxFiles - Maximum number of log files to search (default 5)
- * @returns {Array<{file: string, timestamp: string, entries: Array<{time: string, message: string}>}>}
- */
-function searchHookLogs(maxFiles = 5) {
-  const debugDir = path.join(HOME, '.claude', 'debug');
-  const results = [];
-  
-  try {
-    if (!fs.existsSync(debugDir)) {
-      return results;
-    }
-    
-    // Get log files sorted by modification time (newest first)
-    const files = fs.readdirSync(debugDir)
-      .filter(f => f.endsWith('.txt') && f !== 'latest')
-      .map(f => ({
-        name: f,
-        path: path.join(debugDir, f),
-        mtime: fs.statSync(path.join(debugDir, f)).mtime
-      }))
-      .sort((a, b) => b.mtime - a.mtime)
-      .slice(0, maxFiles);
-    
-    for (const file of files) {
-      const content = fs.readFileSync(file.path, 'utf-8');
-      const lines = content.split('\n');
-      const hookEntries = [];
-      
-      for (const line of lines) {
-        // Look for SessionStart hook entries only (not repo URLs containing "depester")
-        if (line.includes('SessionStart') || 
-            line.includes('Hook output')) {
-          // Parse timestamp from log line: 2026-01-18T09:07:34.119Z [DEBUG] ...
-          const match = line.match(/^(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z)\s+\[.*?\]\s+(.*)$/);
-          if (match) {
-            hookEntries.push({
-              time: match[1],
-              message: match[2]
-            });
-          }
-        }
-      }
-      
-      if (hookEntries.length > 0) {
-        results.push({
-          file: file.name,
-          timestamp: file.mtime.toISOString(),
-          entries: hookEntries
-        });
-      }
-    }
-  } catch (e) {
-    // Ignore errors reading logs
-  }
-  
-  return results;
-}
-
-/**
- * Append entry to depester log file, keeping only last MAX_LOG_ENTRIES
- * @param {string} message - Log message
- * @param {object} data - Additional data to log
- */
-function appendLog(message, data = null) {
-  try {
-    const timestamp = new Date().toISOString();
-    const entry = {
-      timestamp,
-      message,
-      ...(data && { data })
-    };
-    
-    // Read existing entries
-    let entries = [];
-    if (fs.existsSync(LOG_PATH)) {
-      const content = fs.readFileSync(LOG_PATH, 'utf-8');
-      const lines = content.trim().split('\n').filter(l => l);
-      entries = lines.map(line => {
-        try {
-          return JSON.parse(line);
-        } catch {
-          return null;
-        }
-      }).filter(e => e !== null);
-    }
-    
-    // Add new entry
-    entries.push(entry);
-    
-    // Keep only last MAX_LOG_ENTRIES
-    if (entries.length > MAX_LOG_ENTRIES) {
-      entries = entries.slice(-MAX_LOG_ENTRIES);
-    }
-    
-    // Write back
-    const dir = path.dirname(LOG_PATH);
-    if (!fs.existsSync(dir)) {
-      fs.mkdirSync(dir, { recursive: true });
-    }
-    fs.writeFileSync(LOG_PATH, entries.map(e => JSON.stringify(e)).join('\n') + '\n', 'utf-8');
-    
-  } catch (e) {
-    // Silently ignore logging errors
-  }
-}
-
-/**
- * Read depester log entries
- * @returns {Array<{timestamp: string, message: string, data?: object}>}
- */
-function readLog() {
-  try {
-    if (!fs.existsSync(LOG_PATH)) {
-      return [];
-    }
-    const content = fs.readFileSync(LOG_PATH, 'utf-8');
-    const lines = content.trim().split('\n').filter(l => l);
-    return lines.map(line => {
-      try {
-        return JSON.parse(line);
-      } catch {
-        return null;
-      }
-    }).filter(e => e !== null);
-  } catch (e) {
-    return [];
-  }
-}
-
 module.exports = {
   installHook,
   removeHook,
   isHookInstalled,
   getHookStatus,
-  searchHookLogs,
-  appendLog,
-  readLog,
   SETTINGS_PATH,
-  HOOK_COMMAND,
-  LOG_PATH
+  HOOK_COMMAND
 };