claude-depester 1.0.0 → 1.2.0

package/README.md

@@ -7,7 +7,7 @@ Remove silly thinking words from Claude Code.
 
 Instead of seeing "Flibbertigibbeting", "Discombobulating", "Clauding", etc., you'll see a clean "Thinking".
 
-> **Last updated:** 2026-01-11 | **Tested with:** Claude Code 2.1.4
+> **Last updated:** 2026-01-11 | **Tested with:** Claude Code 2.1.4, 2.1.5
 
 ![Thinking... instead of silly words](img/screenshot1.png)
 
@@ -43,16 +43,20 @@ That's it! Restart Claude Code for changes to take effect.
 ## Features
 
 - Works with native binaries (Bun-compiled) and npm installations
+- **Patches VS Code/VSCodium extension webview** (the UI that shows spinner text)
 - Auto-detects your Claude Code installation
 - Creates backup before patching (can restore anytime)
 - Optional SessionStart hook for auto-patching after updates
 - Content-based detection survives version updates
+- Cross-platform: Linux, macOS, Windows (WSL/Git Bash)
 
 ## Commands
 
 | Command | Description |
 |---------|-------------|
 | `npx claude-depester` | Patch Claude Code |
+| `npx claude-depester --all` | Patch ALL installations (CLI + VS Code) |
+| `npx claude-depester --list` | List all found installations |
 | `npx claude-depester --dry-run` | Preview changes (no modifications) |
 | `npx claude-depester --check` | Check patch status |
 | `npx claude-depester --restore` | Restore original from backup |
@@ -64,14 +68,36 @@ That's it! Restart Claude Code for changes to take effect.
 
 ## Supported Installation Methods
 
+### Linux
 | Method | Path | Status |
 |--------|------|--------|
-| Native binary | `~/.local/bin/claude` -> `~/.local/share/claude/versions/X.Y.Z` | Fully supported |
+| Native binary | `~/.local/share/claude/versions/X.Y.Z` | Fully supported |
+| VS Code extension | `~/.vscode/extensions/anthropic.claude-code-*/` | Fully supported |
+| VS Code webview | `~/.vscode/extensions/.../webview/index.js` | Fully supported |
+| VSCodium extension | `~/.vscode-oss/extensions/anthropic.claude-code-*/` | Fully supported |
 | Local npm | `~/.claude/local/node_modules/@anthropic-ai/claude-code/` | Fully supported |
 | Global npm | `npm root -g`/@anthropic-ai/claude-code/ | Fully supported |
-| Homebrew | `/opt/homebrew/Caskroom/claude-code/` | Fully supported |
 
-The tool auto-detects your installation.
+### macOS
+| Method | Path | Status |
+|--------|------|--------|
+| Native binary | `~/.local/share/claude/versions/X.Y.Z` | Fully supported |
+| Native binary | `~/Library/Application Support/Claude/versions/X.Y.Z` | Fully supported |
+| VS Code extension | `~/.vscode/extensions/anthropic.claude-code-*/` | Fully supported |
+| VS Code webview | `~/.vscode/extensions/.../webview/index.js` | Fully supported |
+| Homebrew | `/opt/homebrew/lib/node_modules/@anthropic-ai/claude-code/` | Fully supported |
+
+### Windows (WSL/Git Bash)
+| Method | Path | Status |
+|--------|------|--------|
+| Native binary | `%USERPROFILE%\.local\bin\claude.exe` | Fully supported |
+| Native binary | `%LOCALAPPDATA%\Claude\versions\X.Y.Z` | Fully supported |
+| VS Code extension | `%USERPROFILE%\.vscode\extensions\anthropic.claude-code-*\` | Fully supported |
+| VS Code webview | `...\extensions\...\webview\index.js` | Fully supported |
+
+The tool auto-detects your installation. Use `--list` to see all found installations, and `--all` to patch them all at once.
+
+> **Important for VS Code users:** The extension has TWO places with spinner words - the native binary AND the webview. Use `--all` to patch both!
 
 ## After Claude Code Updates
 
@@ -112,11 +138,40 @@ Every time Claude Code starts, it checks and re-applies the patch if needed.
 
 ## Troubleshooting
 
+### Still seeing silly words after patching?
+
+**You must fully restart Claude Code / VS Code / VSCodium** after patching. The patch modifies the binary on disk, but running processes still use the old code in memory.
+
+For VS Code / VSCodium:
+1. Close the editor completely (check it's not running in background)
+2. Kill any remaining processes: `pkill -f codium` or `pkill -f "Code"`
+3. Reopen the editor
+
+To verify processes are stopped:
+```bash
+ps aux | grep -E "(vscode|codium|claude)" | grep -v grep
+```
+
 ### "Could not find Claude Code installation"
 
 Make sure Claude Code is installed:
 - Check with `claude --version`
 - Run with `--verbose` to see searched paths
+- Use `--list` to see all detected installations
+
+### VS Code extension still showing silly words
+
+The VS Code extension has **TWO separate components** with spinner words:
+1. **Native binary** (`resources/native-binary/claude`) - the backend
+2. **Webview** (`webview/index.js`) - the frontend UI that renders the spinner
+
+You must patch BOTH for the fix to work. Use:
+```bash
+npx claude-depester --list    # Should show both binary AND webview
+npx claude-depester --all     # Patch ALL components
+```
+
+Then **fully restart VS Code** (not just reload window).
 
 ### Patch not working after update
 
@@ -128,8 +183,8 @@ If the patch fails:
 ### Want to undo everything
 
 ```bash
-npx claude-depester --restore      # Restore original file
-npx claude-depester --remove-hook  # Remove auto-patch hook
+npx claude-depester --restore --all  # Restore all installations
+npx claude-depester --remove-hook    # Remove auto-patch hook
 ```
 
 ## Technical Details
@@ -154,6 +209,19 @@ npx claude-depester --remove-hook  # Remove auto-patch hook
 - Node.js >= 18.0.0
 - Claude Code installed
 
+## Platform Support
+
+| Platform | Binary Patching | Webview Patching | Status |
+|----------|-----------------|------------------|--------|
+| Linux x64 | ELF | Yes | Tested |
+| Linux ARM64 | ELF | Yes | Should work |
+| macOS Intel | MachO | Yes | Should work |
+| macOS Apple Silicon | MachO | Yes | Should work |
+| Windows x64 | PE | Yes | Should work |
+| Windows ARM64 | PE | Yes | Should work |
+
+The tool uses [node-lief](https://www.npmjs.com/package/node-lief) which has prebuilt binaries for all these platforms.
+
 ## Contributing
 
 If Claude Code updates and the patch stops working:

package/bin/claude-depester

@@ -5,7 +5,7 @@
  * Remove silly thinking words from Claude Code
  */
 
-const { findCliJs, getSearchedPaths } = require('../lib/detector');
+const { findCliJs, findAllClaudeCode, getSearchedPaths } = require('../lib/detector');
 const { patch, checkStatus, restoreBackup } = require('../lib/patcher');
 const { installHook, removeHook, getHookStatus } = require('../lib/hooks');
 
@@ -23,7 +23,9 @@ const flags = {
   removeHook: args.includes('--remove-hook'),
   hookStatus: args.includes('--hook-status'),
   silent: args.includes('--silent') || args.includes('-s'),
-  verbose: args.includes('--verbose')
+  verbose: args.includes('--verbose'),
+  all: args.includes('--all') || args.includes('-a'),
+  list: args.includes('--list') || args.includes('-l')
 };
 
 function log(...msg) {
@@ -48,6 +50,8 @@ USAGE:
 
 OPTIONS:
   (no options)      Patch Claude Code now
+  -a, --all         Patch ALL installations (CLI + VS Code extensions)
+  -l, --list        List all found installations
   -c, --check       Check if Claude Code is patched
   -r, --restore     Restore original file from backup
   -n, --dry-run     Preview changes without applying
@@ -62,7 +66,9 @@ OPTIONS:
   -h, --help        Show this help
 
 EXAMPLES:
-  npx claude-depester                 # Patch now
+  npx claude-depester                 # Patch first found installation
+  npx claude-depester --all           # Patch ALL installations
+  npx claude-depester --list          # List all installations
   npx claude-depester --check         # Check status
   npx claude-depester --install-hook  # Auto-patch after updates
   npx claude-depester --restore       # Undo patch
@@ -116,7 +122,86 @@ async function main() {
     process.exit(result.success ? 0 : 1);
   }
   
-  // Find Claude Code installation
+  // Handle --list
+  if (flags.list) {
+    const installations = findAllClaudeCode();
+    if (installations.length === 0) {
+      error('No Claude Code installations found.');
+      if (flags.verbose) {
+        showSearchedPaths();
+      }
+      process.exit(1);
+    }
+    
+    log(`Found ${installations.length} installation(s):\n`);
+    for (const inst of installations) {
+      const status = checkStatus(inst.path, { type: inst.type });
+      const statusStr = status.patched ? '[PATCHED]' : '[NOT PATCHED]';
+      const typeStr = inst.type === 'webview' ? ' (webview)' : inst.type === 'binary' ? ' (binary)' : '';
+      log(`${statusStr} ${inst.method}${typeStr}`);
+      log(`  ${inst.path}\n`);
+    }
+    process.exit(0);
+  }
+  
+  // Handle --all (patch all installations)
+  if (flags.all) {
+    const installations = findAllClaudeCode();
+    if (installations.length === 0) {
+      error('No Claude Code installations found.');
+      if (flags.verbose) {
+        showSearchedPaths();
+      }
+      process.exit(1);
+    }
+    
+    log(`Found ${installations.length} installation(s):\n`);
+    
+    let successCount = 0;
+    let skipCount = 0;
+    let failCount = 0;
+    
+    for (const inst of installations) {
+      log(`${inst.method}:`);
+      log(`  ${inst.path}`);
+      
+      if (flags.restore) {
+        const success = restoreBackup(inst.path);
+        if (success) {
+          log('  -> Restored from backup\n');
+          successCount++;
+        } else {
+          log('  -> No backup found\n');
+          skipCount++;
+        }
+      } else {
+        const result = patch(inst.path, { dryRun: flags.dryRun, type: inst.type });
+        if (result.success) {
+          if (result.alreadyPatched) {
+            log('  -> Already patched\n');
+            skipCount++;
+          } else if (result.dryRun) {
+            log('  -> Would patch\n');
+            successCount++;
+          } else {
+            log('  -> Patched!\n');
+            successCount++;
+          }
+        } else {
+          log(`  -> Failed: ${result.message}\n`);
+          failCount++;
+        }
+      }
+    }
+    
+    log(`Done: ${successCount} patched, ${skipCount} skipped, ${failCount} failed`);
+    if (!flags.dryRun && successCount > 0) {
+      log('Restart Claude Code for changes to take effect.');
+    }
+    process.exit(failCount > 0 ? 1 : 0);
+  }
+  
+  // Find Claude Code installation (single)
   const cliInfo = findCliJs();
   
   if (!cliInfo) {
@@ -138,7 +223,7 @@ async function main() {
   
   // Handle check
   if (flags.check) {
-    const status = checkStatus(cliInfo.path);
+    const status = checkStatus(cliInfo.path, { type: cliInfo.type });
     
     if (status.error) {
       error(`Error: ${status.error}`);
@@ -180,7 +265,7 @@ async function main() {
   }
   
   // Default action: patch
-  const result = patch(cliInfo.path, { dryRun: flags.dryRun });
+  const result = patch(cliInfo.path, { dryRun: flags.dryRun, type: cliInfo.type });
   
   if (result.success) {
     if (result.alreadyPatched) {

package/lib/detector.js

@@ -15,10 +15,13 @@ const HOME = os.homedir();
  */
 function getPotentialPaths() {
   const paths = [];
+  const isWindows = process.platform === 'win32';
+  const isMac = process.platform === 'darwin';
   
   // Priority 1: Native binary (recommended installation method)
-  // The binary is at ~/.local/bin/claude which symlinks to ~/.local/share/claude/versions/X.Y.Z
-  if (process.platform !== 'win32') {
+  // Linux/macOS: ~/.local/bin/claude symlinks to ~/.local/share/claude/versions/X.Y.Z
+  // Windows: %USERPROFILE%\.local\bin\claude.exe
+  if (!isWindows) {
     try {
       const claudePath = execSync('which claude', { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] }).trim();
       if (claudePath) {
@@ -33,30 +36,84 @@ function getPotentialPaths() {
     } catch (e) {
       // which failed or claude not found
     }
-  }
-  
-  // Also check versions directory directly
-  const versionsDir = path.join(HOME, '.local', 'share', 'claude', 'versions');
-  try {
-    if (fs.existsSync(versionsDir)) {
-      const versions = fs.readdirSync(versionsDir)
-        .filter(f => /^\d+\.\d+\.\d+$/.test(f))
-        .sort((a, b) => {
-          const [aMajor, aMinor, aPatch] = a.split('.').map(Number);
-          const [bMajor, bMinor, bPatch] = b.split('.').map(Number);
-          return bMajor - aMajor || bMinor - aMinor || bPatch - aPatch;
-        });
-      
-      if (versions.length > 0) {
+  } else {
+    // Windows: try where command
+    try {
+      const claudePath = execSync('where claude', { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] }).trim().split('\n')[0];
+      if (claudePath) {
         paths.push({
-          method: 'native binary (~/.local/share/claude/versions)',
-          path: path.join(versionsDir, versions[0]),
+          method: 'native binary (where claude)',
+          path: claudePath,
           type: 'binary'
         });
       }
+    } catch (e) {
+      // where failed or claude not found
     }
-  } catch (e) {
-    // Failed to read versions dir
+  }
+  
+  // Check versions directory directly
+  // Linux: ~/.local/share/claude/versions/X.Y.Z
+  // macOS: ~/Library/Application Support/Claude/versions/X.Y.Z (also ~/.local/share/claude)
+  // Windows: %LOCALAPPDATA%\Claude\versions\X.Y.Z
+  const versionsDirs = [];
+  
+  if (isWindows) {
+    const localAppData = process.env.LOCALAPPDATA || path.join(HOME, 'AppData', 'Local');
+    versionsDirs.push(path.join(localAppData, 'Claude', 'versions'));
+    versionsDirs.push(path.join(HOME, '.local', 'share', 'claude', 'versions'));
+  } else if (isMac) {
+    versionsDirs.push(path.join(HOME, 'Library', 'Application Support', 'Claude', 'versions'));
+    versionsDirs.push(path.join(HOME, '.local', 'share', 'claude', 'versions'));
+  } else {
+    versionsDirs.push(path.join(HOME, '.local', 'share', 'claude', 'versions'));
+  }
+  
+  for (const versionsDir of versionsDirs) {
+    try {
+      if (fs.existsSync(versionsDir)) {
+        const versions = fs.readdirSync(versionsDir)
+          .filter(f => /^\d+\.\d+\.\d+$/.test(f))
+          .sort((a, b) => {
+            const [aMajor, aMinor, aPatch] = a.split('.').map(Number);
+            const [bMajor, bMinor, bPatch] = b.split('.').map(Number);
+            return bMajor - aMajor || bMinor - aMinor || bPatch - aPatch;
+          });
+        
+        for (const version of versions) {
+          const binaryName = isWindows ? 'claude.exe' : 'claude';
+          const binaryPath = path.join(versionsDir, version, binaryName);
+          // Also check if version folder itself is the binary (some installations)
+          const versionPath = path.join(versionsDir, version);
+          
+          if (fs.existsSync(binaryPath)) {
+            paths.push({
+              method: `native binary (${versionsDir})`,
+              path: binaryPath,
+              type: 'binary'
+            });
+          } else if (fs.existsSync(versionPath) && fs.statSync(versionPath).isFile()) {
+            paths.push({
+              method: `native binary (${versionsDir})`,
+              path: versionPath,
+              type: 'binary'
+            });
+          }
+        }
+      }
+    } catch (e) {
+      // Failed to read versions dir
+    }
+  }
+  
+  // Windows: also check .local\bin directly
+  if (isWindows) {
+    const winBinaryPath = path.join(HOME, '.local', 'bin', 'claude.exe');
+    paths.push({
+      method: 'native binary (Windows .local\\bin)',
+      path: winBinaryPath,
+      type: 'binary'
+    });
   }
   
   // Priority 2: Local npm installations
@@ -85,7 +142,68 @@ function getPotentialPaths() {
     // npm not available or failed
   }
   
-  // Priority 4: Derive from process.execPath
+  // Priority 4: VS Code / VSCodium extensions
+  // Linux: ~/.vscode/extensions, ~/.vscode-oss/extensions
+  // macOS: ~/.vscode/extensions, ~/Library/Application Support/Code/User/extensions (rare)
+  // Windows: %USERPROFILE%\.vscode\extensions, %APPDATA%\Code\User\extensions
+  const vscodeExtDirs = [
+    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
+  ];
+  
+  // Add Windows-specific paths
+  if (isWindows) {
+    const appData = process.env.APPDATA || path.join(HOME, 'AppData', 'Roaming');
+    vscodeExtDirs.push(path.join(appData, 'Code', 'User', 'extensions'));
+    vscodeExtDirs.push(path.join(appData, 'Code - Insiders', 'User', 'extensions'));
+    vscodeExtDirs.push(path.join(appData, 'VSCodium', 'User', 'extensions'));
+  }
+  
+  // Add macOS-specific paths  
+  if (isMac) {
+    vscodeExtDirs.push(path.join(HOME, 'Library', 'Application Support', 'Code', 'User', 'extensions'));
+    vscodeExtDirs.push(path.join(HOME, 'Library', 'Application Support', 'Code - Insiders', 'User', 'extensions'));
+    vscodeExtDirs.push(path.join(HOME, 'Library', 'Application Support', 'VSCodium', 'User', 'extensions'));
+  }
+  
+  for (const extDir of vscodeExtDirs) {
+    try {
+      if (fs.existsSync(extDir)) {
+        const extensions = fs.readdirSync(extDir)
+          .filter(f => f.startsWith('anthropic.claude-code-'))
+          .sort()
+          .reverse(); // Latest version first
+        
+        for (const ext of extensions) {
+          // Native binary in extension
+          const binaryName = isWindows ? 'claude.exe' : 'claude';
+          const binaryPath = path.join(extDir, ext, 'resources', 'native-binary', binaryName);
+          if (fs.existsSync(binaryPath)) {
+            paths.push({
+              method: `VS Code extension binary (${ext})`,
+              path: binaryPath,
+              type: 'binary'
+            });
+          }
+          
+          // Webview frontend JS - has separate copy of spinner words
+          const webviewPath = path.join(extDir, ext, 'webview', 'index.js');
+          if (fs.existsSync(webviewPath)) {
+            paths.push({
+              method: `VS Code extension webview (${ext})`,
+              path: webviewPath,
+              type: 'webview'
+            });
+          }
+        }
+      }
+    } catch (e) {
+      // Failed to read extensions dir
+    }
+  }
+  
+  // Priority 5: Derive from process.execPath
   try {
     const nodeDir = path.dirname(process.execPath);
     paths.push({
@@ -97,7 +215,7 @@ function getPotentialPaths() {
     // Failed to derive
   }
   
-  // Priority 5: Common homebrew locations (macOS)
+  // Priority 6: Common homebrew locations (macOS)
   if (process.platform === 'darwin') {
     paths.push({
       method: 'homebrew (arm64)',
@@ -115,14 +233,19 @@ function getPotentialPaths() {
 }
 
 /**
- * Check if a file contains the silly words (works for both JS and binary)
+ * Check if a file contains the silly words OR has been patched (works for both JS and binary)
  */
-function containsSillyWords(filePath) {
+function containsSillyWordsOrPatched(filePath) {
   try {
     // Read as buffer to handle both text and binary
     const content = fs.readFileSync(filePath);
     const contentStr = content.toString('utf-8');
     
+    // Check if already patched (replacement pattern)
+    if (/=\["Thinking"\]/.test(contentStr)) {
+      return true;
+    }
+    
     // Check for marker words
     const markers = ['Flibbertigibbeting', 'Discombobulating', 'Clauding'];
     let found = 0;
@@ -137,9 +260,14 @@ function containsSillyWords(filePath) {
   }
 }
 
+// Legacy alias
+function containsSillyWords(filePath) {
+  return containsSillyWordsOrPatched(filePath);
+}
+
 /**
  * Find Claude Code installation (cli.js or native binary)
- * @returns {{ path: string, method: string, type: 'js' | 'binary' } | null}
+ * @returns {{ path: string, method: string, type: 'js' | 'binary' | 'webview' } | null}
  */
 function findClaudeCode() {
   const potentialPaths = getPotentialPaths();
@@ -170,6 +298,35 @@ function findCliJs() {
   return null;
 }
 
+/**
+ * Find ALL Claude Code installations (CLI + VS Code extensions + webviews)
+ * @returns {Array<{ path: string, method: string, type: 'js' | 'binary' | 'webview' }>}
+ */
+function findAllClaudeCode() {
+  const potentialPaths = getPotentialPaths();
+  const found = [];
+  const seenPaths = new Set();
+  
+  for (const { method, path: codePath, type } of potentialPaths) {
+    try {
+      const resolvedPath = path.resolve(codePath);
+      if (seenPaths.has(resolvedPath)) continue;
+      
+      if (fs.existsSync(resolvedPath)) {
+        const stats = fs.statSync(resolvedPath);
+        if (stats.isFile() && containsSillyWords(resolvedPath)) {
+          found.push({ path: resolvedPath, method, type });
+          seenPaths.add(resolvedPath);
+        }
+      }
+    } catch (e) {
+      // File doesn't exist or can't be read
+    }
+  }
+  
+  return found;
+}
+
 /**
  * Get all searched paths for error reporting
  */
@@ -180,5 +337,6 @@ function getSearchedPaths() {
 module.exports = {
   findClaudeCode,
   findCliJs,
+  findAllClaudeCode,
   getSearchedPaths
 };

package/lib/patcher.js

@@ -52,29 +52,40 @@ function isPatched(content) {
 /**
  * Find and replace the silly words array in JavaScript content
  * @param {Buffer} jsContent - JavaScript content as buffer
+ * @param {object} options - Options
+ * @param {boolean} options.isWebview - Whether this is a webview file (uses different var names)
  * @returns {{ patched: Buffer, count: number } | null}
  */
-function patchJsContent(jsContent) {
+function patchJsContent(jsContent, options = {}) {
   let str = jsContent.toString('utf-8');
   
-  // Pattern to match the array assignment: varName=["Accomplishing",...,"Zigzagging"]
+  // Pattern to match the array assignment: varName=["Accomplishing",...,"LastWord"]
+  // Different versions may end with different words:
+  // - CLI binary: ends with "Zigzagging"
+  // - Webview: ends with "Wrangling"
   // We need to find arrays that contain our marker words
-  const arrayPattern = /([a-zA-Z_$][a-zA-Z0-9_$]*)=\["Accomplishing"[^\]]*"Zigzagging"\]/g;
+  // Note: Webview uses longer var names like "Tte", binaries use shorter like "ouI"
+  const arrayPatterns = [
+    /([a-zA-Z_$][a-zA-Z0-9_$]*)=\["Accomplishing"[^\]]*"Zigzagging"\]/g,  // CLI binary
+    /([a-zA-Z_$][a-zA-Z0-9_$]*)=\["Accomplishing"[^\]]*"Wrangling"\]/g,   // Webview
+  ];
   
   let count = 0;
-  str = str.replace(arrayPattern, (match, varName) => {
-    // Verify it contains marker words
-    let markerCount = 0;
-    for (const marker of MARKER_WORDS) {
-      if (match.includes(`"${marker}"`)) markerCount++;
-    }
-    
-    if (markerCount >= 3) {
-      count++;
-      return `${varName}=["${REPLACEMENT_WORD}"]`;
-    }
-    return match;
-  });
+  for (const arrayPattern of arrayPatterns) {
+    str = str.replace(arrayPattern, (match, varName) => {
+      // Verify it contains marker words
+      let markerCount = 0;
+      for (const marker of MARKER_WORDS) {
+        if (match.includes(`"${marker}"`)) markerCount++;
+      }
+      
+      if (markerCount >= 3) {
+        count++;
+        return `${varName}=["${REPLACEMENT_WORD}"]`;
+      }
+      return match;
+    });
+  }
   
   if (count === 0) return null;
   
@@ -161,13 +172,17 @@ function isNativeBinary(filePath) {
  * Main patch function
  * @param {string} filePath - Path to cli.js or binary
  * @param {object} options - Options
+ * @param {boolean} options.dryRun - Don't actually patch
+ * @param {string} options.type - Override type detection: 'binary', 'js', 'webview'
  * @returns {{ success: boolean, message: string, alreadyPatched?: boolean }}
  */
 function patch(filePath, options = {}) {
-  const { dryRun = false } = options;
+  const { dryRun = false, type } = options;
   
   try {
-    const isBinary = isNativeBinary(filePath);
+    // Use provided type or detect
+    const isBinary = type === 'binary' || (type !== 'js' && type !== 'webview' && isNativeBinary(filePath));
+    const isWebview = type === 'webview';
     
     if (isBinary) {
       // Native binary - extract JS, patch, repack
@@ -227,8 +242,9 @@ function patch(filePath, options = {}) {
       };
       
     } else {
-      // Plain JS file (npm installation)
+      // Plain JS file (npm installation) or webview file
       const content = fs.readFileSync(filePath);
+      const fileType = isWebview ? 'webview' : 'JavaScript';
       
       if (isPatched(content)) {
         return {
@@ -241,22 +257,22 @@ function patch(filePath, options = {}) {
       if (!hasSillyWords(content)) {
         return {
           success: false,
-          message: 'Could not find silly words array. Claude Code version may not be supported.'
+          message: `Could not find silly words array in ${fileType}. Claude Code version may not be supported.`
         };
       }
       
-      const result = patchJsContent(content);
+      const result = patchJsContent(content, { isWebview });
       if (!result) {
         return {
           success: false,
-          message: 'Could not locate words array pattern'
+          message: `Could not locate words array pattern in ${fileType}`
         };
       }
       
       if (dryRun) {
         return {
           success: true,
-          message: `Dry run - would patch ${result.count} occurrence(s) of silly words array`,
+          message: `Dry run - would patch ${result.count} occurrence(s) of silly words array in ${fileType}`,
           dryRun: true
         };
       }
@@ -269,7 +285,7 @@ function patch(filePath, options = {}) {
       
       return {
         success: true,
-        message: `Patched ${result.count} occurrence(s) successfully. Backup at: ${backupPath}`,
+        message: `Patched ${result.count} occurrence(s) in ${fileType} successfully. Backup at: ${backupPath}`,
         backupPath
       };
     }
@@ -285,11 +301,15 @@ function patch(filePath, options = {}) {
 /**
  * Check patch status
  * @param {string} filePath - Path to cli.js or binary
- * @returns {{ patched: boolean, hasSillyWords: boolean, hasBackup: boolean, isBinary: boolean }}
+ * @param {object} options - Options
+ * @param {string} options.type - Override type detection: 'binary', 'js', 'webview'
+ * @returns {{ patched: boolean, hasSillyWords: boolean, hasBackup: boolean, isBinary: boolean, isWebview: boolean }}
  */
-function checkStatus(filePath) {
+function checkStatus(filePath, options = {}) {
   try {
-    const isBinary = isNativeBinary(filePath);
+    const { type } = options;
+    const isBinary = type === 'binary' || (type !== 'js' && type !== 'webview' && isNativeBinary(filePath));
+    const isWebview = type === 'webview';
     
     let content;
     if (isBinary) {
@@ -300,6 +320,7 @@ function checkStatus(filePath) {
           hasSillyWords: false,
           hasBackup: hasBackup(filePath),
           isBinary: true,
+          isWebview: false,
           error: 'Could not extract JavaScript from binary'
         };
       }
@@ -311,7 +332,8 @@ function checkStatus(filePath) {
       patched: isPatched(content),
       hasSillyWords: hasSillyWords(content),
       hasBackup: hasBackup(filePath),
-      isBinary
+      isBinary,
+      isWebview
     };
   } catch (err) {
     return {
@@ -319,6 +341,7 @@ function checkStatus(filePath) {
       hasSillyWords: false,
       hasBackup: false,
       isBinary: false,
+      isWebview: false,
       error: err.message
     };
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-depester",
-  "version": "1.0.0",
+  "version": "1.2.0",
   "description": "Remove silly thinking words from Claude Code. Auto-patches and survives updates via SessionStart hook.",
   "main": "lib/patcher.js",
   "bin": {