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

package/README.md

@@ -32,14 +32,11 @@ This installs slash commands to `~/.claude/commands/`.
 
 | Command | Description |
 |---------|-------------|
-| `/plexor-login` | Authenticate with Plexor |
-| `/plexor-status` | View usage stats and savings |
-| `/plexor-mode` | Set optimization mode (eco/balanced/quality/passthrough) |
-| `/plexor-provider` | Force specific provider (auto/claude/deepseek/mistral/gemini) |
-| `/plexor-config` | Quick config (enable/disable/cache/reset) |
-| `/plexor-settings` | Advanced settings (API URL, mode, provider) |
-| `/plexor-enabled` | Enable/disable the proxy |
+| `/plexor-setup` | First-time setup wizard |
+| `/plexor-login` | Authenticate with Plexor API key |
 | `/plexor-logout` | Sign out and clear credentials |
+| `/plexor-status` | View usage stats and savings |
+| `/plexor-enabled` | Enable/disable Plexor routing |
 
 ## How It Works
 

package/commands/plexor-enabled.js

@@ -14,26 +14,108 @@
 const fs = require('fs');
 const path = require('path');
 
-// Import settings manager for automatic Claude Code configuration
-const { settingsManager, PLEXOR_STAGING_URL, PLEXOR_PROD_URL } = require('../lib/settings-manager');
+// Import centralized constants with HOME directory validation
+const { PLEXOR_DIR, CONFIG_PATH } = require('../lib/constants');
 
-const CONFIG_PATH = path.join(process.env.HOME, '.plexor', 'config.json');
-const PLEXOR_DIR = path.join(process.env.HOME, '.plexor');
+// Import settings manager with error handling for missing lib
+let settingsManager, PLEXOR_STAGING_URL, PLEXOR_PROD_URL;
+try {
+  const lib = require('../lib/settings-manager');
+  settingsManager = lib.settingsManager;
+  PLEXOR_STAGING_URL = lib.PLEXOR_STAGING_URL;
+  PLEXOR_PROD_URL = lib.PLEXOR_PROD_URL;
+} catch (err) {
+  if (err.code === 'MODULE_NOT_FOUND') {
+    console.error('Error: Plexor plugin files are missing or corrupted.');
+    console.error('       Please reinstall: npm install @plexor-dev/claude-code-plugin-staging');
+    process.exit(1);
+  }
+  throw err;
+}
 
 function loadConfig() {
   try {
+    if (!fs.existsSync(CONFIG_PATH)) {
+      return { version: 1, auth: {}, settings: {} };
+    }
     const data = fs.readFileSync(CONFIG_PATH, 'utf8');
-    return JSON.parse(data);
-  } catch {
+    if (!data || data.trim() === '') {
+      return { version: 1, auth: {}, settings: {} };
+    }
+    const config = JSON.parse(data);
+    if (typeof config !== 'object' || config === null) {
+      console.warn('Warning: Config file has invalid format, using defaults');
+      return { version: 1, auth: {}, settings: {} };
+    }
+    return config;
+  } catch (err) {
+    if (err instanceof SyntaxError) {
+      console.warn('Warning: Config file is corrupted, using defaults');
+      // Backup corrupted file
+      try {
+        fs.copyFileSync(CONFIG_PATH, CONFIG_PATH + '.corrupted');
+      } catch { /* ignore */ }
+    }
     return { version: 1, auth: {}, settings: {} };
   }
 }
 
 function saveConfig(config) {
-  if (!fs.existsSync(PLEXOR_DIR)) {
-    fs.mkdirSync(PLEXOR_DIR, { recursive: true, mode: 0o700 });
+  try {
+    if (!fs.existsSync(PLEXOR_DIR)) {
+      fs.mkdirSync(PLEXOR_DIR, { recursive: true, mode: 0o700 });
+    }
+
+    // Atomic write: write to temp file, then rename
+    const crypto = require('crypto');
+    const tempId = crypto.randomBytes(8).toString('hex');
+    const tempPath = path.join(PLEXOR_DIR, `.config.${tempId}.tmp`);
+
+    fs.writeFileSync(tempPath, JSON.stringify(config, null, 2), { mode: 0o600 });
+    fs.renameSync(tempPath, CONFIG_PATH);
+    return true;
+  } catch (err) {
+    if (err.code === 'EACCES' || err.code === 'EPERM') {
+      console.error(`Error: Cannot write to ~/.plexor/config.json`);
+      console.error('       Check file permissions or run with appropriate access.');
+    } else {
+      console.error('Failed to save config:', err.message);
+    }
+    return false;
   }
-  fs.writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2), { mode: 0o600 });
+}
+
+/**
+ * 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;
+}
+
+/**
+ * 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() {
@@ -49,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(`├─────────────────────────────────────────────┤`);
@@ -57,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    │`);
@@ -80,26 +172,93 @@ function main() {
     process.exit(1);
   }
 
-  // Update Plexor plugin config
-  config.settings = config.settings || {};
-  config.settings.enabled = newEnabled;
-  saveConfig(config);
-
   // THE KEY FEATURE: Update Claude Code settings.json routing
   let routingUpdated = false;
+  let missingApiKey = false;
+  let invalidApiKey = false;
+
   if (newEnabled) {
-    // Enable routing - need API key from config
-    if (apiKey) {
+    // Enable routing - need valid API key from config
+    if (!apiKey) {
+      missingApiKey = true;
+    } else if (!isValidApiKeyFormat(apiKey)) {
+      invalidApiKey = true;
+    } else {
+      // Update Plexor plugin config first
+      config.settings = config.settings || {};
+      config.settings.enabled = newEnabled;
+      if (!saveConfig(config)) {
+        process.exit(1);
+      }
+
       // STAGING PACKAGE - uses staging API
       const apiUrl = config.settings?.apiUrl || 'https://staging.api.plexor.dev';
       const useStaging = apiUrl.includes('staging');
       routingUpdated = settingsManager.enablePlexorRouting(apiKey, { useStaging });
-    } else {
-      console.log('⚠ No API key found. Run /plexor-login first.');
+
+      // 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
+    config.settings = config.settings || {};
+    config.settings.enabled = newEnabled;
+    if (!saveConfig(config)) {
+      process.exit(1);
+    }
+
     // 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
+  if (missingApiKey) {
+    console.log(`┌─────────────────────────────────────────────┐`);
+    console.log(`│  ✗ Cannot Enable Plexor                     │`);
+    console.log(`├─────────────────────────────────────────────┤`);
+    console.log(`│  No API key configured.                     │`);
+    console.log(`│  Run /plexor-login <api-key> first.         │`);
+    console.log(`├─────────────────────────────────────────────┤`);
+    console.log(`│  Get your API key at:                       │`);
+    console.log(`│  https://plexor.dev/dashboard/api-keys      │`);
+    console.log(`└─────────────────────────────────────────────┘`);
+    process.exit(1);
+  }
+
+  // Show error if API key format is invalid
+  if (invalidApiKey) {
+    console.log(`┌─────────────────────────────────────────────┐`);
+    console.log(`│  ✗ Cannot Enable Plexor                     │`);
+    console.log(`├─────────────────────────────────────────────┤`);
+    console.log(`│  Invalid API key format in config.          │`);
+    console.log(`│  Keys must start with "plx_" (20+ chars).   │`);
+    console.log(`├─────────────────────────────────────────────┤`);
+    console.log(`│  Run /plexor-login <api-key> to fix.        │`);
+    console.log(`└─────────────────────────────────────────────┘`);
+    process.exit(1);
   }
 
   const newStatus = newEnabled ? '● Enabled' : '○ Disabled';

package/commands/plexor-enabled.md

@@ -4,25 +4,45 @@ description: Enable or disable Plexor proxy (routes all traffic through Plexor A
 
 # Plexor Enabled
 
-Run this command to view or toggle the Plexor proxy:
+Toggle Plexor proxy on or off.
+
+## If argument provided (on/off/true/false)
+
+Run the command directly with the argument:
 
 ```bash
-node ~/.claude/plugins/plexor/commands/plexor-enabled.js
+node ~/.claude/plugins/plexor/commands/plexor-enabled.js <argument>
 ```
 
-To enable or disable, pass an argument:
+Then display the output and STOP.
+
+## If NO argument provided
+
+**Step 1**: First get current status by running:
 
 ```bash
-node ~/.claude/plugins/plexor/commands/plexor-enabled.js true
-node ~/.claude/plugins/plexor/commands/plexor-enabled.js false
+node ~/.claude/plugins/plexor/commands/plexor-enabled.js
 ```
 
-Use the Bash tool to execute this command.
+**Step 2**: Based on the output, use AskUserQuestion to present options:
+
+If currently ENABLED (shows "● Enabled" or "● Active"):
+- Question: "Plexor is currently ON. What would you like to do?"
+- Header: "Plexor"
+- Options:
+  1. **Turn OFF** - Disable Plexor routing (connect directly to Anthropic)
+  2. **Keep ON** - No change
+
+If currently DISABLED (shows "○ Disabled" or "○ Inactive"):
+- Question: "Plexor is currently OFF. What would you like to do?"
+- Header: "Plexor"
+- Options:
+  1. **Turn ON** - Enable Plexor routing
+  2. **Keep OFF** - No change
 
-**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
+**Step 3**: Based on user selection:
+- If "Turn OFF" selected: Run `node ~/.claude/plugins/plexor/commands/plexor-enabled.js false`
+- If "Turn ON" selected: Run `node ~/.claude/plugins/plexor/commands/plexor-enabled.js true`
+- If "Keep" selected: Do nothing, just confirm current state
 
-The command output is the complete response. Simply show the output and wait for the user's next input.
+**IMPORTANT**: After completing, STOP. Do not read files, explore codebase, or run additional commands.

package/commands/plexor-login.js

@@ -13,28 +13,67 @@ const path = require('path');
 const https = require('https');
 const http = require('http');
 
-// Import settings manager for automatic Claude Code configuration
-const { settingsManager } = require('../lib/settings-manager');
+// Import centralized constants with HOME directory validation
+const { PLEXOR_DIR, CONFIG_PATH, DEFAULT_API_URL } = require('../lib/constants');
 
-const CONFIG_PATH = path.join(process.env.HOME, '.plexor', 'config.json');
-const PLEXOR_DIR = path.join(process.env.HOME, '.plexor');
-// STAGING PACKAGE - uses staging API
-const DEFAULT_API_URL = 'https://staging.api.plexor.dev';
+// Import settings manager with error handling for missing lib
+let settingsManager;
+try {
+  settingsManager = require('../lib/settings-manager').settingsManager;
+} catch (err) {
+  if (err.code === 'MODULE_NOT_FOUND') {
+    console.error('Error: Plexor plugin files are missing or corrupted.');
+    console.error('       Please reinstall: npm install @plexor-dev/claude-code-plugin-staging');
+    process.exit(1);
+  }
+  throw err;
+}
 
 function loadConfig() {
   try {
+    if (!fs.existsSync(CONFIG_PATH)) {
+      return { version: 1, auth: {}, settings: {} };
+    }
     const data = fs.readFileSync(CONFIG_PATH, 'utf8');
-    return JSON.parse(data);
-  } catch {
+    if (!data || data.trim() === '') {
+      return { version: 1, auth: {}, settings: {} };
+    }
+    const config = JSON.parse(data);
+    if (typeof config !== 'object' || config === null) {
+      return { version: 1, auth: {}, settings: {} };
+    }
+    return config;
+  } catch (err) {
+    if (err instanceof SyntaxError) {
+      console.warn('Warning: Config file is corrupted, will be overwritten');
+    }
     return { version: 1, auth: {}, settings: {} };
   }
 }
 
 function saveConfig(config) {
-  if (!fs.existsSync(PLEXOR_DIR)) {
-    fs.mkdirSync(PLEXOR_DIR, { recursive: true, mode: 0o700 });
+  try {
+    if (!fs.existsSync(PLEXOR_DIR)) {
+      fs.mkdirSync(PLEXOR_DIR, { recursive: true, mode: 0o700 });
+    }
+
+    // Atomic write: write to temp file, then rename
+    const crypto = require('crypto');
+    const tempId = crypto.randomBytes(8).toString('hex');
+    const tempPath = path.join(PLEXOR_DIR, `.config.${tempId}.tmp`);
+
+    fs.writeFileSync(tempPath, JSON.stringify(config, null, 2), { mode: 0o600 });
+    fs.renameSync(tempPath, CONFIG_PATH);
+    return true;
+  } catch (err) {
+    if (err.code === 'EACCES' || err.code === 'EPERM') {
+      console.error('Error: Cannot write to ~/.plexor/config.json');
+      console.error('       Check file permissions or run with appropriate access.');
+    } else {
+      console.error('Failed to save config:', err.message);
+    }
+    return false;
   }
-  fs.writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2), { mode: 0o600 });
 }
 
 function validateApiKey(apiUrl, apiKey) {
@@ -80,23 +119,62 @@ function validateApiKey(apiUrl, apiKey) {
   });
 }
 
-async function promptForApiKey() {
-  const rl = readline.createInterface({
-    input: process.stdin,
-    output: process.stdout
-  });
+/**
+ * Read API key from stdin (for piped input)
+ * @returns {Promise<string>} The API key read from stdin
+ */
+function readFromStdin() {
+  return new Promise((resolve, reject) => {
+    let data = '';
+    const timeout = setTimeout(() => {
+      reject(new Error('Timeout reading from stdin'));
+    }, 5000);
 
-  return new Promise((resolve) => {
-    rl.question('Enter your Plexor API key: ', (answer) => {
-      rl.close();
-      resolve(answer.trim());
+    process.stdin.setEncoding('utf8');
+    process.stdin.on('data', (chunk) => {
+      data += chunk;
+    });
+    process.stdin.on('end', () => {
+      clearTimeout(timeout);
+      resolve(data.trim());
+    });
+    process.stdin.on('error', (err) => {
+      clearTimeout(timeout);
+      reject(err);
     });
+    process.stdin.resume();
   });
 }
 
 async function main() {
   const args = process.argv.slice(2);
-  let apiKey = args[0];
+  let apiKey = null;
+  let keySource = null;
+
+  // SECURITY FIX: Check for API key in order of preference
+  // 1. Environment variable (most secure for scripts/CI)
+  // 2. Stdin pipe (secure for interactive use)
+  // 3. Command line argument (warns about security risk)
+
+  // Check environment variable first (most secure)
+  if (process.env.PLEXOR_API_KEY) {
+    apiKey = process.env.PLEXOR_API_KEY;
+    keySource = 'environment';
+  }
+  // Check if stdin has data (piped input)
+  else if (!process.stdin.isTTY && args.length === 0) {
+    try {
+      apiKey = await readFromStdin();
+      keySource = 'stdin';
+    } catch {
+      // Stdin read failed, continue to check args
+    }
+  }
+  // Check command line argument (least secure - shows in ps)
+  else if (args[0]) {
+    apiKey = args[0];
+    keySource = 'argument';
+  }
 
   // Check for existing login
   const config = loadConfig();
@@ -108,14 +186,14 @@ async function main() {
     console.log(`├─────────────────────────────────────────────┤`);
     console.log(`│  API Key: ${(existingKey.substring(0, 8) + '...').padEnd(33)}│`);
     console.log(`│  To re-login, provide a new key:            │`);
-    console.log(`│    /plexor-login <api-key>                  │`);
+    console.log(`│    echo $PLEXOR_API_KEY | /plexor-login     │`);
     console.log(`│  To logout:                                 │`);
     console.log(`│    /plexor-logout                           │`);
     console.log(`└─────────────────────────────────────────────┘`);
     return;
   }
 
-  // If no key provided, prompt for it
+  // If no key provided, show secure usage options
   if (!apiKey) {
     console.log(`┌─────────────────────────────────────────────┐`);
     console.log(`│  Plexor Login                               │`);
@@ -123,11 +201,25 @@ async function main() {
     console.log(`│  Get your API key at:                       │`);
     console.log(`│  https://plexor.dev/dashboard/api-keys      │`);
     console.log(`├─────────────────────────────────────────────┤`);
-    console.log(`│  Usage: /plexor-login <api-key>             │`);
+    console.log(`│  Secure usage (recommended):                │`);
+    console.log(`│    echo "plx_..." | /plexor-login           │`);
+    console.log(`│    PLEXOR_API_KEY=plx_... /plexor-login     │`);
+    console.log(`├─────────────────────────────────────────────┤`);
+    console.log(`│  Direct usage (visible in ps):              │`);
+    console.log(`│    /plexor-login <api-key>                  │`);
     console.log(`└─────────────────────────────────────────────┘`);
     return;
   }
 
+  // Warn if API key was passed as command line argument
+  if (keySource === 'argument') {
+    console.log(`⚠ Security note: API key passed as argument is visible in`);
+    console.log(`  process list (ps aux). For better security, use:`);
+    console.log(`    echo "plx_..." | /plexor-login`);
+    console.log(`    PLEXOR_API_KEY=plx_... /plexor-login`);
+    console.log('');
+  }
+
   // Validate key format
   if (!apiKey.startsWith('plx_') || apiKey.length < 20) {
     console.error(`Error: Invalid API key format`);
@@ -146,7 +238,9 @@ async function main() {
     config.auth.api_key = apiKey;
     config.settings = config.settings || {};
     config.settings.enabled = true;
-    saveConfig(config);
+    if (!saveConfig(config)) {
+      process.exit(1);
+    }
 
     // AUTO-CONFIGURE CLAUDE CODE ROUTING
     // This is the key feature: automatically set ANTHROPIC_BASE_URL and ANTHROPIC_AUTH_TOKEN

package/commands/plexor-logout.js

@@ -8,25 +8,68 @@
 const fs = require('fs');
 const path = require('path');
 
-const PLEXOR_DIR = path.join(process.env.HOME, '.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');
+// Import centralized constants with HOME directory validation
+const { PLEXOR_DIR, CONFIG_PATH, SESSION_PATH, CACHE_PATH } = require('../lib/constants');
+
+// Import settings manager for Claude Code routing cleanup
+let settingsManager;
+try {
+  const lib = require('../lib/settings-manager');
+  settingsManager = lib.settingsManager;
+} catch (err) {
+  if (err.code === 'MODULE_NOT_FOUND') {
+    console.error('Error: Plexor plugin files are missing or corrupted.');
+    console.error('       Please reinstall: npm install @plexor-dev/claude-code-plugin-staging');
+    process.exit(1);
+  }
+  throw err;
+}
 
 function loadConfig() {
   try {
+    if (!fs.existsSync(CONFIG_PATH)) {
+      return null;
+    }
     const data = fs.readFileSync(CONFIG_PATH, 'utf8');
-    return JSON.parse(data);
-  } catch {
+    if (!data || data.trim() === '') {
+      return null;
+    }
+    const config = JSON.parse(data);
+    if (typeof config !== 'object' || config === null) {
+      return null;
+    }
+    return config;
+  } catch (err) {
+    if (err instanceof SyntaxError) {
+      console.warn('Warning: Config file is corrupted');
+    }
     return null;
   }
 }
 
 function saveConfig(config) {
-  if (!fs.existsSync(PLEXOR_DIR)) {
-    fs.mkdirSync(PLEXOR_DIR, { recursive: true, mode: 0o700 });
+  try {
+    if (!fs.existsSync(PLEXOR_DIR)) {
+      fs.mkdirSync(PLEXOR_DIR, { recursive: true, mode: 0o700 });
+    }
+
+    // Atomic write: write to temp file, then rename
+    const crypto = require('crypto');
+    const tempId = crypto.randomBytes(8).toString('hex');
+    const tempPath = path.join(PLEXOR_DIR, `.config.${tempId}.tmp`);
+
+    fs.writeFileSync(tempPath, JSON.stringify(config, null, 2), { mode: 0o600 });
+    fs.renameSync(tempPath, CONFIG_PATH);
+    return true;
+  } catch (err) {
+    if (err.code === 'EACCES' || err.code === 'EPERM') {
+      console.error('Error: Cannot write to ~/.plexor/config.json');
+      console.error('       Check file permissions or run with appropriate access.');
+    } else {
+      console.error('Failed to save config:', err.message);
+    }
+    return false;
   }
-  fs.writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2), { mode: 0o600 });
 }
 
 function deleteFile(filePath) {
@@ -61,7 +104,14 @@ function main() {
   delete config.auth.api_key;
   config.settings = config.settings || {};
   config.settings.enabled = false;
-  saveConfig(config);
+  if (!saveConfig(config)) {
+    process.exit(1);
+  }
+
+  // CRITICAL FIX: Disable Claude Code routing in ~/.claude/settings.json
+  // This removes ANTHROPIC_BASE_URL and ANTHROPIC_AUTH_TOKEN so Claude Code
+  // no longer tries to route through Plexor with removed credentials
+  const routingDisabled = settingsManager.disablePlexorRouting();
 
   // Clear session
   deleteFile(SESSION_PATH);
@@ -76,12 +126,13 @@ function main() {
   console.log(`│  ✓ Logged Out                               │`);
   console.log(`├─────────────────────────────────────────────┤`);
   console.log(`│  ✓ API key removed                          │`);
-  console.log(`│  ✓ Plexor proxy disabled                    │`);
+  console.log(`│  ${routingDisabled ? '✓' : '○'} Claude Code routing disabled             │`);
   console.log(`│  ✓ Session cleared                          │`);
   if (clearCache) {
     console.log(`│  ${cacheCleared ? '✓' : '○'} Cache cleared                            │`);
   }
   console.log(`├─────────────────────────────────────────────┤`);
+  console.log(`│  Claude Code now connects directly.         │`);
   console.log(`│  Run /plexor-login to re-authenticate.      │`);
   if (!clearCache) {
     console.log(`│  Use --clear-cache to also clear cache.     │`);