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

package/lib/plexor-client.js

@@ -0,0 +1,122 @@
+/**
+ * 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.21'
+        },
+        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

@@ -0,0 +1,237 @@
+/**
+ * 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

@@ -0,0 +1,156 @@
+/**
+ * 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/package.json

@@ -1,8 +1,18 @@
 {
   "name": "@plexor-dev/claude-code-plugin",
-  "version": "0.1.0-beta.2",
+  "version": "0.1.0-beta.21",
   "description": "LLM cost optimization plugin for Claude Code - Save up to 90% on AI costs",
   "main": "lib/constants.js",
+  "bin": {
+    "plexor-status": "./commands/plexor-status.js",
+    "plexor-mode": "./commands/plexor-mode.js",
+    "plexor-enabled": "./commands/plexor-enabled.js",
+    "plexor-provider": "./commands/plexor-provider.js",
+    "plexor-login": "./commands/plexor-login.js",
+    "plexor-logout": "./commands/plexor-logout.js",
+    "plexor-settings": "./commands/plexor-settings.js",
+    "plexor-config": "./commands/plexor-config.js"
+  },
   "scripts": {
     "postinstall": "node scripts/postinstall.js",
     "preuninstall": "node scripts/uninstall.js",
@@ -10,6 +20,7 @@
   },
   "files": [
     "commands/",
+    "hooks/",
     "scripts/",
     "lib/",
     "README.md",

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 "$@"

package/scripts/postinstall.js

@@ -11,23 +11,49 @@ const fs = require('fs');
 const path = require('path');
 const os = require('os');
 
+/**
+ * Get the correct home directory, accounting for sudo.
+ * When running with sudo, os.homedir() returns /root, but we want
+ * the actual user's home directory.
+ */
+function getHomeDir() {
+  // Check if running with sudo - SUDO_USER contains the original username
+  if (process.env.SUDO_USER) {
+    // On Linux/Mac, home directories are typically /home/<user> or /Users/<user>
+    const platform = os.platform();
+    if (platform === 'darwin') {
+      return path.join('/Users', process.env.SUDO_USER);
+    } else if (platform === 'linux') {
+      return path.join('/home', process.env.SUDO_USER);
+    }
+  }
+  return os.homedir();
+}
+
+const HOME_DIR = getHomeDir();
 const COMMANDS_SOURCE = path.join(__dirname, '..', 'commands');
-const CLAUDE_COMMANDS_DIR = path.join(os.homedir(), '.claude', 'commands');
-const PLEXOR_CONFIG_DIR = path.join(os.homedir(), '.plexor');
+const CLAUDE_COMMANDS_DIR = path.join(HOME_DIR, '.claude', 'commands');
+const PLEXOR_PLUGINS_DIR = path.join(HOME_DIR, '.claude', 'plugins', 'plexor', 'commands');
+const PLEXOR_CONFIG_DIR = path.join(HOME_DIR, '.plexor');
 
 function main() {
   try {
     // Create ~/.claude/commands/ if not exists
     fs.mkdirSync(CLAUDE_COMMANDS_DIR, { recursive: true });
 
+    // Create ~/.claude/plugins/plexor/commands/ for JS executors
+    fs.mkdirSync(PLEXOR_PLUGINS_DIR, { recursive: true });
+
     // Create ~/.plexor/ with secure permissions (owner only)
     fs.mkdirSync(PLEXOR_CONFIG_DIR, { recursive: true, mode: 0o700 });
 
-    // Get list of command files
-    const files = fs.readdirSync(COMMANDS_SOURCE)
+    // Get list of command files (.md for Claude, .js for executors)
+    const mdFiles = fs.readdirSync(COMMANDS_SOURCE)
       .filter(f => f.endsWith('.md'));
+    const jsFiles = fs.readdirSync(COMMANDS_SOURCE)
+      .filter(f => f.endsWith('.js'));
 
-    if (files.length === 0) {
+    if (mdFiles.length === 0) {
       console.error('No command files found in package. Installation may be corrupt.');
       process.exit(1);
     }
@@ -35,7 +61,8 @@ function main() {
     const installed = [];
     const backed_up = [];
 
-    for (const file of files) {
+    // Copy .md command files to ~/.claude/commands/
+    for (const file of mdFiles) {
       const src = path.join(COMMANDS_SOURCE, file);
       const dest = path.join(CLAUDE_COMMANDS_DIR, file);
 
@@ -55,6 +82,17 @@ function main() {
       installed.push(file.replace('.md', ''));
     }
 
+    // Copy .js executor files to ~/.claude/plugins/plexor/commands/
+    const jsInstalled = [];
+    for (const file of jsFiles) {
+      const src = path.join(COMMANDS_SOURCE, file);
+      const dest = path.join(PLEXOR_PLUGINS_DIR, file);
+      fs.copyFileSync(src, dest);
+      // Make executable
+      fs.chmodSync(dest, 0o755);
+      jsInstalled.push(file);
+    }
+
     // Print success message
     console.log('');
     console.log('  ╔═══════════════════════════════════════════════════════════╗');
@@ -74,12 +112,20 @@ function main() {
       backed_up.forEach(f => console.log(`    ${f}`));
     }
 
+    if (jsInstalled.length > 0) {
+      console.log('');
+      console.log('  Executors installed to ~/.claude/plugins/plexor/commands/:');
+      jsInstalled.forEach(f => console.log(`    ${f}`));
+    }
+
     console.log('');
     console.log('  Next steps:');
     console.log('    1. Open Claude Code');
-    console.log('    2. Run /plexor-login to authenticate');
+    console.log('    2. Run /plexor-setup to configure (handles MAX + API key users)');
     console.log('    3. Start saving on LLM costs!');
     console.log('');
+    console.log('  Have Claude MAX? Just set: export ANTHROPIC_BASE_URL="https://api.plexor.dev/gateway/anthropic"');
+    console.log('');
     console.log('  Documentation: https://plexor.dev/docs');
     console.log('');