@plexor-dev/claude-code-plugin 0.1.0-beta.31 → 0.1.0-beta.33

package/commands/plexor-uninstall.js

@@ -0,0 +1,293 @@
+#!/usr/bin/env node
+
+/**
+ * Plexor Uninstall Command
+ *
+ * Comprehensive cleanup before npm uninstall.
+ *
+ * CRITICAL: npm's preuninstall hook does NOT run for global package uninstalls.
+ * Users MUST run this command BEFORE running npm uninstall -g.
+ *
+ * This command:
+ * 1. Removes Plexor routing from ~/.claude/settings.json
+ * 2. Removes slash command .md files from ~/.claude/commands/
+ * 3. Removes plugin directory ~/.claude/plugins/plexor/
+ * 4. Optionally removes ~/.plexor/ config directory
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+// Get home directory, handling sudo case
+function getHomeDir() {
+  if (process.env.SUDO_USER) {
+    const platform = os.platform();
+    if (platform === 'darwin') {
+      return path.join('/Users', process.env.SUDO_USER);
+    } else if (platform === 'linux') {
+      return path.join('/home', process.env.SUDO_USER);
+    }
+  }
+  return process.env.HOME || process.env.USERPROFILE || os.homedir();
+}
+
+const HOME_DIR = getHomeDir();
+const CLAUDE_DIR = path.join(HOME_DIR, '.claude');
+const CLAUDE_COMMANDS_DIR = path.join(CLAUDE_DIR, 'commands');
+const CLAUDE_PLUGINS_DIR = path.join(CLAUDE_DIR, 'plugins', 'plexor');
+const PLEXOR_CONFIG_DIR = path.join(HOME_DIR, '.plexor');
+
+// All Plexor slash command files
+const PLEXOR_COMMANDS = [
+  'plexor-enabled.md',
+  'plexor-login.md',
+  'plexor-logout.md',
+  'plexor-setup.md',
+  'plexor-status.md',
+  'plexor-uninstall.md',
+  'plexor-mode.md',
+  'plexor-provider.md',
+  'plexor-settings.md',
+  'plexor-config.md'
+];
+
+/**
+ * Load settings manager if available
+ */
+function loadSettingsManager() {
+  // Try plugin dir first (installed location)
+  try {
+    const pluginLib = path.join(CLAUDE_PLUGINS_DIR, 'lib', 'settings-manager.js');
+    if (fs.existsSync(pluginLib)) {
+      const lib = require(pluginLib);
+      return lib.settingsManager;
+    }
+  } catch {
+    // Continue to fallback
+  }
+
+  // Try package lib (during npm lifecycle)
+  try {
+    const lib = require('../lib/settings-manager');
+    return lib.settingsManager;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Disable Plexor routing in Claude settings manually
+ * Fallback when settings-manager is not available
+ */
+function disableRoutingManually() {
+  const settingsPath = path.join(CLAUDE_DIR, 'settings.json');
+
+  try {
+    if (!fs.existsSync(settingsPath)) {
+      return { success: true, message: 'Settings file does not exist' };
+    }
+
+    const data = fs.readFileSync(settingsPath, 'utf8');
+    if (!data || data.trim() === '') {
+      return { success: true, message: 'Settings file is empty' };
+    }
+
+    const settings = JSON.parse(data);
+
+    if (!settings.env) {
+      return { success: true, message: 'No env block in settings' };
+    }
+
+    // Check if Plexor routing is active
+    const baseUrl = settings.env.ANTHROPIC_BASE_URL || '';
+    const isPlexorRouting = baseUrl.includes('plexor') || baseUrl.includes('staging.api');
+
+    if (!isPlexorRouting) {
+      return { success: true, message: 'Plexor routing not active' };
+    }
+
+    // Remove Plexor env vars
+    delete settings.env.ANTHROPIC_BASE_URL;
+    delete settings.env.ANTHROPIC_AUTH_TOKEN;
+
+    // Clean up empty env block
+    if (Object.keys(settings.env).length === 0) {
+      delete settings.env;
+    }
+
+    // Atomic write
+    const crypto = require('crypto');
+    const tempId = crypto.randomBytes(8).toString('hex');
+    const tempPath = path.join(CLAUDE_DIR, `.settings.${tempId}.tmp`);
+
+    fs.writeFileSync(tempPath, JSON.stringify(settings, null, 2), { mode: 0o600 });
+    fs.renameSync(tempPath, settingsPath);
+
+    return { success: true, message: 'Routing disabled' };
+  } catch (err) {
+    return { success: false, message: err.message };
+  }
+}
+
+/**
+ * Remove slash command files
+ */
+function removeSlashCommands() {
+  let removed = 0;
+  let restored = 0;
+
+  for (const cmd of PLEXOR_COMMANDS) {
+    const cmdPath = path.join(CLAUDE_COMMANDS_DIR, cmd);
+    const backupPath = cmdPath + '.backup';
+
+    try {
+      if (fs.existsSync(cmdPath)) {
+        fs.unlinkSync(cmdPath);
+        removed++;
+
+        // Restore backup if exists
+        if (fs.existsSync(backupPath)) {
+          fs.renameSync(backupPath, cmdPath);
+          restored++;
+        }
+      }
+    } catch {
+      // Continue with other files
+    }
+  }
+
+  return { removed, restored };
+}
+
+/**
+ * Remove plugin directory
+ */
+function removePluginDirectory() {
+  try {
+    if (fs.existsSync(CLAUDE_PLUGINS_DIR)) {
+      fs.rmSync(CLAUDE_PLUGINS_DIR, { recursive: true, force: true });
+      return true;
+    }
+  } catch {
+    return false;
+  }
+  return false;
+}
+
+/**
+ * Remove config directory
+ */
+function removeConfigDirectory() {
+  try {
+    if (fs.existsSync(PLEXOR_CONFIG_DIR)) {
+      fs.rmSync(PLEXOR_CONFIG_DIR, { recursive: true, force: true });
+      return true;
+    }
+  } catch {
+    return false;
+  }
+  return false;
+}
+
+function main() {
+  const args = process.argv.slice(2);
+
+  // Handle help flag
+  if (args.includes('--help') || args.includes('-h')) {
+    console.log('');
+    console.log('  Usage: plexor-uninstall [options]');
+    console.log('');
+    console.log('  Cleans up Plexor integration before npm uninstall.');
+    console.log('');
+    console.log('  Options:');
+    console.log('    --remove-config, -c  Also remove ~/.plexor/ config directory');
+    console.log('    --quiet, -q          Suppress output messages');
+    console.log('    --help, -h           Show this help message');
+    console.log('');
+    console.log('  After running this command:');
+    console.log('    npm uninstall -g @plexor-dev/claude-code-plugin');
+    console.log('');
+    process.exit(0);
+  }
+
+  const removeConfig = args.includes('--remove-config') || args.includes('-c');
+  const quiet = args.includes('--quiet') || args.includes('-q');
+
+  if (!quiet) {
+    console.log('');
+    console.log('  Plexor Uninstall - Cleaning up...');
+    console.log('');
+  }
+
+  // 1. Remove routing from ~/.claude/settings.json
+  let routingResult;
+  const settingsManager = loadSettingsManager();
+
+  if (settingsManager) {
+    try {
+      const success = settingsManager.disablePlexorRouting();
+      routingResult = { success, message: success ? 'Routing disabled via manager' : 'Already clean' };
+    } catch (err) {
+      routingResult = disableRoutingManually();
+    }
+  } else {
+    routingResult = disableRoutingManually();
+  }
+
+  if (!quiet) {
+    console.log(routingResult.success
+      ? '  ✓ Removed Plexor routing from Claude settings'
+      : `  ✗ Failed to remove routing: ${routingResult.message}`);
+  }
+
+  // 2. Remove slash command .md files
+  const cmdResult = removeSlashCommands();
+  if (!quiet) {
+    console.log(`  ✓ Removed ${cmdResult.removed} slash command files`);
+    if (cmdResult.restored > 0) {
+      console.log(`  ✓ Restored ${cmdResult.restored} backed-up files`);
+    }
+  }
+
+  // 3. Remove plugin directory
+  const pluginRemoved = removePluginDirectory();
+  if (!quiet) {
+    console.log(pluginRemoved
+      ? '  ✓ Removed plugin directory'
+      : '  ○ Plugin directory not found (already clean)');
+  }
+
+  // 4. Optionally remove config directory
+  if (removeConfig) {
+    const configRemoved = removeConfigDirectory();
+    if (!quiet) {
+      console.log(configRemoved
+        ? '  ✓ Removed ~/.plexor config directory'
+        : '  ○ Config directory not found');
+    }
+  }
+
+  // Show next steps
+  if (!quiet) {
+    console.log('');
+    console.log('  ┌─────────────────────────────────────────────────────────────────┐');
+    console.log('  │  Cleanup complete! Now run:                                     │');
+    console.log('  │                                                                 │');
+    console.log('  │    npm uninstall -g @plexor-dev/claude-code-plugin              │');
+    console.log('  │                                                                 │');
+    console.log('  └─────────────────────────────────────────────────────────────────┘');
+    console.log('');
+    console.log('  Your Claude Code is ready to work normally again.');
+    console.log('');
+
+    if (!removeConfig) {
+      console.log('  Note: ~/.plexor/ config directory was preserved.');
+      console.log('  To also remove it: plexor-uninstall --remove-config');
+      console.log('  Or manually: rm -rf ~/.plexor');
+      console.log('');
+    }
+  }
+}
+
+main();

package/commands/plexor-uninstall.md

@@ -0,0 +1,12 @@
+---
+name: plexor-uninstall
+description: Clean up Plexor integration before uninstalling
+---
+
+**RULE: Execute the bash command below EXACTLY ONCE. After the Bash tool returns output, your ONLY action is to present that output to the user. DO NOT re-execute the command. DO NOT call any other tools.**
+
+**IMPORTANT**: Run this BEFORE `npm uninstall -g @plexor-dev/claude-code-plugin`. Pass `--remove-config` to also remove ~/.plexor/ config directory.
+
+```bash
+node ~/.claude/plugins/plexor/commands/plexor-uninstall.js $ARGUMENTS 2>&1 || plexor-uninstall $ARGUMENTS 2>&1
+```

package/hooks/intercept.js

@@ -106,9 +106,9 @@ try {
   const saveSession = (s) => {
     try {
       const dir = path.dirname(SESSION_PATH);
-      if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+      if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
       s.last_activity = Date.now();
-      fs.writeFileSync(SESSION_PATH, JSON.stringify(s, null, 2));
+      fs.writeFileSync(SESSION_PATH, JSON.stringify(s, null, 2), { mode: 0o600 });
     } catch {}
   };
 
@@ -179,6 +179,17 @@ async function main() {
     input = await readStdin();
     request = JSON.parse(input);
 
+    // Issue #2042: Check for slash commands FIRST, before ANY other processing
+    // Slash commands must pass through completely clean — no metadata injection
+    // Adding _plexor_client or _plexor to slash command requests adds context noise
+    // that causes the model to re-execute commands in a loop
+    // Note: session.recordPassthrough() intentionally omitted — slash commands are
+    // not API requests and should not pollute session analytics
+    if (isSlashCommand(request)) {
+      logger.debug('Slash command detected, clean passthrough (no metadata)');
+      return output(request);  // Completely clean — no metadata added
+    }
+
     // Phase 3 Hypervisor Mode Detection
     // When ANTHROPIC_BASE_URL points to Plexor, all intelligence is server-side
     // The plugin just passes through - server handles optimization, routing, quality
@@ -202,25 +213,6 @@ async function main() {
       });
     }
 
-    // CRITICAL: Check for slash commands FIRST (before agentic check)
-    // Slash commands like /plexor-status should pass through unchanged
-    // Must check before isAgenticRequest since all Claude Code requests have tools
-    if (isSlashCommand(request)) {
-      logger.debug('Slash command detected, passing through unchanged');
-      session.recordPassthrough();
-      return output({
-        ...request,
-        plexor_cwd: process.cwd(),
-        _plexor: {
-          request_id: generateRequestId('slash'),  // Issue #701: Add request_id for tracking
-          source: 'passthrough_slash_command',
-          reason: 'slash_command_detected',
-          cwd: process.cwd(),
-          latency_ms: Date.now() - startTime
-        }
-      });
-    }
-
     // CRITICAL: Skip optimization for CLI commands requiring tool execution
     // Azure CLI, AWS CLI, kubectl, etc. need tools to be preserved
     if (requiresToolExecution(request)) {
@@ -578,12 +570,16 @@ function isSlashCommand(request) {
   }
 
   // Check for system messages with skill instructions
+  // Issue #2042: Updated to match new RULE-based .md format (old H1 headers removed)
   for (const msg of messages) {
     if (msg.role === 'system') {
       const content = typeof msg.content === 'string' ? msg.content : '';
       if (/# Plexor (?:Status|Login|Logout|Mode|Provider|Enabled|Settings)/i.test(content)) {
         return true;
       }
+      if (/plexor\/commands\/plexor-/i.test(content)) {
+        return true;
+      }
     }
   }
 

package/hooks/track-response.js

@@ -85,10 +85,10 @@ try {
     save(session) {
       try {
         if (!fs.existsSync(PLEXOR_DIR)) {
-          fs.mkdirSync(PLEXOR_DIR, { recursive: true });
+          fs.mkdirSync(PLEXOR_DIR, { recursive: true, mode: 0o700 });
         }
         session.last_activity = Date.now();
-        fs.writeFileSync(this.sessionPath, JSON.stringify(session, null, 2));
+        fs.writeFileSync(this.sessionPath, JSON.stringify(session, null, 2), { mode: 0o600 });
       } catch {}
     }
 

package/lib/config.js

@@ -56,7 +56,7 @@ class ConfigManager {
         }
       };
 
-      fs.writeFileSync(this.configPath, JSON.stringify(updated, null, 2));
+      fs.writeFileSync(this.configPath, JSON.stringify(updated, null, 2), { mode: 0o600 });
       return true;
     } catch {
       return false;

package/lib/constants.js

@@ -4,7 +4,23 @@
 
 const path = require('path');
 
-const PLEXOR_DIR = path.join(process.env.HOME || process.env.USERPROFILE || '', '.plexor');
+/**
+ * Get the user's home directory with proper validation
+ * @returns {string} Home directory path
+ * @throws {Error} If HOME is not set or empty
+ */
+function getHomeDir() {
+  const home = process.env.HOME || process.env.USERPROFILE;
+  if (!home || home.trim() === '') {
+    console.error('Error: HOME environment variable is not set.');
+    console.error('       Please set HOME to your user directory before running Plexor commands.');
+    process.exit(1);
+  }
+  return home;
+}
+
+const HOME_DIR = getHomeDir();
+const PLEXOR_DIR = path.join(HOME_DIR, '.plexor');
 const CONFIG_PATH = path.join(PLEXOR_DIR, 'config.json');
 const SESSION_PATH = path.join(PLEXOR_DIR, 'session.json');
 const CACHE_PATH = path.join(PLEXOR_DIR, 'cache.json');
@@ -15,6 +31,8 @@ const DEFAULT_API_URL = 'https://api.plexor.dev';
 const DEFAULT_TIMEOUT = 5000;
 
 module.exports = {
+  getHomeDir,
+  HOME_DIR,
   PLEXOR_DIR,
   CONFIG_PATH,
   SESSION_PATH,

package/lib/settings-manager.js

@@ -49,8 +49,14 @@ class ClaudeSettingsManager {
 
       // Basic schema validation - must be an object
       if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {
-        console.warn('Warning: Claude settings file has invalid format, using defaults');
-        this._backupCorruptedFile();
+        const backupPath = this._backupCorruptedFile();
+        console.warn('');
+        console.warn('WARNING: Claude settings file has invalid format!');
+        if (backupPath) {
+          console.warn(`         Corrupted file backed up to: ${backupPath}`);
+        }
+        console.warn('         Using default settings. Your previous settings may need manual recovery.');
+        console.warn('');
         return {};
       }
 
@@ -61,9 +67,14 @@ class ClaudeSettingsManager {
       }
       // JSON parse error or corrupted file
       if (err instanceof SyntaxError) {
-        console.warn('Warning: Claude settings file is corrupted, using defaults');
-        console.warn('         A backup has been saved to settings.json.corrupted');
-        this._backupCorruptedFile();
+        const backupPath = this._backupCorruptedFile();
+        console.warn('');
+        console.warn('WARNING: Claude settings file is corrupted (invalid JSON)!');
+        if (backupPath) {
+          console.warn(`         Corrupted file backed up to: ${backupPath}`);
+        }
+        console.warn('         Using default settings. Your previous settings may need manual recovery.');
+        console.warn('');
         return {};
       }
       // Permission error
@@ -77,17 +88,30 @@ class ClaudeSettingsManager {
   }
 
   /**
-   * Backup a corrupted settings file for debugging
+   * Backup a corrupted settings file with numbered suffix for debugging
+   * Creates settings.json.corrupted.1, .corrupted.2, etc. to preserve history
+   * @returns {string|null} path to backup file, or null if backup failed
    */
   _backupCorruptedFile() {
     try {
       if (fs.existsSync(this.settingsPath)) {
-        const backupPath = this.settingsPath + '.corrupted';
+        // Find next available numbered backup
+        let backupNum = 1;
+        let backupPath;
+        while (true) {
+          backupPath = `${this.settingsPath}.corrupted.${backupNum}`;
+          if (!fs.existsSync(backupPath)) {
+            break;
+          }
+          backupNum++;
+        }
         fs.copyFileSync(this.settingsPath, backupPath);
+        return backupPath;
       }
     } catch {
-      // Ignore backup errors
+      // Ignore backup errors silently
     }
+    return null;
   }
 
   /**
@@ -242,6 +266,30 @@ class ClaudeSettingsManager {
     }
   }
 
+  /**
+   * Detect partial routing state where URL points to Plexor but auth is missing/invalid
+   * This can cause confusing auth errors for users
+   * @returns {Object} { partial: boolean, issue: string|null }
+   */
+  detectPartialState() {
+    try {
+      const settings = this.load();
+      const baseUrl = settings.env?.ANTHROPIC_BASE_URL || '';
+      const authToken = settings.env?.ANTHROPIC_AUTH_TOKEN || '';
+      const isPlexorUrl = baseUrl.includes('plexor') || baseUrl.includes('staging.api');
+
+      if (isPlexorUrl && !authToken) {
+        return { partial: true, issue: 'Plexor URL set but no auth token' };
+      }
+      if (isPlexorUrl && !authToken.startsWith('plx_')) {
+        return { partial: true, issue: 'Plexor URL set but auth token is not a Plexor key' };
+      }
+      return { partial: false, issue: null };
+    } catch {
+      return { partial: false, issue: null };
+    }
+  }
+
   /**
    * Update just the API key without changing other settings
    * @param {string} apiKey - new Plexor API key

package/package.json

@@ -1,13 +1,14 @@
 {
   "name": "@plexor-dev/claude-code-plugin",
-  "version": "0.1.0-beta.31",
+  "version": "0.1.0-beta.33",
   "description": "LLM cost optimization plugin for Claude Code - Save up to 90% on AI costs",
   "main": "lib/constants.js",
   "bin": {
     "plexor-status": "./commands/plexor-status.js",
     "plexor-enabled": "./commands/plexor-enabled.js",
     "plexor-login": "./commands/plexor-login.js",
-    "plexor-logout": "./commands/plexor-logout.js"
+    "plexor-logout": "./commands/plexor-logout.js",
+    "plexor-uninstall": "./commands/plexor-uninstall.js"
   },
   "scripts": {
     "postinstall": "node scripts/postinstall.js",

package/scripts/postinstall.js

@@ -77,6 +77,51 @@ const PLEXOR_LIB_DIR = path.join(HOME_DIR, '.claude', 'plugins', 'plexor', 'lib'
 const PLEXOR_CONFIG_DIR = path.join(HOME_DIR, '.plexor');
 const PLEXOR_CONFIG_FILE = path.join(PLEXOR_CONFIG_DIR, 'config.json');
 
+/**
+ * Check for orphaned Plexor routing in settings.json without valid config.
+ * This can happen if a previous uninstall was incomplete.
+ */
+function checkOrphanedRouting() {
+  const home = process.env.HOME || process.env.USERPROFILE;
+  if (!home) return;
+
+  const settingsPath = path.join(home, '.claude', 'settings.json');
+  const configPath = path.join(home, '.plexor', 'config.json');
+
+  try {
+    if (!fs.existsSync(settingsPath)) return;
+
+    const settings = JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
+    const env = settings.env || {};
+
+    const hasPlexorUrl = env.ANTHROPIC_BASE_URL &&
+                         env.ANTHROPIC_BASE_URL.includes('plexor');
+
+    if (hasPlexorUrl) {
+      // Check if there's a valid Plexor config
+      let hasValidConfig = false;
+      try {
+        if (fs.existsSync(configPath)) {
+          const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+          hasValidConfig = config.apiKey && config.apiKey.startsWith('plx_');
+        }
+      } catch (e) {}
+
+      if (!hasValidConfig) {
+        console.log('\n  Warning: Detected orphaned Plexor routing in Claude settings');
+        console.log('  This may be from a previous installation.\n');
+        console.log('  Run /plexor-login to reconfigure, or');
+        console.log('  Run /plexor-uninstall to clean up\n');
+      } else {
+        console.log('\n  Existing Plexor configuration detected');
+        console.log('  Your previous settings have been preserved.\n');
+      }
+    }
+  } catch (e) {
+    // Ignore errors in detection - don't break install
+  }
+}
+
 // Default configuration for new installs
 // PRODUCTION PACKAGE - uses production API
 const DEFAULT_CONFIG = {
@@ -94,6 +139,9 @@ const DEFAULT_CONFIG = {
 };
 
 function main() {
+  // Check for orphaned routing at start of postinstall
+  checkOrphanedRouting();
+
   try {
     // Get target user info for chown (if running with sudo)
     const targetUser = getTargetUserIds();