@plexor-dev/claude-code-plugin-staging 0.1.0-beta.10 → 0.1.0-beta.11

package/commands/plexor-enabled.js

@@ -94,6 +94,30 @@ function isValidApiKeyFormat(key) {
   return key && typeof key === 'string' && key.startsWith('plx_') && key.length >= 20;
 }
 
+/**
+ * Check for state mismatch between config.json enabled flag and settings.json routing
+ * @param {boolean} configEnabled - enabled flag from config.json
+ * @param {boolean} routingActive - whether settings.json has Plexor routing configured
+ * @returns {Object|null} mismatch details or null if states are consistent
+ */
+function checkStateMismatch(configEnabled, routingActive) {
+  if (configEnabled && !routingActive) {
+    return {
+      type: 'config-enabled-routing-inactive',
+      message: 'Config shows enabled but Claude routing is not configured',
+      suggestion: 'Run /plexor-enabled true to sync and configure routing'
+    };
+  }
+  if (!configEnabled && routingActive) {
+    return {
+      type: 'config-disabled-routing-active',
+      message: 'Config shows disabled but Claude routing is active',
+      suggestion: 'Run /plexor-enabled false to sync and disable routing'
+    };
+  }
+  return null;
+}
+
 function main() {
   const args = process.argv.slice(2);
   const config = loadConfig();
@@ -107,6 +131,10 @@ function main() {
   if (args.length === 0) {
     const status = currentEnabled ? '● Enabled' : '○ Disabled';
     const routingStr = routingStatus.enabled ? '● Active' : '○ Inactive';
+
+    // Check for state mismatch between config enabled flag and routing status
+    const stateMismatch = checkStateMismatch(currentEnabled, routingStatus.enabled);
+
     console.log(`┌─────────────────────────────────────────────┐`);
     console.log(`│  Plexor Proxy Status                        │`);
     console.log(`├─────────────────────────────────────────────┤`);
@@ -115,6 +143,12 @@ function main() {
     if (routingStatus.enabled) {
     console.log(`│  Endpoint: ${(routingStatus.isStaging ? 'Staging' : 'Production').padEnd(32)}│`);
     }
+    if (stateMismatch) {
+    console.log(`├─────────────────────────────────────────────┤`);
+    console.log(`│  ⚠ State mismatch detected:                 │`);
+    console.log(`│  ${stateMismatch.message.padEnd(42)}│`);
+    console.log(`│  ${stateMismatch.suggestion.padEnd(42)}│`);
+    }
     console.log(`├─────────────────────────────────────────────┤`);
     console.log(`│  Usage:                                     │`);
     console.log(`│    /plexor-enabled true   - Enable proxy    │`);
@@ -161,6 +195,19 @@ function main() {
       const apiUrl = config.settings?.apiUrl || 'https://staging.api.plexor.dev';
       const useStaging = apiUrl.includes('staging');
       routingUpdated = settingsManager.enablePlexorRouting(apiKey, { useStaging });
+
+      // Check if settings.json update failed
+      if (!routingUpdated) {
+        console.log(`┌─────────────────────────────────────────────┐`);
+        console.log(`│  ✗ Failed to Enable Plexor Routing          │`);
+        console.log(`├─────────────────────────────────────────────┤`);
+        console.log(`│  Could not update ~/.claude/settings.json   │`);
+        console.log(`│  Config.json was updated but routing failed.│`);
+        console.log(`├─────────────────────────────────────────────┤`);
+        console.log(`│  Check file permissions and try again.      │`);
+        console.log(`└─────────────────────────────────────────────┘`);
+        process.exit(1);
+      }
     }
   } else {
     // Update Plexor plugin config
@@ -172,6 +219,19 @@ function main() {
 
     // Disable routing - remove env vars from settings.json
     routingUpdated = settingsManager.disablePlexorRouting();
+
+    // Check if settings.json update failed
+    if (!routingUpdated) {
+      console.log(`┌─────────────────────────────────────────────┐`);
+      console.log(`│  ✗ Failed to Disable Plexor Routing         │`);
+      console.log(`├─────────────────────────────────────────────┤`);
+      console.log(`│  Could not update ~/.claude/settings.json   │`);
+      console.log(`│  Config.json was updated but routing failed.│`);
+      console.log(`├─────────────────────────────────────────────┤`);
+      console.log(`│  Check file permissions and try again.      │`);
+      console.log(`└─────────────────────────────────────────────┘`);
+      process.exit(1);
+    }
   }
 
   // Show error if no API key when enabling

package/commands/plexor-status.js

@@ -34,6 +34,31 @@ function getRoutingStatus() {
   }
 }
 
+/**
+ * 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 }
+ */
+function detectPartialState() {
+  try {
+    const data = fs.readFileSync(CLAUDE_SETTINGS_PATH, 'utf8');
+    const settings = JSON.parse(data);
+    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 };
+  }
+}
+
 function loadSessionStats() {
   try {
     const data = fs.readFileSync(SESSION_PATH, 'utf8');
@@ -101,6 +126,30 @@ function checkEnvironmentMismatch(configApiUrl, routingBaseUrl) {
   return null;
 }
 
+/**
+ * Check for state mismatch between config.json enabled flag and settings.json routing
+ * @param {boolean} configEnabled - enabled flag from config.json
+ * @param {boolean} routingActive - whether settings.json has Plexor routing configured
+ * @returns {Object|null} mismatch details or null if states are consistent
+ */
+function checkStateMismatch(configEnabled, routingActive) {
+  if (configEnabled && !routingActive) {
+    return {
+      type: 'config-enabled-routing-inactive',
+      message: 'Config shows enabled but Claude routing is not configured',
+      suggestion: 'Run /plexor-enabled true to sync and configure routing'
+    };
+  }
+  if (!configEnabled && routingActive) {
+    return {
+      type: 'config-disabled-routing-active',
+      message: 'Config shows disabled but Claude routing is active',
+      suggestion: 'Run /plexor-enabled false to sync and disable routing'
+    };
+  }
+  return null;
+}
+
 async function main() {
   // Read config with integrity checking
   const config = loadConfig();
@@ -231,6 +280,20 @@ ${line(`└── Cost saved: $${sessionCostSaved}`)}
     console.log(mismatchWarning);
   }
 
+  // Check for partial routing state (Plexor URL without valid auth)
+  const partialState = detectPartialState();
+  if (partialState.partial) {
+    console.log(`  ⚠ PARTIAL STATE DETECTED: ${partialState.issue}`);
+    console.log(`    Run /plexor-login to fix, or /plexor-logout to disable routing\n`);
+  }
+
+  // Check for state mismatch between config enabled flag and routing status
+  const stateMismatch = checkStateMismatch(enabled, routing.active);
+  if (stateMismatch) {
+    console.log(`  ⚠ State mismatch: ${stateMismatch.message}`);
+    console.log(`  └─ ${stateMismatch.suggestion}\n`);
+  }
+
   console.log(`  ┌─────────────────────────────────────────────┐
 ${line(routingIndicator + (routing.active ? ' ' + envLabel : ''))}
   ├─────────────────────────────────────────────┤

package/commands/plexor-uninstall.js

@@ -0,0 +1,274 @@
+#!/usr/bin/env node
+
+/**
+ * Plexor Uninstall Command (STAGING)
+ *
+ * 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);
+  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 (STAGING) - 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-staging      │');
+    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,30 @@
+---
+name: plexor-uninstall
+description: Clean up Plexor integration before uninstalling
+---
+
+Runs comprehensive cleanup to prepare for npm uninstall.
+
+**IMPORTANT**: Run this command BEFORE `npm uninstall -g @plexor-dev/claude-code-plugin-staging`
+
+npm's preuninstall hook does NOT run for global package uninstalls, so this command
+must be run manually to ensure proper cleanup.
+
+This removes:
+- Plexor routing from Claude settings (~/.claude/settings.json)
+- Slash command files from ~/.claude/commands/
+- Plugin directory ~/.claude/plugins/plexor/
+
+Options:
+- `--remove-config` or `-c`: Also remove ~/.plexor/ config directory
+
+After running this command, run:
+```bash
+npm uninstall -g @plexor-dev/claude-code-plugin-staging
+```
+
+$ARGUMENTS: $ARGUMENTS
+
+```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 {}
   };
 

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/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-staging",
-  "version": "0.1.0-beta.10",
+  "version": "0.1.0-beta.11",
   "description": "STAGING - LLM cost optimization plugin for Claude Code (internal testing)",
   "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
 // STAGING PACKAGE - uses staging 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();

package/scripts/uninstall.js

@@ -1,97 +1,154 @@
 #!/usr/bin/env node
 
 /**
- * Plexor Claude Code Plugin - Uninstall Script
+ * Plexor Claude Code Plugin (Staging) - Comprehensive Uninstall Script
  *
- * Removes slash commands from ~/.claude/commands/
- * Optionally restores backups if they exist.
+ * Runs on npm uninstall (when npm actually calls it).
+ * Also callable directly: node scripts/uninstall.js
+ *
+ * Performs complete cleanup:
+ * 1. Removes Plexor routing from ~/.claude/settings.json
+ * 2. Removes slash command files from ~/.claude/commands/
+ * 3. Removes plugin directory from ~/.claude/plugins/plexor/
+ * 4. Restores any backups if they exist
  */
 
 const fs = require('fs');
 const path = require('path');
-const os = require('os');
 
-// Import settings manager for Claude Code routing cleanup
-let settingsManager;
-try {
-  const lib = require('../lib/settings-manager');
-  settingsManager = lib.settingsManager;
-} catch (err) {
-  // If settings manager can't be loaded during uninstall, continue anyway
-  settingsManager = null;
+// Get home directory - support both Unix and Windows
+const home = process.env.HOME || process.env.USERPROFILE;
+if (!home) {
+  console.log('Warning: HOME not set, skipping cleanup');
+  process.exit(0);
 }
 
-const COMMANDS_SOURCE = path.join(__dirname, '..', 'commands');
-const CLAUDE_COMMANDS_DIR = path.join(os.homedir(), '.claude', 'commands');
-
-function main() {
-  try {
-    // CRITICAL: Disable Claude Code routing before removing commands
-    // This ensures users don't get stuck with Plexor routing after uninstall
-    let routingDisabled = false;
-    if (settingsManager) {
-      try {
-        routingDisabled = settingsManager.disablePlexorRouting();
-      } catch (e) {
-        // Continue with uninstall even if routing cleanup fails
+console.log('');
+console.log('  Plexor plugin cleanup...');
+console.log('');
+
+const results = {
+  routing: false,
+  commands: [],
+  restored: [],
+  pluginDir: false
+};
+
+// 1. Remove routing from settings.json
+// This is CRITICAL - do NOT depend on settings-manager module since it may not load during uninstall
+try {
+  const settingsPath = path.join(home, '.claude', 'settings.json');
+  if (fs.existsSync(settingsPath)) {
+    const data = fs.readFileSync(settingsPath, 'utf8');
+    if (data && data.trim()) {
+      const settings = JSON.parse(data);
+      if (settings.env) {
+        const hadBaseUrl = !!settings.env.ANTHROPIC_BASE_URL;
+        const hadAuthToken = !!settings.env.ANTHROPIC_AUTH_TOKEN;
+
+        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;
+        }
+
+        if (hadBaseUrl || hadAuthToken) {
+          fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2), { mode: 0o600 });
+          results.routing = true;
+        }
       }
     }
+  }
+} catch (e) {
+  console.log(`  Warning: Could not clean settings.json: ${e.message}`);
+}
 
-    // Get list of our command files
-    const files = fs.readdirSync(COMMANDS_SOURCE)
-      .filter(f => f.endsWith('.md'));
-
-    const removed = [];
-    const restored = [];
+// 2. Remove slash command files
+// These are the Plexor-specific command files that get installed to ~/.claude/commands/
+const plexorCommands = [
+  'plexor-config.md',
+  'plexor-enabled.md',
+  'plexor-login.md',
+  'plexor-logout.md',
+  'plexor-mode.md',
+  'plexor-provider.md',
+  'plexor-settings.md',
+  'plexor-setup.md',
+  'plexor-status.md',
+  'plexor-uninstall.md'
+];
 
-    for (const file of files) {
-      const dest = path.join(CLAUDE_COMMANDS_DIR, file);
-      const backupPath = dest + '.backup';
+try {
+  const commandsDir = path.join(home, '.claude', 'commands');
+  if (fs.existsSync(commandsDir)) {
+    for (const cmd of plexorCommands) {
+      const cmdPath = path.join(commandsDir, cmd);
+      const backupPath = cmdPath + '.backup';
 
-      if (fs.existsSync(dest)) {
-        fs.unlinkSync(dest);
-        removed.push(file.replace('.md', ''));
+      if (fs.existsSync(cmdPath)) {
+        fs.unlinkSync(cmdPath);
+        results.commands.push(cmd.replace('.md', ''));
 
         // Restore backup if it exists
         if (fs.existsSync(backupPath)) {
-          fs.renameSync(backupPath, dest);
-          restored.push(file);
+          fs.renameSync(backupPath, cmdPath);
+          results.restored.push(cmd);
         }
       }
     }
+  }
+} catch (e) {
+  console.log(`  Warning: Could not clean commands: ${e.message}`);
+}
 
-    if (removed.length > 0 || routingDisabled) {
-      console.log('');
-      console.log('  Plexor plugin uninstalled');
-      console.log('');
+// 3. Remove plugin directory
+try {
+  const pluginDir = path.join(home, '.claude', 'plugins', 'plexor');
+  if (fs.existsSync(pluginDir)) {
+    fs.rmSync(pluginDir, { recursive: true, force: true });
+    results.pluginDir = true;
+  }
+} catch (e) {
+  console.log(`  Warning: Could not remove plugin directory: ${e.message}`);
+}
 
-      if (routingDisabled) {
-        console.log('  ✓ Claude Code routing disabled');
-        console.log('    (Claude Code now connects directly to Anthropic)');
-        console.log('');
-      }
+// Output results
+if (results.routing || results.commands.length > 0 || results.pluginDir) {
+  console.log('  Plexor plugin uninstalled');
+  console.log('');
 
-      if (removed.length > 0) {
-        console.log('  Removed commands:');
-        removed.forEach(cmd => console.log(`    /${cmd}`));
-      }
+  if (results.routing) {
+    console.log('  Removed Plexor routing from Claude settings');
+    console.log('    (Claude Code now connects directly to Anthropic)');
+    console.log('');
+  }
 
-      if (restored.length > 0) {
-        console.log('');
-        console.log('  Restored from backup:');
-        restored.forEach(f => console.log(`    ${f}`));
-      }
+  if (results.commands.length > 0) {
+    console.log('  Removed commands:');
+    results.commands.forEach(cmd => console.log(`    /${cmd}`));
+    console.log('');
+  }
 
-      console.log('');
-      console.log('  Note: ~/.plexor/ config directory was preserved.');
-      console.log('  To remove it: rm -rf ~/.plexor');
-      console.log('');
-    }
+  if (results.restored.length > 0) {
+    console.log('  Restored from backup:');
+    results.restored.forEach(f => console.log(`    ${f}`));
+    console.log('');
+  }
 
-  } catch (error) {
-    // Don't fail uninstall on errors - just warn
-    console.warn(`  Warning: Could not fully uninstall: ${error.message}`);
+  if (results.pluginDir) {
+    console.log('  Removed plugin directory');
+    console.log('');
   }
+
+  console.log('  Note: ~/.plexor/ config directory was preserved.');
+  console.log('  To remove it: rm -rf ~/.plexor');
+  console.log('');
+} else {
+  console.log('  No Plexor components found to clean up.');
+  console.log('');
 }
 
-main();
+console.log('  Cleanup complete');
+console.log('');