@plexor-dev/claude-code-plugin-localhost 0.1.0-beta.12 → 0.1.0-beta.13

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plexor-dev/claude-code-plugin-localhost",
-  "version": "0.1.0-beta.12",
+  "version": "0.1.0-beta.13",
   "description": "LOCALHOST - LLM cost optimization plugin for Claude Code (local dev testing via tunnel)",
   "main": "lib/constants.js",
   "bin": {

package/lib/cache.js

@@ -1,107 +0,0 @@
-/**
- * Plexor Local Cache
- *
- * Stores request/response metadata for cache hit detection.
- */
-
-const fs = require('fs');
-const { CACHE_PATH, PLEXOR_DIR } = require('./constants');
-
-const CACHE_TTL_MS = 5 * 60 * 1000; // 5 minutes
-
-class LocalCache {
-  constructor() {
-    this.cachePath = CACHE_PATH;
-    this.cache = this.load();
-  }
-
-  load() {
-    try {
-      const data = fs.readFileSync(this.cachePath, 'utf8');
-      return JSON.parse(data);
-    } catch {
-      return { entries: {}, metadata: {} };
-    }
-  }
-
-  save() {
-    try {
-      if (!fs.existsSync(PLEXOR_DIR)) {
-        fs.mkdirSync(PLEXOR_DIR, { recursive: true });
-      }
-      fs.writeFileSync(this.cachePath, JSON.stringify(this.cache, null, 2));
-      return true;
-    } catch {
-      return false;
-    }
-  }
-
-  generateKey(messages) {
-    const str = JSON.stringify(messages);
-    let hash = 0;
-    for (let i = 0; i < str.length; i++) {
-      hash = ((hash << 5) - hash) + str.charCodeAt(i);
-      hash |= 0;
-    }
-    return `cache_${Math.abs(hash)}`;
-  }
-
-  async get(key) {
-    const entry = this.cache.entries[key];
-    if (!entry) {
-      return null;
-    }
-
-    // Check if expired
-    if (Date.now() - entry.timestamp > CACHE_TTL_MS) {
-      delete this.cache.entries[key];
-      this.save();
-      return null;
-    }
-
-    return entry.value;
-  }
-
-  async set(key, value) {
-    this.cache.entries[key] = {
-      value,
-      timestamp: Date.now()
-    };
-    this.cleanup();
-    this.save();
-  }
-
-  async getMetadata(requestId) {
-    return this.cache.metadata[requestId] || null;
-  }
-
-  async setMetadata(requestId, metadata) {
-    this.cache.metadata[requestId] = {
-      ...metadata,
-      timestamp: Date.now()
-    };
-    this.cleanupMetadata();
-    this.save();
-  }
-
-  cleanup() {
-    const now = Date.now();
-    for (const key of Object.keys(this.cache.entries)) {
-      if (now - this.cache.entries[key].timestamp > CACHE_TTL_MS) {
-        delete this.cache.entries[key];
-      }
-    }
-  }
-
-  cleanupMetadata() {
-    const now = Date.now();
-    const METADATA_TTL_MS = 60 * 60 * 1000; // 1 hour
-    for (const key of Object.keys(this.cache.metadata)) {
-      if (now - this.cache.metadata[key].timestamp > METADATA_TTL_MS) {
-        delete this.cache.metadata[key];
-      }
-    }
-  }
-}
-
-module.exports = LocalCache;

package/lib/config.js

@@ -1,67 +0,0 @@
-/**
- * Plexor Configuration Manager
- */
-
-const fs = require('fs');
-const path = require('path');
-const { CONFIG_PATH, PLEXOR_DIR, DEFAULT_API_URL, DEFAULT_TIMEOUT } = require('./constants');
-
-class ConfigManager {
-  constructor() {
-    this.configPath = CONFIG_PATH;
-  }
-
-  async load() {
-    try {
-      const data = fs.readFileSync(this.configPath, 'utf8');
-      const cfg = JSON.parse(data);
-      return {
-        enabled: cfg.settings?.enabled ?? false,
-        apiKey: cfg.auth?.api_key || '',
-        apiUrl: cfg.settings?.apiUrl || DEFAULT_API_URL,
-        timeout: cfg.settings?.timeout || DEFAULT_TIMEOUT,
-        localCacheEnabled: cfg.settings?.localCacheEnabled ?? false,
-        mode: cfg.settings?.mode || 'balanced',
-        preferredProvider: cfg.settings?.preferred_provider || 'auto'
-      };
-    } catch {
-      return { enabled: false, apiKey: '', apiUrl: DEFAULT_API_URL };
-    }
-  }
-
-  async save(config) {
-    try {
-      if (!fs.existsSync(PLEXOR_DIR)) {
-        fs.mkdirSync(PLEXOR_DIR, { recursive: true });
-      }
-
-      let existing = {};
-      try {
-        const data = fs.readFileSync(this.configPath, 'utf8');
-        existing = JSON.parse(data);
-      } catch {
-        existing = { version: 1, auth: {}, settings: {} };
-      }
-
-      const updated = {
-        ...existing,
-        settings: {
-          ...existing.settings,
-          enabled: config.enabled ?? existing.settings?.enabled,
-          apiUrl: config.apiUrl ?? existing.settings?.apiUrl,
-          timeout: config.timeout ?? existing.settings?.timeout,
-          localCacheEnabled: config.localCacheEnabled ?? existing.settings?.localCacheEnabled,
-          mode: config.mode ?? existing.settings?.mode,
-          preferred_provider: config.preferredProvider ?? existing.settings?.preferred_provider
-        }
-      };
-
-      fs.writeFileSync(this.configPath, JSON.stringify(updated, null, 2), { mode: 0o600 });
-      return true;
-    } catch {
-      return false;
-    }
-  }
-}
-
-module.exports = ConfigManager;

package/lib/constants.js

@@ -1,44 +0,0 @@
-/**
- * Plexor Plugin Constants
- */
-
-const path = require('path');
-
-/**
- * Get the user's home directory with proper validation
- * @returns {string} Home directory path
- * @throws {Error} If HOME is not set or empty
- */
-function getHomeDir() {
-  const home = process.env.HOME || process.env.USERPROFILE;
-  if (!home || home.trim() === '') {
-    console.error('Error: HOME environment variable is not set.');
-    console.error('       Please set HOME to your user directory before running Plexor commands.');
-    process.exit(1);
-  }
-  return home;
-}
-
-const HOME_DIR = getHomeDir();
-const PLEXOR_DIR = path.join(HOME_DIR, '.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');
-
-const SESSION_TIMEOUT_MS = 30 * 60 * 1000; // 30 minutes
-
-// STAGING PACKAGE - uses staging API
-const DEFAULT_API_URL = 'LOCALHOST_TUNNEL_URL';
-const DEFAULT_TIMEOUT = 5000;
-
-module.exports = {
-  getHomeDir,
-  HOME_DIR,
-  PLEXOR_DIR,
-  CONFIG_PATH,
-  SESSION_PATH,
-  CACHE_PATH,
-  SESSION_TIMEOUT_MS,
-  DEFAULT_API_URL,
-  DEFAULT_TIMEOUT
-};

package/lib/index.js

@@ -1,19 +0,0 @@
-/**
- * Plexor Plugin Library
- */
-
-const ConfigManager = require('./config');
-const SessionManager = require('./session');
-const LocalCache = require('./cache');
-const Logger = require('./logger');
-const PlexorClient = require('./plexor-client');
-const constants = require('./constants');
-
-module.exports = {
-  ConfigManager,
-  SessionManager,
-  LocalCache,
-  Logger,
-  PlexorClient,
-  ...constants
-};

package/lib/logger.js

@@ -1,36 +0,0 @@
-/**
- * Plexor Logger
- *
- * Simple logger that outputs to stderr to avoid interfering with stdout JSON.
- */
-
-class Logger {
-  constructor(component = 'plexor') {
-    this.component = component;
-    this.debug_enabled = process.env.PLEXOR_DEBUG === '1' || process.env.PLEXOR_DEBUG === 'true';
-  }
-
-  debug(msg, data = null) {
-    if (this.debug_enabled) {
-      const output = data ? `[DEBUG][${this.component}] ${msg} ${JSON.stringify(data)}` : `[DEBUG][${this.component}] ${msg}`;
-      console.error(output);
-    }
-  }
-
-  info(msg, data = null) {
-    const output = data ? `${msg} ${JSON.stringify(data)}` : msg;
-    console.error(output);
-  }
-
-  warn(msg, data = null) {
-    const output = data ? `[WARN][${this.component}] ${msg} ${JSON.stringify(data)}` : `[WARN][${this.component}] ${msg}`;
-    console.error(output);
-  }
-
-  error(msg, data = null) {
-    const output = data ? `[ERROR][${this.component}] ${msg} ${JSON.stringify(data)}` : `[ERROR][${this.component}] ${msg}`;
-    console.error(output);
-  }
-}
-
-module.exports = Logger;

package/lib/plexor-client.js

@@ -1,122 +0,0 @@
-/**
- * Plexor API Client
- *
- * Handles communication with the Plexor optimization API.
- */
-
-const https = require('https');
-const http = require('http');
-const { URL } = require('url');
-const { DEFAULT_API_URL, DEFAULT_TIMEOUT } = require('./constants');
-
-class PlexorClient {
-  constructor(options = {}) {
-    this.apiKey = options.apiKey || '';
-    this.baseUrl = options.baseUrl || DEFAULT_API_URL;
-    this.timeout = options.timeout || DEFAULT_TIMEOUT;
-  }
-
-  async request(method, path, body = null) {
-    return new Promise((resolve, reject) => {
-      const url = new URL(path, this.baseUrl);
-      const isHttps = url.protocol === 'https:';
-      const lib = isHttps ? https : http;
-
-      const options = {
-        hostname: url.hostname,
-        port: url.port || (isHttps ? 443 : 80),
-        path: url.pathname + url.search,
-        method: method,
-        headers: {
-          'Content-Type': 'application/json',
-          'X-API-Key': this.apiKey,
-          'X-Plexor-Key': this.apiKey,
-          'User-Agent': 'plexor-claude-code-plugin/0.1.0-beta.22'
-        },
-        timeout: this.timeout
-      };
-
-      const req = lib.request(options, (res) => {
-        let data = '';
-        res.on('data', (chunk) => data += chunk);
-        res.on('end', () => {
-          try {
-            const json = JSON.parse(data);
-            if (res.statusCode >= 200 && res.statusCode < 300) {
-              resolve(json);
-            } else {
-              reject(new Error(json.message || `HTTP ${res.statusCode}`));
-            }
-          } catch {
-            reject(new Error(`Invalid JSON response: ${data.substring(0, 100)}`));
-          }
-        });
-      });
-
-      req.on('error', reject);
-      req.on('timeout', () => {
-        req.destroy();
-        reject(new Error('Request timeout'));
-      });
-
-      if (body) {
-        req.write(JSON.stringify(body));
-      }
-
-      req.end();
-    });
-  }
-
-  async optimize(params) {
-    try {
-      const result = await this.request('POST', '/v1/optimize', {
-        messages: params.messages,
-        model: params.model,
-        max_tokens: params.max_tokens,
-        task_hint: params.task_hint,
-        context: params.context
-      });
-
-      return {
-        request_id: result.request_id || `req_${Date.now()}`,
-        original_tokens: result.original_tokens || 0,
-        optimized_tokens: result.optimized_tokens || 0,
-        tokens_saved: result.tokens_saved || 0,
-        optimized_messages: result.optimized_messages || params.messages,
-        recommended_provider: result.recommended_provider || 'anthropic',
-        recommended_model: result.recommended_model || params.model,
-        estimated_cost: result.estimated_cost || 0,
-        baseline_cost: result.baseline_cost || 0
-      };
-    } catch (error) {
-      // Return passthrough on error
-      const tokens = Math.round(JSON.stringify(params.messages).length / 4);
-      return {
-        request_id: `req_${Date.now()}`,
-        original_tokens: tokens,
-        optimized_tokens: tokens,
-        tokens_saved: 0,
-        optimized_messages: params.messages,
-        recommended_provider: 'anthropic',
-        recommended_model: params.model,
-        estimated_cost: 0,
-        baseline_cost: 0,
-        error: error.message
-      };
-    }
-  }
-
-  async getUser() {
-    return this.request('GET', '/v1/user');
-  }
-
-  async getStats() {
-    return this.request('GET', '/v1/stats');
-  }
-
-  async trackResponse(requestId, metrics) {
-    return this.request('POST', `/v1/track/${requestId}`, metrics);
-  }
-}
-
-module.exports = PlexorClient;

package/lib/server-sync.js

@@ -1,237 +0,0 @@
-/**
- * Plexor Server Sync Module
- *
- * Issue #701: Syncs local plugin session state to the Plexor server.
- * This ensures accurate token tracking even for passthrough requests.
- *
- * Phase 2 of the hypervisor architecture implementation.
- */
-
-const https = require('https');
-const http = require('http');
-
-class ServerSync {
-  constructor(options = {}) {
-    this.apiKey = options.apiKey;
-    this.baseUrl = options.baseUrl || 'https://api.plexor.dev';
-    this.timeout = options.timeout || 5000;
-    this.enabled = options.enabled !== false;
-    this.lastSyncTime = null;
-    this.syncInterval = options.syncInterval || 60000; // 1 minute default
-    this.pendingSync = null;
-    this.serverSessionId = null;
-  }
-
-  /**
-   * Sync local session stats to the server.
-   * Issue #701: Ensures server has accurate metrics even for passthroughs.
-   *
-   * @param {Object} localSession - Local session stats from SessionManager
-   * @returns {Promise<Object>} Server response with synced metrics
-   */
-  async syncSession(localSession) {
-    if (!this.enabled || !this.apiKey) {
-      return { synced: false, message: 'Server sync disabled or no API key' };
-    }
-
-    try {
-      const syncData = {
-        session_id: this.serverSessionId,
-        requests: localSession.requests || 0,
-        optimizations: localSession.optimizations || 0,
-        cache_hits: localSession.cache_hits || 0,
-        passthroughs: localSession.passthroughs || 0,
-        original_tokens: localSession.original_tokens || 0,
-        optimized_tokens: localSession.optimized_tokens || 0,
-        tokens_saved: localSession.tokens_saved || 0,
-        output_tokens: localSession.output_tokens || 0,
-        baseline_cost: localSession.baseline_cost || 0,
-        actual_cost: localSession.actual_cost || 0,
-        cost_saved: localSession.cost_saved || 0
-      };
-
-      const response = await this._postToServer('/v1/plugin/session/sync', syncData);
-
-      if (response.synced) {
-        this.serverSessionId = response.server_session_id;
-        this.lastSyncTime = Date.now();
-      }
-
-      return response;
-    } catch (error) {
-      // Don't throw - server sync failures shouldn't break the plugin
-      return {
-        synced: false,
-        message: `Server sync failed: ${error.message}`,
-        error: error.message
-      };
-    }
-  }
-
-  /**
-   * Get server-side session state.
-   *
-   * @param {string} sessionId - Session ID to query
-   * @returns {Promise<Object>} Server session state
-   */
-  async getServerSession(sessionId) {
-    if (!this.enabled || !this.apiKey) {
-      return { found: false, message: 'Server sync disabled or no API key' };
-    }
-
-    try {
-      return await this._getFromServer(`/v1/plugin/session/${sessionId}`);
-    } catch (error) {
-      return {
-        found: false,
-        message: `Failed to get server session: ${error.message}`
-      };
-    }
-  }
-
-  /**
-   * Schedule periodic sync (debounced).
-   *
-   * @param {Object} localSession - Local session stats
-   */
-  scheduleSync(localSession) {
-    // Debounce: don't sync more than once per interval
-    if (this.pendingSync) {
-      clearTimeout(this.pendingSync);
-    }
-
-    this.pendingSync = setTimeout(async () => {
-      await this.syncSession(localSession);
-      this.pendingSync = null;
-    }, 1000); // Sync 1 second after last request
-  }
-
-  /**
-   * POST data to the Plexor server.
-   *
-   * @param {string} path - API path
-   * @param {Object} data - Data to send
-   * @returns {Promise<Object>} Parsed JSON response
-   */
-  _postToServer(path, data) {
-    return new Promise((resolve, reject) => {
-      const url = new URL(path, this.baseUrl);
-      const isHttps = url.protocol === 'https:';
-      const client = isHttps ? https : http;
-
-      const options = {
-        hostname: url.hostname,
-        port: url.port || (isHttps ? 443 : 80),
-        path: url.pathname,
-        method: 'POST',
-        headers: {
-          'Content-Type': 'application/json',
-          'Authorization': `Bearer ${this.apiKey}`,
-          'X-Plexor-Plugin-Version': '0.1.0-beta.5',
-          'X-Plexor-Issue': '701'
-        },
-        timeout: this.timeout
-      };
-
-      const req = client.request(options, (res) => {
-        let body = '';
-        res.on('data', chunk => body += chunk);
-        res.on('end', () => {
-          try {
-            const parsed = JSON.parse(body);
-            resolve(parsed);
-          } catch (e) {
-            reject(new Error(`Invalid JSON response: ${body.substring(0, 100)}`));
-          }
-        });
-      });
-
-      req.on('error', reject);
-      req.on('timeout', () => {
-        req.destroy();
-        reject(new Error('Request timeout'));
-      });
-
-      req.write(JSON.stringify(data));
-      req.end();
-    });
-  }
-
-  /**
-   * GET data from the Plexor server.
-   *
-   * @param {string} path - API path
-   * @returns {Promise<Object>} Parsed JSON response
-   */
-  _getFromServer(path) {
-    return new Promise((resolve, reject) => {
-      const url = new URL(path, this.baseUrl);
-      const isHttps = url.protocol === 'https:';
-      const client = isHttps ? https : http;
-
-      const options = {
-        hostname: url.hostname,
-        port: url.port || (isHttps ? 443 : 80),
-        path: url.pathname,
-        method: 'GET',
-        headers: {
-          'Authorization': `Bearer ${this.apiKey}`,
-          'X-Plexor-Plugin-Version': '0.1.0-beta.5'
-        },
-        timeout: this.timeout
-      };
-
-      const req = client.request(options, (res) => {
-        let body = '';
-        res.on('data', chunk => body += chunk);
-        res.on('end', () => {
-          try {
-            resolve(JSON.parse(body));
-          } catch (e) {
-            reject(new Error(`Invalid JSON response: ${body.substring(0, 100)}`));
-          }
-        });
-      });
-
-      req.on('error', reject);
-      req.on('timeout', () => {
-        req.destroy();
-        reject(new Error('Request timeout'));
-      });
-
-      req.end();
-    });
-  }
-
-  /**
-   * Check if sync is needed based on time elapsed.
-   */
-  needsSync() {
-    if (!this.lastSyncTime) return true;
-    return Date.now() - this.lastSyncTime > this.syncInterval;
-  }
-}
-
-// Singleton instance
-let _serverSync = null;
-
-function getServerSync(options = {}) {
-  if (!_serverSync) {
-    _serverSync = new ServerSync(options);
-  } else if (options.apiKey && options.apiKey !== _serverSync.apiKey) {
-    // Update API key if changed
-    _serverSync.apiKey = options.apiKey;
-    _serverSync.baseUrl = options.baseUrl || _serverSync.baseUrl;
-  }
-  return _serverSync;
-}
-
-function resetServerSync() {
-  _serverSync = null;
-}
-
-module.exports = {
-  ServerSync,
-  getServerSync,
-  resetServerSync
-};

package/lib/session.js

@@ -1,156 +0,0 @@
-/**
- * Plexor Session Manager
- *
- * Tracks session statistics for the current Claude Code session.
- * Session expires after 30 minutes of inactivity.
- */
-
-const fs = require('fs');
-const path = require('path');
-const { SESSION_PATH, PLEXOR_DIR, SESSION_TIMEOUT_MS } = require('./constants');
-
-class SessionManager {
-  constructor() {
-    this.sessionPath = SESSION_PATH;
-  }
-
-  load() {
-    try {
-      const data = fs.readFileSync(this.sessionPath, 'utf8');
-      const session = JSON.parse(data);
-
-      // Check if session has expired (30 min inactivity)
-      if (Date.now() - session.last_activity > SESSION_TIMEOUT_MS) {
-        return this.createNew();
-      }
-
-      return session;
-    } catch {
-      return this.createNew();
-    }
-  }
-
-  createNew() {
-    const session = {
-      session_id: `session_${Date.now()}`,
-      started_at: new Date().toISOString(),
-      last_activity: Date.now(),
-      requests: 0,
-      optimizations: 0,
-      cache_hits: 0,
-      passthroughs: 0,  // Issue #701: Track passthroughs
-      original_tokens: 0,
-      optimized_tokens: 0,
-      tokens_saved: 0,
-      output_tokens: 0,  // Issue #701: Track output tokens
-      baseline_cost: 0,
-      actual_cost: 0,
-      cost_saved: 0
-    };
-    this.save(session);
-    return session;
-  }
-
-  save(session) {
-    try {
-      if (!fs.existsSync(PLEXOR_DIR)) {
-        fs.mkdirSync(PLEXOR_DIR, { recursive: true });
-      }
-      session.last_activity = Date.now();
-      fs.writeFileSync(this.sessionPath, JSON.stringify(session, null, 2));
-      return true;
-    } catch {
-      return false;
-    }
-  }
-
-  recordRequest(stats = {}) {
-    const session = this.load();
-    session.requests++;
-
-    if (stats.optimized) {
-      session.optimizations++;
-      session.original_tokens += stats.original_tokens || 0;
-      session.optimized_tokens += stats.optimized_tokens || 0;
-      session.tokens_saved += stats.tokens_saved || 0;
-      session.output_tokens = (session.output_tokens || 0) + (stats.output_tokens || 0);  // Issue #701
-      session.baseline_cost += stats.baseline_cost || 0;
-      session.actual_cost += stats.actual_cost || 0;
-      session.cost_saved += stats.cost_saved || 0;
-    }
-
-    if (stats.cache_hit) {
-      session.cache_hits++;
-    }
-
-    // Issue #701: Track passthroughs and their output tokens
-    if (stats.passthrough) {
-      session.passthroughs = (session.passthroughs || 0) + 1;
-      session.output_tokens = (session.output_tokens || 0) + (stats.output_tokens || 0);
-    }
-
-    this.save(session);
-    return session;
-  }
-
-  recordOptimization(result) {
-    return this.recordRequest({
-      optimized: true,
-      original_tokens: result.original_tokens || 0,
-      optimized_tokens: result.optimized_tokens || 0,
-      tokens_saved: result.tokens_saved || 0,
-      output_tokens: result.output_tokens || 0,  // Issue #701: Track output tokens
-      baseline_cost: result.baseline_cost || 0,
-      actual_cost: result.estimated_cost || result.actual_cost || 0,
-      cost_saved: (result.baseline_cost || 0) - (result.estimated_cost || result.actual_cost || 0)
-    });
-  }
-
-  recordCacheHit() {
-    return this.recordRequest({ cache_hit: true });
-  }
-
-  recordPassthrough(outputTokens = 0) {
-    // Issue #701: Track passthroughs and their output tokens
-    return this.recordRequest({ passthrough: true, output_tokens: outputTokens });
-  }
-
-  getStats() {
-    const session = this.load();
-    const duration = Date.now() - new Date(session.started_at).getTime();
-
-    return {
-      ...session,
-      duration_ms: duration,
-      duration_formatted: this.formatDuration(duration),
-      tokens_saved_percent: session.original_tokens > 0
-        ? ((session.tokens_saved / session.original_tokens) * 100).toFixed(1)
-        : '0.0',
-      cost_saved_percent: session.baseline_cost > 0
-        ? ((session.cost_saved / session.baseline_cost) * 100).toFixed(1)
-        : '0.0'
-    };
-  }
-
-  formatDuration(ms) {
-    const minutes = Math.floor(ms / 60000);
-    if (minutes < 60) {
-      return `${minutes}m`;
-    }
-    const hours = Math.floor(minutes / 60);
-    const remainingMinutes = minutes % 60;
-    return `${hours}h ${remainingMinutes}m`;
-  }
-
-  isExpired() {
-    try {
-      const data = fs.readFileSync(this.sessionPath, 'utf8');
-      const session = JSON.parse(data);
-      return Date.now() - session.last_activity > SESSION_TIMEOUT_MS;
-    } catch {
-      return true;
-    }
-  }
-}
-
-module.exports = SessionManager;

package/lib/settings-manager.js

@@ -1,352 +0,0 @@
-/**
- * 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
-const PLEXOR_STAGING_URL = 'LOCALHOST_TUNNEL_URL/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 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 = {}) {
-    // STAGING PACKAGE - defaults to staging API
-    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 };
-    }
-  }
-
-  /**
-   * 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');
-
-      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
-};