@plexor-dev/claude-code-plugin 0.1.0-beta.23 → 0.1.0-beta.25

package/commands/plexor-enabled.js

@@ -3,11 +3,20 @@
 /**
  * Plexor Enabled Command
  * Enable or disable Plexor optimization proxy
+ *
+ * KEY FEATURE: When toggling on/off, automatically updates ~/.claude/settings.json
+ * to route or un-route ALL Claude Code sessions through Plexor gateway.
+ *
+ * THE DREAM: User just runs "/plexor-enabled off" to disable, "/plexor-enabled on" to enable.
+ * No manual environment variables or config updates required!
  */
 
 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');
+
 const CONFIG_PATH = path.join(process.env.HOME, '.plexor', 'config.json');
 const PLEXOR_DIR = path.join(process.env.HOME, '.plexor');
 
@@ -31,14 +40,23 @@ function main() {
   const args = process.argv.slice(2);
   const config = loadConfig();
   const currentEnabled = config.settings?.enabled ?? false;
+  const apiKey = config.auth?.api_key;
+
+  // Get current Claude settings.json routing status
+  const routingStatus = settingsManager.getRoutingStatus();
 
   // No args - show current status
   if (args.length === 0) {
     const status = currentEnabled ? '● Enabled' : '○ Disabled';
+    const routingStr = routingStatus.enabled ? '● Active' : '○ Inactive';
     console.log(`┌─────────────────────────────────────────────┐`);
     console.log(`│  Plexor Proxy Status                        │`);
     console.log(`├─────────────────────────────────────────────┤`);
-    console.log(`│  Status: ${status.padEnd(34)}│`);
+    console.log(`│  Plugin Config: ${status.padEnd(27)}│`);
+    console.log(`│  Claude Routing: ${routingStr.padEnd(26)}│`);
+    if (routingStatus.enabled) {
+    console.log(`│  Endpoint: ${(routingStatus.isStaging ? 'Staging' : 'Production').padEnd(32)}│`);
+    }
     console.log(`├─────────────────────────────────────────────┤`);
     console.log(`│  Usage:                                     │`);
     console.log(`│    /plexor-enabled true   - Enable proxy    │`);
@@ -62,21 +80,32 @@ function main() {
     process.exit(1);
   }
 
-  if (newEnabled === currentEnabled) {
-    const state = currentEnabled ? 'enabled' : 'disabled';
-    console.log(`Plexor proxy is already ${state}`);
-    return;
-  }
-
+  // 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;
+  if (newEnabled) {
+    // Enable routing - need API key from config
+    if (apiKey) {
+      const apiUrl = config.settings?.apiUrl || 'https://api.plexor.dev';
+      const useStaging = apiUrl.includes('staging');
+      routingUpdated = settingsManager.enablePlexorRouting(apiKey, { useStaging });
+    } else {
+      console.log('⚠ No API key found. Run /plexor-login first.');
+    }
+  } else {
+    // Disable routing - remove env vars from settings.json
+    routingUpdated = settingsManager.disablePlexorRouting();
+  }
+
   const newStatus = newEnabled ? '● Enabled' : '○ Disabled';
   const prevStatus = currentEnabled ? 'Enabled' : 'Disabled';
-  const message = newEnabled
-    ? 'All requests will be routed through Plexor'
-    : 'Requests will go directly to providers';
+  const routingMsg = routingUpdated
+    ? (newEnabled ? 'Claude Code now routes through Plexor' : 'Claude Code now connects directly')
+    : 'Manual routing update may be needed';
 
   console.log(`┌─────────────────────────────────────────────┐`);
   console.log(`│  ✓ Plexor Proxy Updated                     │`);
@@ -84,7 +113,8 @@ function main() {
   console.log(`│  Previous: ${prevStatus.padEnd(32)}│`);
   console.log(`│  New: ${newStatus.padEnd(37)}│`);
   console.log(`├─────────────────────────────────────────────┤`);
-  console.log(`│  ${message.padEnd(42)}│`);
+  console.log(`│  ${routingMsg.padEnd(42)}│`);
+  console.log(`│  Changes take effect immediately.           │`);
   console.log(`└─────────────────────────────────────────────┘`);
 }
 

package/commands/plexor-login.js

@@ -2,7 +2,10 @@
 
 /**
  * Plexor Login Command
- * Authenticate with Plexor API
+ * Authenticate with Plexor API and auto-configure Claude Code routing
+ *
+ * KEY FEATURE: After successful login, automatically configures ~/.claude/settings.json
+ * to route ALL Claude Code sessions through Plexor gateway.
  */
 
 const fs = require('fs');
@@ -10,6 +13,9 @@ 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');
+
 const CONFIG_PATH = path.join(process.env.HOME, '.plexor', 'config.json');
 const PLEXOR_DIR = path.join(process.env.HOME, '.plexor');
 const DEFAULT_API_URL = 'https://api.plexor.dev';
@@ -141,6 +147,12 @@ async function main() {
     config.settings.enabled = true;
     saveConfig(config);
 
+    // AUTO-CONFIGURE CLAUDE CODE ROUTING
+    // This is the key feature: automatically set ANTHROPIC_BASE_URL and ANTHROPIC_AUTH_TOKEN
+    // in ~/.claude/settings.json so ALL Claude Code sessions route through Plexor
+    const useStaging = apiUrl.includes('staging');
+    const routingEnabled = settingsManager.enablePlexorRouting(apiKey, { useStaging });
+
     const email = user.email || 'Unknown';
     const tier = user.tier?.name || 'Free';
 
@@ -150,7 +162,14 @@ async function main() {
     console.log(`│  Email: ${email.substring(0, 35).padEnd(35)}│`);
     console.log(`│  Tier: ${tier.padEnd(36)}│`);
     console.log(`├─────────────────────────────────────────────┤`);
-    console.log(`│  Plexor proxy is now enabled.               │`);
+    if (routingEnabled) {
+    console.log(`│  ✓ Claude Code routing: CONFIGURED          │`);
+    console.log(`│    All sessions now route through Plexor    │`);
+    } else {
+    console.log(`│  ⚠ Claude Code routing: MANUAL SETUP NEEDED │`);
+    console.log(`│    Set ANTHROPIC_BASE_URL in environment    │`);
+    }
+    console.log(`├─────────────────────────────────────────────┤`);
     console.log(`│  Run /plexor-status to see your stats.      │`);
     console.log(`└─────────────────────────────────────────────┘`);
   } catch (err) {

package/commands/plexor-setup.md

@@ -4,13 +4,16 @@ description: First-time setup wizard for Plexor with Claude Code (user)
 
 # Plexor Setup Wizard
 
-Guide users through first-time Plexor setup, handling both Claude MAX subscribers and API key users.
+Guide users through first-time Plexor setup. **No manual environment variable configuration required!**
+
+The plugin automatically configures `~/.claude/settings.json` to route all Claude Code sessions through Plexor.
 
 ## Steps
 
 **Step 1: Check if already configured**
 
 Use the Read tool to check if `~/.plexor/config.json` exists and has valid configuration.
+Also check `~/.claude/settings.json` for routing status.
 
 If configured, show:
 ```
@@ -21,9 +24,11 @@ Already configured!
 API URL: [apiUrl from config]
 Mode: [mode from config]
 Status: [Enabled/Disabled]
+Claude Routing: [Active/Inactive]
 
 Run /plexor-status to see your usage.
 Run /plexor-settings to modify configuration.
+Run /plexor-enabled off to disable routing.
 ```
 
 **Step 2: Ask about Claude MAX subscription**
@@ -40,11 +45,17 @@ Options:
 
 If user selected "Yes, I have Claude MAX":
 
-1. Use the Write tool to create `~/.plexor/config.json`:
+1. Ask for their Plexor API key:
+   "Please provide your Plexor API key (starts with 'plx_')."
+   "Get one at: https://plexor.dev/dashboard"
+   "Your MAX subscription will be used for Claude - the Plexor key is for tracking/optimization."
+
+2. Use the Write tool to create `~/.plexor/config.json`:
 ```json
 {
   "version": 1,
   "auth": {
+    "api_key": "[user's Plexor key]",
     "mode": "oauth_passthrough",
     "authenticated_at": "[current ISO timestamp]"
   },
@@ -57,24 +68,39 @@ If user selected "Yes, I have Claude MAX":
 }
 ```
 
-2. Show the user:
+3. Use the Write tool to update `~/.claude/settings.json` env block:
+```json
+{
+  "env": {
+    "ANTHROPIC_BASE_URL": "https://api.plexor.dev/gateway/anthropic",
+    "ANTHROPIC_AUTH_TOKEN": "[user's Plexor key]"
+  }
+}
+```
+Note: Preserve any existing settings, just add/update the env block.
+
+4. Show the user:
 ```
 Plexor Setup - Claude MAX User
 ==============================
-Your Claude MAX subscription will be used with Plexor optimization.
+Setup Complete! No manual configuration needed.
 
-Add this to your shell profile (~/.bashrc or ~/.zshrc):
-
-  export ANTHROPIC_BASE_URL="https://api.plexor.dev/gateway/anthropic"
-
-Then restart your terminal or run: source ~/.bashrc
+What was configured:
+- ~/.plexor/config.json (Plexor plugin settings)
+- ~/.claude/settings.json (automatic Claude Code routing)
 
 How it works:
-- Claude Code sends your OAuth token through Plexor
-- Plexor optimizes prompts and tracks usage
+- All Claude Code sessions now route through Plexor
+- Your MAX subscription OAuth token is passed through
 - You keep your MAX benefits ($0 cost, 20x rate limits)
+- Plexor optimizes prompts and tracks usage
+
+Commands:
+- /plexor-status    - See your usage stats
+- /plexor-enabled off - Temporarily disable Plexor
+- /plexor-enabled on  - Re-enable Plexor
 
-Run /plexor-status to verify setup.
+Changes take effect immediately in all Claude Code sessions!
 ```
 
 **Step 3B: API Key User Setup**
@@ -104,31 +130,43 @@ If user selected "No, I'll use a Plexor API key":
 }
 ```
 
-3. Show the user:
+3. Use the Write tool to update `~/.claude/settings.json` env block:
+```json
+{
+  "env": {
+    "ANTHROPIC_BASE_URL": "https://api.plexor.dev/gateway/anthropic",
+    "ANTHROPIC_AUTH_TOKEN": "[user's Plexor key]"
+  }
+}
+```
+Note: Preserve any existing settings, just add/update the env block.
+
+4. Show the user:
 ```
 Plexor Setup - API Key User
 ===========================
-Your Plexor API key has been configured.
-
-Add these lines to your shell profile (~/.bashrc or ~/.zshrc):
+Setup Complete! No manual configuration needed.
 
-  export ANTHROPIC_BASE_URL="https://api.plexor.dev/gateway/anthropic"
-  export ANTHROPIC_API_KEY="[their plexor key]"
-
-Then restart your terminal or run: source ~/.bashrc
+What was configured:
+- ~/.plexor/config.json (Plexor plugin settings)
+- ~/.claude/settings.json (automatic Claude Code routing)
 
 How it works:
-- Requests route through Plexor gateway
+- All Claude Code sessions now route through Plexor
 - Plexor picks the best provider (can save up to 90%)
-- Your Plexor key goes in ANTHROPIC_API_KEY (this is correct!)
+- Your usage is tracked and optimized
 
-Run /plexor-status to verify setup.
-```
+Commands:
+- /plexor-status    - See your usage and savings
+- /plexor-mode eco  - Maximize savings
+- /plexor-mode quality - Maximize quality
+- /plexor-enabled off - Temporarily disable Plexor
 
-**Step 4: Offer to auto-configure shell (optional)**
-
-Ask: "Would you like me to add this to your shell profile automatically?"
-
-If yes, use the Edit tool to append the export lines to `~/.bashrc` (or `~/.zshrc` if it exists).
+Changes take effect immediately in all Claude Code sessions!
+```
 
-**IMPORTANT**: After completing setup, STOP. Do not run additional commands.
+**IMPORTANT NOTES**:
+- The `~/.claude/settings.json` env block is the KEY mechanism that routes Claude Code through Plexor
+- ANTHROPIC_AUTH_TOKEN takes precedence over ANTHROPIC_API_KEY (use AUTH_TOKEN for the Plexor key)
+- Changes take effect immediately - no shell restart needed
+- After completing setup, STOP. Do not run additional commands.

package/lib/settings-manager.js

@@ -0,0 +1,238 @@
+/**
+ * Claude Code Settings Manager
+ *
+ * Manages ~/.claude/settings.json to enable automatic Plexor routing.
+ *
+ * KEY DISCOVERY: Claude Code reads settings.json at runtime and the `env` block
+ * overrides environment variables. This allows the plugin to redirect ALL Claude
+ * Code sessions to Plexor without users manually setting environment variables.
+ *
+ * Reference: Claude Code v2.0.1+ behavior - settings.json env takes precedence
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const CLAUDE_DIR = path.join(process.env.HOME || process.env.USERPROFILE || '', '.claude');
+const SETTINGS_PATH = path.join(CLAUDE_DIR, 'settings.json');
+
+// Plexor gateway endpoints
+const PLEXOR_STAGING_URL = 'https://staging.api.plexor.dev/gateway/anthropic';
+const PLEXOR_PROD_URL = 'https://api.plexor.dev/gateway/anthropic';
+
+class ClaudeSettingsManager {
+  constructor() {
+    this.settingsPath = SETTINGS_PATH;
+    this.claudeDir = CLAUDE_DIR;
+  }
+
+  /**
+   * Load current Claude settings
+   * @returns {Object} settings object or empty object if not found
+   */
+  load() {
+    try {
+      if (!fs.existsSync(this.settingsPath)) {
+        return {};
+      }
+      const data = fs.readFileSync(this.settingsPath, 'utf8');
+      return JSON.parse(data);
+    } catch (err) {
+      // Return empty object if file doesn't exist or parse error
+      return {};
+    }
+  }
+
+  /**
+   * Save Claude settings
+   * @param {Object} settings - settings object to save
+   * @returns {boolean} success status
+   */
+  save(settings) {
+    try {
+      // Ensure .claude directory exists
+      if (!fs.existsSync(this.claudeDir)) {
+        fs.mkdirSync(this.claudeDir, { recursive: true });
+      }
+
+      fs.writeFileSync(this.settingsPath, JSON.stringify(settings, null, 2));
+      return true;
+    } catch (err) {
+      console.error('Failed to save Claude settings:', err.message);
+      return false;
+    }
+  }
+
+  /**
+   * Enable Plexor routing by setting env vars in settings.json
+   *
+   * This is the KEY mechanism: setting ANTHROPIC_BASE_URL and ANTHROPIC_AUTH_TOKEN
+   * in the env block redirects ALL Claude Code sessions to Plexor automatically.
+   *
+   * @param {string} apiKey - Plexor API key (plx_*)
+   * @param {Object} options - { useStaging: boolean }
+   * @returns {boolean} success status
+   */
+  enablePlexorRouting(apiKey, options = {}) {
+    const { useStaging = true } = options;
+    const apiUrl = useStaging ? PLEXOR_STAGING_URL : PLEXOR_PROD_URL;
+
+    try {
+      const settings = this.load();
+
+      // Initialize env block if doesn't exist
+      if (!settings.env) {
+        settings.env = {};
+      }
+
+      // Set the magic environment variables
+      // ANTHROPIC_AUTH_TOKEN has higher precedence than ANTHROPIC_API_KEY
+      settings.env.ANTHROPIC_BASE_URL = apiUrl;
+      settings.env.ANTHROPIC_AUTH_TOKEN = apiKey;
+
+      const success = this.save(settings);
+
+      if (success) {
+        console.log(`✓ Plexor routing enabled`);
+        console.log(`  Base URL: ${apiUrl}`);
+        console.log(`  API Key: ${apiKey.substring(0, 12)}...`);
+        console.log(`\n  All Claude Code sessions will now route through Plexor.`);
+        console.log(`  Changes take effect immediately (no restart needed).`);
+      }
+
+      return success;
+    } catch (err) {
+      console.error('Failed to enable Plexor routing:', err.message);
+      return false;
+    }
+  }
+
+  /**
+   * Disable Plexor routing by removing env vars from settings.json
+   *
+   * This restores direct connection to Anthropic API.
+   *
+   * @returns {boolean} success status
+   */
+  disablePlexorRouting() {
+    try {
+      const settings = this.load();
+
+      if (!settings.env) {
+        console.log('Plexor routing is not currently enabled.');
+        return true;
+      }
+
+      // Remove Plexor-specific 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;
+      }
+
+      const success = this.save(settings);
+
+      if (success) {
+        console.log('✓ Plexor routing disabled');
+        console.log('  Claude Code will now connect directly to Anthropic.');
+        console.log('  Changes take effect immediately (no restart needed).');
+      }
+
+      return success;
+    } catch (err) {
+      console.error('Failed to disable Plexor routing:', err.message);
+      return false;
+    }
+  }
+
+  /**
+   * Get current routing status
+   * @returns {Object} { enabled: boolean, baseUrl: string|null, hasToken: boolean }
+   */
+  getRoutingStatus() {
+    try {
+      const settings = this.load();
+
+      const baseUrl = settings.env?.ANTHROPIC_BASE_URL || null;
+      const hasToken = !!settings.env?.ANTHROPIC_AUTH_TOKEN;
+
+      // Check if routing to Plexor
+      const isPlexorRouting = baseUrl && (
+        baseUrl.includes('plexor') ||
+        baseUrl.includes('staging.api')
+      );
+
+      return {
+        enabled: isPlexorRouting,
+        baseUrl,
+        hasToken,
+        isStaging: baseUrl?.includes('staging') || false,
+        tokenPreview: hasToken ? settings.env.ANTHROPIC_AUTH_TOKEN.substring(0, 12) + '...' : null
+      };
+    } catch {
+      return { enabled: false, baseUrl: null, hasToken: false };
+    }
+  }
+
+  /**
+   * Update just the API key without changing other settings
+   * @param {string} apiKey - new Plexor API key
+   * @returns {boolean} success status
+   */
+  updateApiKey(apiKey) {
+    try {
+      const settings = this.load();
+
+      if (!settings.env) {
+        settings.env = {};
+      }
+
+      settings.env.ANTHROPIC_AUTH_TOKEN = apiKey;
+      return this.save(settings);
+    } catch (err) {
+      console.error('Failed to update API key:', err.message);
+      return false;
+    }
+  }
+
+  /**
+   * Switch between staging and production
+   * @param {boolean} useStaging - true for staging, false for production
+   * @returns {boolean} success status
+   */
+  setEnvironment(useStaging) {
+    try {
+      const settings = this.load();
+
+      if (!settings.env?.ANTHROPIC_BASE_URL) {
+        console.log('Plexor routing is not enabled. Run /plexor-login first.');
+        return false;
+      }
+
+      settings.env.ANTHROPIC_BASE_URL = useStaging ? PLEXOR_STAGING_URL : PLEXOR_PROD_URL;
+
+      const success = this.save(settings);
+      if (success) {
+        console.log(`✓ Switched to ${useStaging ? 'staging' : 'production'} environment`);
+      }
+      return success;
+    } catch (err) {
+      console.error('Failed to switch environment:', err.message);
+      return false;
+    }
+  }
+}
+
+// Export singleton instance and class
+const settingsManager = new ClaudeSettingsManager();
+
+module.exports = {
+  ClaudeSettingsManager,
+  settingsManager,
+  CLAUDE_DIR,
+  SETTINGS_PATH,
+  PLEXOR_STAGING_URL,
+  PLEXOR_PROD_URL
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plexor-dev/claude-code-plugin",
-  "version": "0.1.0-beta.23",
+  "version": "0.1.0-beta.25",
   "description": "LLM cost optimization plugin for Claude Code - Save up to 90% on AI costs",
   "main": "lib/constants.js",
   "bin": {

package/scripts/postinstall.js

@@ -10,6 +10,7 @@
 const fs = require('fs');
 const path = require('path');
 const os = require('os');
+const { execSync } = require('child_process');
 
 /**
  * Get the correct home directory, accounting for sudo.
@@ -30,6 +31,43 @@ function getHomeDir() {
   return os.homedir();
 }
 
+/**
+ * Get uid/gid for the target user (handles sudo case).
+ * Returns null if not running with sudo or on Windows.
+ */
+function getTargetUserIds() {
+  const sudoUser = process.env.SUDO_USER;
+  if (!sudoUser || 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 };
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Recursively chown a directory and all its contents.
+ */
+function chownRecursive(dirPath, uid, gid) {
+  if (!fs.existsSync(dirPath)) return;
+
+  const stat = fs.statSync(dirPath);
+  fs.chownSync(dirPath, uid, gid);
+
+  if (stat.isDirectory()) {
+    const entries = fs.readdirSync(dirPath);
+    for (const entry of entries) {
+      chownRecursive(path.join(dirPath, entry), uid, gid);
+    }
+  }
+}
+
 const HOME_DIR = getHomeDir();
 const COMMANDS_SOURCE = path.join(__dirname, '..', 'commands');
 const CLAUDE_COMMANDS_DIR = path.join(HOME_DIR, '.claude', 'commands');
@@ -54,6 +92,9 @@ const DEFAULT_CONFIG = {
 
 function main() {
   try {
+    // Get target user info for chown (if running with sudo)
+    const targetUser = getTargetUserIds();
+
     // Create ~/.claude/commands/ if not exists
     fs.mkdirSync(CLAUDE_COMMANDS_DIR, { recursive: true });
 
@@ -120,6 +161,16 @@ function main() {
       jsInstalled.push(file);
     }
 
+    // Fix file ownership when running with sudo
+    // Files are created as root but should be owned by the original user
+    if (targetUser) {
+      const { uid, gid } = targetUser;
+      // Chown the .claude directory and all contents we created
+      chownRecursive(path.join(HOME_DIR, '.claude'), uid, gid);
+      // Chown the .plexor directory and all contents
+      chownRecursive(PLEXOR_CONFIG_DIR, uid, gid);
+    }
+
     // Detect shell type
     const shell = process.env.SHELL || '';
     const isZsh = shell.includes('zsh');
@@ -141,6 +192,9 @@ function main() {
     if (jsInstalled.length > 0) {
       console.log(`  ✓ Installed ${jsInstalled.length} executors to ~/.claude/plugins/plexor/`);
     }
+    if (targetUser) {
+      console.log(`  ✓ Set file ownership to ${targetUser.user}`);
+    }
     console.log('');
 
     // CRITICAL: Make the required step VERY obvious