@plexor-dev/claude-code-plugin-staging 0.1.0-beta.2 → 0.1.0-beta.20

package/commands/plexor-status.js

@@ -9,10 +9,29 @@ const fs = require('fs');
 const path = require('path');
 const https = require('https');
 
-const CONFIG_PATH = path.join(process.env.HOME, '.plexor', 'config.json');
-const SESSION_PATH = path.join(process.env.HOME, '.plexor', 'session.json');
-const CLAUDE_SETTINGS_PATH = path.join(process.env.HOME, '.claude', 'settings.json');
-const SESSION_TIMEOUT_MS = 30 * 60 * 1000; // 30 minutes
+// Import centralized constants with HOME directory validation
+const { HOME_DIR, CONFIG_PATH, SESSION_PATH, SESSION_TIMEOUT_MS } = require('../lib/constants');
+const CLAUDE_SETTINGS_PATH = path.join(HOME_DIR, '.claude', 'settings.json');
+
+function isManagedGatewayUrl(baseUrl = '') {
+  return (
+    baseUrl.includes('plexor') ||
+    baseUrl.includes('staging.api') ||
+    baseUrl.includes('ngrok') ||
+    baseUrl.includes('localtunnel') ||
+    baseUrl.includes('localhost') ||
+    baseUrl.includes('127.0.0.1')
+  );
+}
+
+function getPlexorAuthKey(env = {}) {
+  const apiKey = env.ANTHROPIC_API_KEY || '';
+  const authToken = env.ANTHROPIC_AUTH_TOKEN || '';
+
+  if (apiKey.startsWith('plx_')) return apiKey;
+  if (authToken.startsWith('plx_')) return authToken;
+  return apiKey || authToken || '';
+}
 
 /**
  * Check if Claude Code is actually routing through Plexor
@@ -23,10 +42,10 @@ function getRoutingStatus() {
     const data = fs.readFileSync(CLAUDE_SETTINGS_PATH, 'utf8');
     const settings = JSON.parse(data);
     const baseUrl = settings.env?.ANTHROPIC_BASE_URL || '';
-    const hasToken = !!settings.env?.ANTHROPIC_AUTH_TOKEN;
-    const isPlexorRouting = baseUrl.includes('plexor') || baseUrl.includes('staging.api');
+    const authKey = getPlexorAuthKey(settings.env);
+    const isPlexorRouting = isManagedGatewayUrl(baseUrl);
     return {
-      active: isPlexorRouting && hasToken,
+      active: isPlexorRouting && !!authKey,
       baseUrl,
       isStaging: baseUrl.includes('staging')
     };
@@ -35,6 +54,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 authKey = getPlexorAuthKey(settings.env);
+    const isPlexorUrl = isManagedGatewayUrl(baseUrl);
+
+    if (isPlexorUrl && !authKey) {
+      return { partial: true, issue: 'Plexor URL set but no Plexor auth key' };
+    }
+    if (isPlexorUrl && !authKey.startsWith('plx_')) {
+      return { partial: true, issue: 'Plexor URL set but auth key 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');
@@ -49,14 +93,107 @@ function loadSessionStats() {
   }
 }
 
-async function main() {
-  // Read config
-  let config;
+/**
+ * Validate API key format
+ * @param {string} key - API key to validate
+ * @returns {boolean} true if valid format
+ */
+function isValidApiKeyFormat(key) {
+  return key && typeof key === 'string' && key.startsWith('plx_') && key.length >= 20;
+}
+
+/**
+ * Load config file with integrity checking
+ * @returns {Object|null} config object or null if invalid
+ */
+function loadConfig() {
   try {
+    if (!fs.existsSync(CONFIG_PATH)) {
+      return null;
+    }
     const data = fs.readFileSync(CONFIG_PATH, 'utf8');
-    config = JSON.parse(data);
+    if (!data || data.trim() === '') {
+      return null;
+    }
+    const config = JSON.parse(data);
+    if (typeof config !== 'object' || config === null) {
+      return null;
+    }
+    return config;
   } catch (err) {
-    console.log('Not configured. Run /plexor-login first.');
+    if (err instanceof SyntaxError) {
+      console.log('Config file is corrupted. Run /plexor-setup to reconfigure.');
+    }
+    return null;
+  }
+}
+
+/**
+ * Check for environment mismatch between config and routing
+ */
+function checkEnvironmentMismatch(configApiUrl, routingBaseUrl) {
+  if (!configApiUrl || !routingBaseUrl) return null;
+
+  const configIsStaging = configApiUrl.includes('staging');
+  const routingIsStaging = routingBaseUrl.includes('staging');
+
+  if (configIsStaging !== routingIsStaging) {
+    return {
+      config: configIsStaging ? 'staging' : 'production',
+      routing: routingIsStaging ? 'staging' : 'production'
+    };
+  }
+  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;
+}
+
+function printHealthSummary(summary) {
+  const line = (content) => `  │  ${String(content).slice(0, 43).padEnd(43)}│`;
+  console.log(`  ┌─────────────────────────────────────────────┐`);
+  console.log(line('Plexor health'));
+  console.log(`  ├─────────────────────────────────────────────┤`);
+  console.log(line(`Installed: ${summary.installed}`));
+  console.log(line(`Connected: ${summary.connected}`));
+  console.log(line(`Routing Active: ${summary.routing}`));
+  console.log(line(`Verified: ${summary.verified}`));
+  console.log(line(`Next action: ${summary.nextAction}`));
+  console.log(`  └─────────────────────────────────────────────┘`);
+}
+
+async function main() {
+  // Read config with integrity checking
+  const config = loadConfig();
+  if (!config) {
+    printHealthSummary({
+      installed: 'Missing',
+      connected: 'Not connected',
+      routing: 'Inactive',
+      verified: 'Not run',
+      nextAction: 'Run /plexor-setup'
+    });
     process.exit(1);
   }
 
@@ -66,21 +203,42 @@ async function main() {
   const provider = config.settings?.preferred_provider || 'auto';
   const localCache = config.settings?.localCacheEnabled ?? false;
   const apiUrl = config.settings?.apiUrl || 'https://api.plexor.dev';
+  const verification = config.health || {};
 
   if (!apiKey) {
-    console.log('Not authenticated. Run /plexor-login first.');
+    printHealthSummary({
+      installed: 'OK',
+      connected: 'Missing key',
+      routing: 'Inactive',
+      verified: 'Not run',
+      nextAction: 'Run /plexor-setup'
+    });
+    process.exit(1);
+  }
+
+  // Validate API key format
+  if (!isValidApiKeyFormat(apiKey)) {
+    printHealthSummary({
+      installed: 'OK',
+      connected: 'Invalid key',
+      routing: 'Needs repair',
+      verified: 'Failed',
+      nextAction: 'Run /plexor-setup'
+    });
     process.exit(1);
   }
 
   // Fetch user info and stats
   let user = { email: 'Unknown', tier: { name: 'Free', limits: {} } };
   let stats = { period: {}, summary: {} };
+  let userFetchWorked = false;
 
   try {
     [user, stats] = await Promise.all([
       fetchJson(apiUrl, '/v1/user', apiKey),
       fetchJson(apiUrl, '/v1/stats', apiKey)
     ]);
+    userFetchWorked = true;
   } catch (err) {
     // Continue with defaults if API fails
   }
@@ -164,6 +322,38 @@ ${line(`└── Cost saved: $${sessionCostSaved}`)}
   const routing = getRoutingStatus();
   const routingIndicator = routing.active ? '🟢 PLEXOR MODE: ON' : '🔴 PLEXOR MODE: OFF';
   const envLabel = routing.isStaging ? '(staging)' : '(production)';
+  const partialState = detectPartialState();
+  const stateMismatch = checkStateMismatch(enabled, routing.active);
+  const connectedState = userFetchWorked ? 'OK' : 'Unknown';
+  const verifiedState = verification.verified
+    ? 'OK'
+    : (verification.verify_error ? 'Failed' : 'Not yet');
+  const nextAction = !routing.active || partialState.partial || stateMismatch || !verification.verified
+    ? '/plexor-setup'
+    : '/plexor-status';
+
+  // Note: Environment mismatch warning removed - it caused false positives during
+  // concurrent operations and transient states. The partial state and config/routing
+  // mismatch warnings below provide more actionable feedback.
+
+  printHealthSummary({
+    installed: 'OK',
+    connected: connectedState,
+    routing: routing.active ? `OK ${envLabel}` : 'Needs repair',
+    verified: verifiedState,
+    nextAction
+  });
+  console.log('');
+  if (partialState.partial) {
+    console.log(`  ⚠ PARTIAL STATE DETECTED: ${partialState.issue}`);
+    console.log(`    Run /plexor-setup to repair, or /plexor-logout to disable routing\n`);
+  }
+
+  // Check for state mismatch between config enabled flag and routing status
+  if (stateMismatch) {
+    console.log(`  ⚠ State mismatch: ${stateMismatch.message}`);
+    console.log(`  └─ ${stateMismatch.suggestion}\n`);
+  }
 
   console.log(`  ┌─────────────────────────────────────────────┐
 ${line(routingIndicator + (routing.active ? ' ' + envLabel : ''))}
@@ -202,7 +392,13 @@ ${line(`└── Endpoint: ${routing.baseUrl ? routing.baseUrl.replace('https:/
 
 function fetchJson(apiUrl, endpoint, apiKey) {
   return new Promise((resolve, reject) => {
-    const url = new URL(`${apiUrl}${endpoint}`);
+    let url;
+    try {
+      url = new URL(`${apiUrl}${endpoint}`);
+    } catch {
+      reject(new Error('Invalid API URL'));
+      return;
+    }
 
     const options = {
       hostname: url.hostname,
@@ -218,18 +414,48 @@ function fetchJson(apiUrl, endpoint, apiKey) {
       let data = '';
       res.on('data', chunk => data += chunk);
       res.on('end', () => {
+        // Check HTTP status code first
+        if (res.statusCode === 401) {
+          reject(new Error('Invalid API key'));
+          return;
+        }
+        if (res.statusCode === 403) {
+          reject(new Error('Access denied'));
+          return;
+        }
+        if (res.statusCode >= 500) {
+          reject(new Error('Server error'));
+          return;
+        }
+        if (res.statusCode !== 200) {
+          reject(new Error(`HTTP ${res.statusCode}`));
+          return;
+        }
+
+        // Check for empty response
+        if (!data || data.trim() === '') {
+          reject(new Error('Empty response'));
+          return;
+        }
+
+        // Parse JSON
         try {
-          resolve(JSON.parse(data));
+          const parsed = JSON.parse(data);
+          if (parsed === null) {
+            reject(new Error('Null response'));
+            return;
+          }
+          resolve(parsed);
         } catch {
-          reject(new Error('Invalid response'));
+          reject(new Error('Invalid JSON response'));
         }
       });
     });
 
-    req.on('error', reject);
+    req.on('error', (err) => reject(new Error(`Connection failed: ${err.message}`)));
     req.setTimeout(5000, () => {
       req.destroy();
-      reject(new Error('Timeout'));
+      reject(new Error('Request timeout'));
     });
     req.end();
   });

package/commands/plexor-status.md

@@ -2,20 +2,8 @@
 description: Show Plexor optimization statistics and savings (user)
 ---
 
-# Plexor Status
-
-Run this command to display Plexor statistics:
+**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.**
 
 ```bash
 node ~/.claude/plugins/plexor/commands/plexor-status.js
 ```
-
-Use the Bash tool to execute this single command.
-
-**IMPORTANT**: After running this command and displaying the output, STOP. Do not:
-- Read any files
-- Explore the codebase
-- Run additional commands
-- Ask follow-up questions
-
-The command output is the complete response. Simply show the output and wait for the user's next input.

package/commands/plexor-uninstall.js

@@ -0,0 +1,319 @@
+#!/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' };
+    }
+
+    const isManagedGatewayUrl = (baseUrl = '') =>
+      baseUrl.includes('plexor') ||
+      baseUrl.includes('staging.api') ||
+      baseUrl.includes('localhost') ||
+      baseUrl.includes('127.0.0.1') ||
+      baseUrl.includes('ngrok') ||
+      baseUrl.includes('localtunnel');
+    const isPlexorApiKey = (value = '') =>
+      typeof value === 'string' && value.startsWith('plx_');
+
+    const hasManagedBaseUrl = isManagedGatewayUrl(settings.env.ANTHROPIC_BASE_URL || '');
+    const hasPlexorAuthToken = isPlexorApiKey(settings.env.ANTHROPIC_AUTH_TOKEN || '');
+    const hasPlexorApiKey = isPlexorApiKey(settings.env.ANTHROPIC_API_KEY || '');
+
+    if (!hasManagedBaseUrl && !hasPlexorAuthToken && !hasPlexorApiKey) {
+      return { success: true, message: 'Plexor routing not active' };
+    }
+
+    if (hasManagedBaseUrl) {
+      delete settings.env.ANTHROPIC_BASE_URL;
+    }
+    if (hasPlexorAuthToken) {
+      delete settings.env.ANTHROPIC_AUTH_TOKEN;
+    }
+    if (hasPlexorApiKey) {
+      delete settings.env.ANTHROPIC_API_KEY;
+    }
+
+    if (!settings.env.ANTHROPIC_API_KEY && settings.env.PLEXOR_PREVIOUS_ANTHROPIC_API_KEY) {
+      settings.env.ANTHROPIC_API_KEY = settings.env.PLEXOR_PREVIOUS_ANTHROPIC_API_KEY;
+    }
+    if (!settings.env.ANTHROPIC_AUTH_TOKEN && settings.env.PLEXOR_PREVIOUS_ANTHROPIC_AUTH_TOKEN) {
+      settings.env.ANTHROPIC_AUTH_TOKEN = settings.env.PLEXOR_PREVIOUS_ANTHROPIC_AUTH_TOKEN;
+    }
+
+    delete settings.env.PLEXOR_PREVIOUS_ANTHROPIC_API_KEY;
+    delete settings.env.PLEXOR_PREVIOUS_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-staging');
+    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 (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,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-staging`. 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
+```