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

package/scripts/postinstall.js

@@ -13,42 +13,109 @@ const os = require('os');
 const { execSync } = require('child_process');
 
 /**
- * Get the correct home directory, accounting for sudo.
- * When running with sudo, os.homedir() returns /root, but we want
- * the actual user's home directory.
+ * Resolve the home directory for a given username by querying /etc/passwd.
+ * This is the authoritative source and handles non-standard home paths
+ * (e.g., /root, /opt/users/foo, NIS/LDAP users, etc.).
+ * Returns null if lookup fails (Windows, missing getent, etc.).
+ */
+function getHomeDirFromPasswd(username) {
+  try {
+    const entry = execSync(`getent passwd ${username}`, { encoding: 'utf8' }).trim();
+    // Format: username:x:uid:gid:gecos:homedir:shell
+    const fields = entry.split(':');
+    if (fields.length >= 6 && fields[5]) {
+      return fields[5];
+    }
+  } catch {
+    // getent not available or user not found
+  }
+  return null;
+}
+
+/**
+ * Get the correct home directory for the process's effective user.
+ *
+ * Handles three scenarios:
+ *   1. Normal execution:           HOME is correct, os.homedir() is correct.
+ *   2. `sudo npm install`:         SUDO_USER is set, os.homedir() returns /root,
+ *                                   but we want the SUDO_USER's home.
+ *   3. `sudo -u target npm install`:
+ *                                   HOME may still be the *caller's* home (e.g.,
+ *                                   /home/azureuser), SUDO_USER is the *caller*
+ *                                   (not the target), but process.getuid() returns
+ *                                   the *target* UID. We must resolve home from
+ *                                   /etc/passwd by UID.
+ *
+ * Resolution order (most authoritative first):
+ *   a) Look up the effective UID in /etc/passwd via getent (handles sudo -u)
+ *   b) Fall back to os.homedir() (works for normal execution)
+ *   c) Fall back to HOME / USERPROFILE env vars (last resort)
  */
 function getHomeDir() {
-  // Check if running with sudo - SUDO_USER contains the original username
-  if (process.env.SUDO_USER) {
-    // On Linux/Mac, home directories are typically /home/<user> or /Users/<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);
+  // On non-Windows, resolve via the effective UID's passwd entry.
+  // This is the most reliable method and correctly handles both
+  // `sudo` and `sudo -u <target>` scenarios.
+  if (os.platform() !== 'win32') {
+    try {
+      const uid = process.getuid();
+      const entry = execSync(`getent passwd ${uid}`, { encoding: 'utf8' }).trim();
+      const fields = entry.split(':');
+      if (fields.length >= 6 && fields[5]) {
+        return fields[5];
+      }
+    } catch {
+      // Fall through to other methods
     }
   }
-  return os.homedir();
+
+  // Fallback: os.homedir() (reads HOME env var, then passwd on Unix)
+  const home = os.homedir();
+  if (home) return home;
+
+  // Last resort: environment variables
+  return process.env.HOME || process.env.USERPROFILE || '/tmp';
 }
 
 /**
- * Get uid/gid for the target user (handles sudo case).
- * Returns null if not running with sudo or on Windows.
+ * Get uid/gid for the effective user running this process.
+ * Under `sudo`, the effective user is root but we want to chown to the
+ * original (SUDO_USER) or target (`sudo -u target`) user.
+ * Under `sudo -u target`, process.getuid() IS the target, so we use that.
+ * Returns null on Windows or if no privilege elevation detected.
  */
 function getTargetUserIds() {
-  const sudoUser = process.env.SUDO_USER;
-  if (!sudoUser || os.platform() === 'win32') {
+  if (os.platform() === 'win32') {
     return null;
   }
 
   try {
-    // Get uid and gid for the sudo user
-    const uid = parseInt(execSync(`id -u ${sudoUser}`, { encoding: 'utf8' }).trim(), 10);
-    const gid = parseInt(execSync(`id -g ${sudoUser}`, { encoding: 'utf8' }).trim(), 10);
-    return { uid, gid, user: sudoUser };
+    const effectiveUid = process.getuid();
+
+    // If we're running as root (uid 0), we were likely invoked via `sudo`.
+    // Chown files to SUDO_USER (the human who ran sudo).
+    if (effectiveUid === 0 && process.env.SUDO_USER) {
+      const uid = parseInt(execSync(`id -u ${process.env.SUDO_USER}`, { encoding: 'utf8' }).trim(), 10);
+      const gid = parseInt(execSync(`id -g ${process.env.SUDO_USER}`, { encoding: 'utf8' }).trim(), 10);
+      return { uid, gid, user: process.env.SUDO_USER };
+    }
+
+    // If we're NOT root but SUDO_USER is set, we were invoked via `sudo -u target`.
+    // The effective UID is already the target user. Chown to that user.
+    if (effectiveUid !== 0 && process.env.SUDO_USER) {
+      const entry = execSync(`getent passwd ${effectiveUid}`, { encoding: 'utf8' }).trim();
+      const fields = entry.split(':');
+      if (fields.length >= 4) {
+        const username = fields[0];
+        const uid = parseInt(fields[2], 10);
+        const gid = parseInt(fields[3], 10);
+        return { uid, gid, user: username };
+      }
+    }
   } catch {
-    return null;
+    // Fall through
   }
+
+  return null;
 }
 
 /**
@@ -70,12 +137,139 @@ function chownRecursive(dirPath, uid, gid) {
 
 const HOME_DIR = getHomeDir();
 const COMMANDS_SOURCE = path.join(__dirname, '..', 'commands');
+const LIB_SOURCE = path.join(__dirname, '..', 'lib');
 const CLAUDE_COMMANDS_DIR = path.join(HOME_DIR, '.claude', 'commands');
 const PLEXOR_PLUGINS_DIR = path.join(HOME_DIR, '.claude', 'plugins', 'plexor', 'commands');
+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 if a base URL is a Plexor-managed gateway URL.
+ * Detects all variants: production, staging, localhost, tunnels.
+ */
+function isManagedGatewayUrl(baseUrl) {
+  if (!baseUrl) return false;
+  return (
+    baseUrl.includes('plexor') ||
+    baseUrl.includes('staging.api') ||
+    baseUrl.includes('localhost') ||
+    baseUrl.includes('127.0.0.1') ||
+    baseUrl.includes('ngrok') ||
+    baseUrl.includes('localtunnel')
+  );
+}
+
+/**
+ * The expected base URL for THIS plugin variant.
+ * Used to detect when a different variant was previously installed.
+ */
+const THIS_VARIANT_URL = 'https://staging.api.plexor.dev/gateway/anthropic';
+const PREVIOUS_API_KEY_ENV = 'PLEXOR_PREVIOUS_ANTHROPIC_API_KEY';
+const PREVIOUS_AUTH_TOKEN_ENV = 'PLEXOR_PREVIOUS_ANTHROPIC_AUTH_TOKEN';
+
+/**
+ * Check for orphaned Plexor routing in settings.json without valid config.
+ * Also detects variant mismatch (e.g., localhost plugin was installed, now
+ * installing staging plugin) and migrates ANTHROPIC_BASE_URL + syncs
+ * Claude auth env vars for Plexor-managed gateways.
+ */
+function selectManagedAuthKey(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 || '';
+}
+
+function syncManagedAuthEnv(env, managedAuthKey) {
+  const currentApiKey = env.ANTHROPIC_API_KEY || '';
+  const currentAuthToken = env.ANTHROPIC_AUTH_TOKEN || '';
+
+  if (currentApiKey && !currentApiKey.startsWith('plx_') && currentApiKey !== managedAuthKey) {
+    env[PREVIOUS_API_KEY_ENV] = currentApiKey;
+  }
+  if (currentAuthToken && !currentAuthToken.startsWith('plx_') && currentAuthToken !== managedAuthKey) {
+    env[PREVIOUS_AUTH_TOKEN_ENV] = currentAuthToken;
+  }
+
+  env.ANTHROPIC_API_KEY = managedAuthKey;
+  env.ANTHROPIC_AUTH_TOKEN = managedAuthKey;
+}
+
+function checkOrphanedRouting() {
+  // Use the resolved HOME_DIR (not process.env.HOME which may be wrong under sudo -u)
+  const settingsPath = path.join(HOME_DIR, '.claude', 'settings.json');
+  const configPath = path.join(HOME_DIR, '.plexor', 'config.json');
+
+  try {
+    if (!fs.existsSync(settingsPath)) return;
+
+    const settings = JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
+    const env = settings.env || {};
+    let settingsChanged = false;
+
+    const hasPlexorUrl = isManagedGatewayUrl(env.ANTHROPIC_BASE_URL);
+
+    if (hasPlexorUrl) {
+      // Keep both Claude auth env vars aligned to the Plexor key so Claude API
+      // auth cannot override the gateway after plugin setup.
+      const managedAuthKey = selectManagedAuthKey(env);
+      if (managedAuthKey &&
+          (env.ANTHROPIC_API_KEY !== managedAuthKey || env.ANTHROPIC_AUTH_TOKEN !== managedAuthKey)) {
+        syncManagedAuthEnv(env, managedAuthKey);
+        settings.env = env;
+        settingsChanged = true;
+        console.log('\n  Synced Plexor auth into ANTHROPIC_API_KEY and ANTHROPIC_AUTH_TOKEN');
+      }
+      // 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.auth?.api_key || 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 {
+        // Fix #2176: Detect variant mismatch and migrate URL
+        const currentUrl = env.ANTHROPIC_BASE_URL;
+        if (currentUrl !== THIS_VARIANT_URL) {
+          env.ANTHROPIC_BASE_URL = THIS_VARIANT_URL;
+          settings.env = env;
+          settingsChanged = true;
+          console.log(`\n  Migrated ANTHROPIC_BASE_URL to this variant's gateway:`);
+          console.log(`    Old: ${currentUrl}`);
+          console.log(`    New: ${THIS_VARIANT_URL}\n`);
+        } else {
+          console.log('\n  Existing Plexor configuration detected');
+          console.log('  Your previous settings have been preserved.\n');
+        }
+      }
+    }
+
+    // Write back settings if any migration was applied
+    if (settingsChanged) {
+      const crypto = require('crypto');
+      const claudeDir = path.join(HOME_DIR, '.claude');
+      const tempId = crypto.randomBytes(8).toString('hex');
+      const tempPath = path.join(claudeDir, `.settings.${tempId}.tmp`);
+      fs.writeFileSync(tempPath, JSON.stringify(settings, null, 2), { mode: 0o600 });
+      fs.renameSync(tempPath, settingsPath);
+    }
+  } catch (e) {
+    // Ignore errors in detection - don't break install
+  }
+}
+
 // Default configuration for new installs
+// STAGING PACKAGE - uses staging API
 const DEFAULT_CONFIG = {
   version: 1,
   auth: {
@@ -84,13 +278,16 @@ const DEFAULT_CONFIG = {
   },
   settings: {
     enabled: true,
-    apiUrl: "https://api.plexor.dev",
+    apiUrl: "https://staging.api.plexor.dev",
     mode: "balanced",
     localCacheEnabled: true
   }
 };
 
 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();
@@ -101,6 +298,9 @@ function main() {
     // Create ~/.claude/plugins/plexor/commands/ for JS executors
     fs.mkdirSync(PLEXOR_PLUGINS_DIR, { recursive: true });
 
+    // Create ~/.claude/plugins/plexor/lib/ for shared modules
+    fs.mkdirSync(PLEXOR_LIB_DIR, { recursive: true });
+
     // Create ~/.plexor/ with secure permissions (owner only)
     fs.mkdirSync(PLEXOR_CONFIG_DIR, { recursive: true, mode: 0o700 });
 
@@ -161,6 +361,40 @@ function main() {
       jsInstalled.push(file);
     }
 
+    // Copy lib files to ~/.claude/plugins/plexor/lib/
+    // CRITICAL: These are required for commands to work
+    const libInstalled = [];
+    if (fs.existsSync(LIB_SOURCE)) {
+      const libFiles = fs.readdirSync(LIB_SOURCE).filter(f => f.endsWith('.js'));
+      if (libFiles.length === 0) {
+        console.warn('  ⚠ Warning: No lib files found in package. Commands may not work.');
+      }
+      for (const file of libFiles) {
+        try {
+          const src = path.join(LIB_SOURCE, file);
+          const dest = path.join(PLEXOR_LIB_DIR, file);
+          fs.copyFileSync(src, dest);
+          libInstalled.push(file);
+        } catch (err) {
+          console.error(`  ✗ Failed to copy lib/${file}: ${err.message}`);
+        }
+      }
+    } else {
+      console.error('  ✗ CRITICAL: lib/ directory not found in package.');
+      console.error('    Commands will fail. Please reinstall the package.');
+      console.error(`    Expected location: ${LIB_SOURCE}`);
+    }
+
+    // Verify critical lib file exists
+    const criticalLibFile = path.join(PLEXOR_LIB_DIR, 'settings-manager.js');
+    if (!fs.existsSync(criticalLibFile)) {
+      console.error('');
+      console.error('  ✗ CRITICAL: settings-manager.js was not installed.');
+      console.error('    This file is required for commands to work.');
+      console.error('    Try reinstalling: npm install @plexor-dev/claude-code-plugin-staging');
+      console.error('');
+    }
+
     // Fix file ownership when running with sudo
     // Files are created as root but should be owned by the original user
     if (targetUser) {
@@ -171,11 +405,6 @@ function main() {
       chownRecursive(PLEXOR_CONFIG_DIR, uid, gid);
     }
 
-    // Detect shell type
-    const shell = process.env.SHELL || '';
-    const isZsh = shell.includes('zsh');
-    const shellRc = isZsh ? '~/.zshrc' : '~/.bashrc';
-
     // Print success message with clear onboarding steps
     console.log('');
     console.log('  ╔═══════════════════════════════════════════════════════════════════╗');
@@ -190,38 +419,36 @@ function main() {
     }
     console.log(`  ✓ Installed ${installed.length} slash commands to ~/.claude/commands/`);
     if (jsInstalled.length > 0) {
-      console.log(`  ✓ Installed ${jsInstalled.length} executors to ~/.claude/plugins/plexor/`);
+      console.log(`  ✓ Installed ${jsInstalled.length} executors to ~/.claude/plugins/plexor/commands/`);
+    }
+    if (libInstalled.length > 0) {
+      console.log(`  ✓ Installed ${libInstalled.length} lib modules to ~/.claude/plugins/plexor/lib/`);
     }
     if (targetUser) {
       console.log(`  ✓ Set file ownership to ${targetUser.user}`);
     }
     console.log('');
 
-    // CRITICAL: Make the required step VERY obvious
     console.log('  ┌─────────────────────────────────────────────────────────────────┐');
-    console.log('  │  REQUIRED: Run this command to enable Plexor routing:          │');
+    console.log('  │  NEXT: Start Claude Code and run /plexor-setup                │');
     console.log('  └─────────────────────────────────────────────────────────────────┘');
     console.log('');
-    console.log('  For Claude MAX users (OAuth):');
-    console.log('');
-    console.log(`    echo 'export ANTHROPIC_BASE_URL="https://api.plexor.dev/gateway/anthropic"' >> ${shellRc}`);
-    console.log(`    source ${shellRc}`);
-    console.log('');
-    console.log('  For API key users (get key at https://plexor.dev/dashboard):');
-    console.log('');
-    console.log(`    echo 'export ANTHROPIC_BASE_URL="https://api.plexor.dev/gateway/anthropic"' >> ${shellRc}`);
-    console.log(`    echo 'export ANTHROPIC_API_KEY="plx_your_key_here"' >> ${shellRc}`);
-    console.log(`    source ${shellRc}`);
+    console.log('  /plexor-setup will:');
+    console.log('    1. Ask for your Plexor API key');
+    console.log('    2. Write ~/.plexor/config.json');
+    console.log('    3. Point Claude at the Plexor staging gateway');
+    console.log('    4. Preserve prior Claude auth for restore on logout');
+    console.log('    5. Verify Claude routing with a deterministic check');
     console.log('');
     console.log('  ┌─────────────────────────────────────────────────────────────────┐');
-    console.log('  │  Then start Claude Code and run: /plexor-status                │');
+    console.log('  │  No shell edits or Claude restart required after setup        │');
     console.log('  └─────────────────────────────────────────────────────────────────┘');
     console.log('');
     console.log('  Available commands:');
+    console.log('    /plexor-setup    - First-time setup wizard');
+    console.log('    /plexor-login    - Advanced/manual auth path');
     console.log('    /plexor-status   - Check connection and see savings');
-    console.log('    /plexor-mode     - Switch modes (eco/balanced/quality)');
-    console.log('    /plexor-login    - Authenticate with API key');
-    console.log('    /plexor-settings - View/modify settings');
+    console.log('    /plexor-enabled  - Enable/disable Plexor routing');
     console.log('');
     console.log('  Documentation: https://plexor.dev/docs');
     console.log('');

package/scripts/uninstall.js

@@ -1,67 +1,220 @@
 #!/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');
+const { execSync } = require('child_process');
 
-const COMMANDS_SOURCE = path.join(__dirname, '..', 'commands');
-const CLAUDE_COMMANDS_DIR = path.join(os.homedir(), '.claude', 'commands');
+/**
+ * Get the correct home directory for the process's effective user.
+ * Resolves via /etc/passwd to handle sudo and sudo -u correctly.
+ */
+function getHomeDir() {
+  if (os.platform() !== 'win32') {
+    try {
+      const uid = process.getuid();
+      const entry = execSync(`getent passwd ${uid}`, { encoding: 'utf8' }).trim();
+      const fields = entry.split(':');
+      if (fields.length >= 6 && fields[5]) {
+        return fields[5];
+      }
+    } catch {
+      // Fall through
+    }
+  }
+  const h = os.homedir();
+  if (h) return h;
+  return process.env.HOME || process.env.USERPROFILE || null;
+}
 
-function main() {
-  try {
-    // Get list of our command files
-    const files = fs.readdirSync(COMMANDS_SOURCE)
-      .filter(f => f.endsWith('.md'));
+const home = getHomeDir();
+if (!home) {
+  console.log('Warning: Could not determine home directory, skipping cleanup');
+  process.exit(0);
+}
+
+console.log('');
+console.log('  Plexor plugin cleanup...');
+console.log('');
+
+const results = {
+  routing: false,
+  commands: [],
+  restored: [],
+  pluginDir: false
+};
 
-    const removed = [];
-    const restored = [];
+function isManagedGatewayUrl(baseUrl = '') {
+  return (
+    baseUrl.includes('plexor') ||
+    baseUrl.includes('staging.api') ||
+    baseUrl.includes('localhost') ||
+    baseUrl.includes('127.0.0.1') ||
+    baseUrl.includes('ngrok') ||
+    baseUrl.includes('localtunnel')
+  );
+}
+
+function isPlexorApiKey(value = '') {
+  return typeof value === 'string' && value.startsWith('plx_');
+}
 
-    for (const file of files) {
-      const dest = path.join(CLAUDE_COMMANDS_DIR, file);
-      const backupPath = dest + '.backup';
+function clearPlexorRoutingEnv(env = {}) {
+  const hasManagedBaseUrl = isManagedGatewayUrl(env.ANTHROPIC_BASE_URL || '');
+  const hasPlexorAuthToken = isPlexorApiKey(env.ANTHROPIC_AUTH_TOKEN || '');
+  const hasPlexorApiKey = isPlexorApiKey(env.ANTHROPIC_API_KEY || '');
+
+  if (!hasManagedBaseUrl && !hasPlexorAuthToken && !hasPlexorApiKey) {
+    return false;
+  }
+
+  if (hasManagedBaseUrl) {
+    delete env.ANTHROPIC_BASE_URL;
+  }
+  if (hasPlexorAuthToken) {
+    delete env.ANTHROPIC_AUTH_TOKEN;
+  }
+  if (hasPlexorApiKey) {
+    delete env.ANTHROPIC_API_KEY;
+  }
+
+  if (!env.ANTHROPIC_API_KEY && env.PLEXOR_PREVIOUS_ANTHROPIC_API_KEY) {
+    env.ANTHROPIC_API_KEY = env.PLEXOR_PREVIOUS_ANTHROPIC_API_KEY;
+  }
+  if (!env.ANTHROPIC_AUTH_TOKEN && env.PLEXOR_PREVIOUS_ANTHROPIC_AUTH_TOKEN) {
+    env.ANTHROPIC_AUTH_TOKEN = env.PLEXOR_PREVIOUS_ANTHROPIC_AUTH_TOKEN;
+  }
+
+  delete env.PLEXOR_PREVIOUS_ANTHROPIC_API_KEY;
+  delete env.PLEXOR_PREVIOUS_ANTHROPIC_AUTH_TOKEN;
+
+  return true;
+}
 
-      if (fs.existsSync(dest)) {
-        fs.unlinkSync(dest);
-        removed.push(file.replace('.md', ''));
+// 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 routingChanged = clearPlexorRoutingEnv(settings.env);
+
+        // Clean up empty env block
+        if (Object.keys(settings.env).length === 0) {
+          delete settings.env;
+        }
+
+        if (routingChanged) {
+          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}`);
+}
+
+// 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'
+];
+
+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(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) {
-      console.log('');
-      console.log('  Plexor plugin uninstalled');
-      console.log('');
-      console.log('  Removed commands:');
-      removed.forEach(cmd => console.log(`    /${cmd}`));
-
-      if (restored.length > 0) {
-        console.log('');
-        console.log('  Restored from backup:');
-        restored.forEach(f => console.log(`    ${f}`));
-      }
+// 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}`);
+}
 
-      console.log('');
-      console.log('  Note: ~/.plexor/ config directory was preserved.');
-      console.log('  To remove it: rm -rf ~/.plexor');
-      console.log('');
-    }
+// Output results
+if (results.routing || results.commands.length > 0 || results.pluginDir) {
+  console.log('  Plexor plugin uninstalled');
+  console.log('');
+
+  if (results.routing) {
+    console.log('  Removed Plexor routing from Claude settings');
+    console.log('    (Claude Code now connects directly to Anthropic)');
+    console.log('');
+  }
+
+  if (results.commands.length > 0) {
+    console.log('  Removed commands:');
+    results.commands.forEach(cmd => console.log(`    /${cmd}`));
+    console.log('');
+  }
 
-  } catch (error) {
-    // Don't fail uninstall on errors - just warn
-    console.warn(`  Warning: Could not fully uninstall: ${error.message}`);
+  if (results.restored.length > 0) {
+    console.log('  Restored from backup:');
+    results.restored.forEach(f => console.log(`    ${f}`));
+    console.log('');
   }
+
+  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('');