@plexor-dev/claude-code-plugin-localhost 0.1.0-localhost.1

package/lib/settings-manager.js

@@ -0,0 +1,354 @@
+/**
+ * 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 os = require('os');
+const crypto = require('crypto');
+
+const CLAUDE_DIR = path.join(process.env.HOME || process.env.USERPROFILE || '', '.claude');
+const SETTINGS_PATH = path.join(CLAUDE_DIR, 'settings.json');
+const LOCK_TIMEOUT_MS = 5000; // 5 second lock timeout
+
+// Plexor gateway endpoints
+// LOCALHOST PACKAGE - both point to same localhost (no staging/prod distinction locally)
+const PLEXOR_STAGING_URL = 'http://localhost:8000/gateway/anthropic';
+const PLEXOR_PROD_URL = 'http://localhost:8000/gateway/anthropic';
+
+class ClaudeSettingsManager {
+  constructor() {
+    this.settingsPath = SETTINGS_PATH;
+    this.claudeDir = CLAUDE_DIR;
+  }
+
+  /**
+   * Load current Claude settings with integrity checking
+   * @returns {Object} settings object or empty object if not found/corrupted
+   */
+  load() {
+    try {
+      if (!fs.existsSync(this.settingsPath)) {
+        return {};
+      }
+      const data = fs.readFileSync(this.settingsPath, 'utf8');
+
+      // Check for empty file
+      if (!data || data.trim() === '') {
+        return {};
+      }
+
+      const parsed = JSON.parse(data);
+
+      // Basic schema validation - must be an object
+      if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {
+        const backupPath = this._backupCorruptedFile();
+        console.warn('');
+        console.warn('WARNING: Claude settings file has invalid format!');
+        if (backupPath) {
+          console.warn(`         Corrupted file backed up to: ${backupPath}`);
+        }
+        console.warn('         Using default settings. Your previous settings may need manual recovery.');
+        console.warn('');
+        return {};
+      }
+
+      return parsed;
+    } catch (err) {
+      if (err.code === 'ENOENT') {
+        return {};
+      }
+      // JSON parse error or corrupted file
+      if (err instanceof SyntaxError) {
+        const backupPath = this._backupCorruptedFile();
+        console.warn('');
+        console.warn('WARNING: Claude settings file is corrupted (invalid JSON)!');
+        if (backupPath) {
+          console.warn(`         Corrupted file backed up to: ${backupPath}`);
+        }
+        console.warn('         Using default settings. Your previous settings may need manual recovery.');
+        console.warn('');
+        return {};
+      }
+      // Permission error
+      if (err.code === 'EACCES' || err.code === 'EPERM') {
+        console.warn(`Warning: Cannot read ${this.settingsPath} (permission denied)`);
+        return {};
+      }
+      console.warn('Warning: Failed to load Claude settings:', err.message);
+      return {};
+    }
+  }
+
+  /**
+   * Backup a corrupted settings file with numbered suffix for debugging
+   * Creates settings.json.corrupted.1, .corrupted.2, etc. to preserve history
+   * @returns {string|null} path to backup file, or null if backup failed
+   */
+  _backupCorruptedFile() {
+    try {
+      if (fs.existsSync(this.settingsPath)) {
+        // Find next available numbered backup
+        let backupNum = 1;
+        let backupPath;
+        while (true) {
+          backupPath = `${this.settingsPath}.corrupted.${backupNum}`;
+          if (!fs.existsSync(backupPath)) {
+            break;
+          }
+          backupNum++;
+        }
+        fs.copyFileSync(this.settingsPath, backupPath);
+        return backupPath;
+      }
+    } catch {
+      // Ignore backup errors silently
+    }
+    return null;
+  }
+
+  /**
+   * Save Claude settings using atomic write pattern
+   * Prevents race conditions by writing to temp file then renaming
+   * @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 });
+      }
+
+      // Atomic write: write to temp file, then rename
+      // This prevents race conditions where concurrent writes corrupt the file
+      const tempId = crypto.randomBytes(8).toString('hex');
+      const tempPath = path.join(this.claudeDir, `.settings.${tempId}.tmp`);
+
+      // Write to temp file
+      const content = JSON.stringify(settings, null, 2);
+      fs.writeFileSync(tempPath, content, { mode: 0o600 });
+
+      // Atomic rename (on POSIX systems, rename is atomic)
+      fs.renameSync(tempPath, this.settingsPath);
+
+      return true;
+    } catch (err) {
+      // Clean error message for permission errors
+      if (err.code === 'EACCES' || err.code === 'EPERM') {
+        console.error(`Error: Cannot write to ${this.settingsPath}`);
+        console.error('       Check file permissions or run with appropriate access.');
+      } else {
+        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 = {}) {
+    // LOCALHOST PACKAGE - always uses localhost
+    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') ||
+        baseUrl.includes('localhost')
+      );
+
+      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 };
+    }
+  }
+
+  /**
+   * Detect partial routing state where URL points to Plexor but auth is missing/invalid
+   * This can cause confusing auth errors for users
+   * @returns {Object} { partial: boolean, issue: string|null }
+   */
+  detectPartialState() {
+    try {
+      const settings = this.load();
+      const baseUrl = settings.env?.ANTHROPIC_BASE_URL || '';
+      const authToken = settings.env?.ANTHROPIC_AUTH_TOKEN || '';
+      const isPlexorUrl = baseUrl.includes('plexor') || baseUrl.includes('staging.api') || baseUrl.includes('localhost');
+
+      if (isPlexorUrl && !authToken) {
+        return { partial: true, issue: 'Plexor URL set but no auth token' };
+      }
+      if (isPlexorUrl && !authToken.startsWith('plx_')) {
+        return { partial: true, issue: 'Plexor URL set but auth token is not a Plexor key' };
+      }
+      return { partial: false, issue: null };
+    } catch {
+      return { partial: false, issue: null };
+    }
+  }
+
+  /**
+   * Update just the API key without changing other settings
+   * @param {string} apiKey - new Plexor API key
+   * @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

@@ -0,0 +1,57 @@
+{
+  "name": "@plexor-dev/claude-code-plugin-localhost",
+  "version": "0.1.0-localhost.1",
+  "description": "LOCALHOST - LLM cost optimization plugin for Claude Code (local VM testing on port 8000)",
+  "main": "lib/constants.js",
+  "bin": {
+    "plexor-status": "./commands/plexor-status.js",
+    "plexor-enabled": "./commands/plexor-enabled.js",
+    "plexor-login": "./commands/plexor-login.js",
+    "plexor-logout": "./commands/plexor-logout.js",
+    "plexor-uninstall": "./commands/plexor-uninstall.js"
+  },
+  "scripts": {
+    "postinstall": "node scripts/postinstall.js",
+    "preuninstall": "node scripts/uninstall.js",
+    "test": "node --test"
+  },
+  "files": [
+    "commands/",
+    "hooks/",
+    "scripts/",
+    "lib/",
+    "README.md",
+    "LICENSE"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "claude",
+    "claude-code",
+    "llm",
+    "optimization",
+    "plexor",
+    "cost-savings",
+    "ai",
+    "anthropic"
+  ],
+  "author": "Plexor <hello@plexor.dev>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/plexor-dev/claude-code-plugin"
+  },
+  "bugs": {
+    "url": "https://github.com/plexor-dev/claude-code-plugin/issues"
+  },
+  "homepage": "https://plexor.dev",
+  "engines": {
+    "node": ">=16"
+  },
+  "os": [
+    "darwin",
+    "linux",
+    "win32"
+  ]
+}

package/scripts/plexor-cli.sh

@@ -0,0 +1,48 @@
+#!/bin/bash
+# Plexor CLI - Claude Code with intelligent optimization
+# This wrapper auto-enables hypervisor mode for direct gateway routing
+
+# Colors
+CYAN='\033[0;36m'
+GREEN='\033[0;32m'
+YELLOW='\033[0;33m'
+DIM='\033[2m'
+NC='\033[0m' # No Color
+
+CONFIG_FILE="$HOME/.plexor/config.json"
+
+# Auto-configure ANTHROPIC_BASE_URL if Plexor is enabled
+if [ -f "$CONFIG_FILE" ]; then
+    ENABLED=$(python3 -c "import json; c=json.load(open('$CONFIG_FILE')); print(c.get('settings',{}).get('enabled', False))" 2>/dev/null)
+    API_URL=$(python3 -c "import json; c=json.load(open('$CONFIG_FILE')); print(c.get('settings',{}).get('apiUrl', ''))" 2>/dev/null)
+    API_KEY=$(python3 -c "import json; c=json.load(open('$CONFIG_FILE')); print(c.get('auth',{}).get('api_key', ''))" 2>/dev/null)
+    MODE=$(python3 -c "import json; c=json.load(open('$CONFIG_FILE')); print(c.get('settings',{}).get('mode', 'balanced'))" 2>/dev/null)
+
+    if [ "$ENABLED" = "True" ] && [ -n "$API_URL" ] && [ -n "$API_KEY" ]; then
+        # Set ANTHROPIC_BASE_URL to Plexor gateway (hypervisor mode)
+        export ANTHROPIC_BASE_URL="${API_URL}/gateway/anthropic/v1"
+        export ANTHROPIC_API_KEY="$API_KEY"
+
+        # Show Plexor branding
+        echo -e "${CYAN}"
+        cat << 'EOF'
+    ____  __
+   / __ \/ /__  _  ______  _____
+  / /_/ / / _ \| |/_/ __ \/ ___/
+ / ____/ /  __/>  </ /_/ / /
+/_/   /_/\___/_/|_|\____/_/
+
+EOF
+        echo -e "${NC}"
+        echo -e "${GREEN}●${NC} Hypervisor Mode: ${GREEN}Active${NC}"
+        echo -e "   Gateway: ${DIM}${ANTHROPIC_BASE_URL}${NC}"
+        echo -e "   Mode: ${MODE}"
+        echo ""
+    else
+        echo -e "${YELLOW}○${NC} Plexor: ${DIM}Disabled${NC} (run /plexor-login to enable)"
+        echo ""
+    fi
+fi
+
+# Launch claude with all arguments passed through
+exec claude "$@"