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

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.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

@@ -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;