@plexor-dev/claude-code-plugin-localhost 0.1.0-beta.11

package/commands/plexor-status.js

@@ -0,0 +1,406 @@
+#!/usr/bin/env node
+
+/**
+ * Plexor Status Command
+ * Displays formatted status with usage statistics
+ */
+
+const fs = require('fs');
+const path = require('path');
+const https = require('https');
+
+// Import centralized constants with HOME directory validation
+const { HOME_DIR, CONFIG_PATH, SESSION_PATH, SESSION_TIMEOUT_MS } = require('../lib/constants');
+const CLAUDE_SETTINGS_PATH = path.join(HOME_DIR, '.claude', 'settings.json');
+
+/**
+ * Check if Claude Code is actually routing through Plexor
+ * by reading ~/.claude/settings.json
+ */
+function getRoutingStatus() {
+  try {
+    const data = fs.readFileSync(CLAUDE_SETTINGS_PATH, 'utf8');
+    const settings = JSON.parse(data);
+    const baseUrl = settings.env?.ANTHROPIC_BASE_URL || '';
+    const hasToken = !!settings.env?.ANTHROPIC_AUTH_TOKEN;
+    const isPlexorRouting = baseUrl.includes('plexor') || baseUrl.includes('staging.api') || baseUrl.includes('ngrok') || baseUrl.includes('localhost');
+    return {
+      active: isPlexorRouting && hasToken,
+      baseUrl,
+      isStaging: baseUrl.includes('staging')
+    };
+  } catch {
+    return { active: false, baseUrl: null, isStaging: 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 }
+ */
+function detectPartialState() {
+  try {
+    const data = fs.readFileSync(CLAUDE_SETTINGS_PATH, 'utf8');
+    const settings = JSON.parse(data);
+    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('ngrok') || 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 };
+  }
+}
+
+function loadSessionStats() {
+  try {
+    const data = fs.readFileSync(SESSION_PATH, 'utf8');
+    const session = JSON.parse(data);
+    // Check if session has expired
+    if (Date.now() - session.last_activity > SESSION_TIMEOUT_MS) {
+      return null;
+    }
+    return session;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Validate API key format
+ * @param {string} key - API key to validate
+ * @returns {boolean} true if valid format
+ */
+function isValidApiKeyFormat(key) {
+  return key && typeof key === 'string' && key.startsWith('plx_') && key.length >= 20;
+}
+
+/**
+ * Load config file with integrity checking
+ * @returns {Object|null} config object or null if invalid
+ */
+function loadConfig() {
+  try {
+    if (!fs.existsSync(CONFIG_PATH)) {
+      return null;
+    }
+    const data = fs.readFileSync(CONFIG_PATH, 'utf8');
+    if (!data || data.trim() === '') {
+      return null;
+    }
+    const config = JSON.parse(data);
+    if (typeof config !== 'object' || config === null) {
+      return null;
+    }
+    return config;
+  } catch (err) {
+    if (err instanceof SyntaxError) {
+      console.log('Config file is corrupted. Run /plexor-login to reconfigure.');
+    }
+    return null;
+  }
+}
+
+/**
+ * Check for environment mismatch between config and routing
+ */
+function checkEnvironmentMismatch(configApiUrl, routingBaseUrl) {
+  if (!configApiUrl || !routingBaseUrl) return null;
+
+  const configIsStaging = configApiUrl.includes('staging');
+  const routingIsStaging = routingBaseUrl.includes('staging');
+
+  if (configIsStaging !== routingIsStaging) {
+    return {
+      config: configIsStaging ? 'staging' : 'production',
+      routing: routingIsStaging ? 'staging' : 'production'
+    };
+  }
+  return null;
+}
+
+/**
+ * Check for state mismatch between config.json enabled flag and settings.json routing
+ * @param {boolean} configEnabled - enabled flag from config.json
+ * @param {boolean} routingActive - whether settings.json has Plexor routing configured
+ * @returns {Object|null} mismatch details or null if states are consistent
+ */
+function checkStateMismatch(configEnabled, routingActive) {
+  if (configEnabled && !routingActive) {
+    return {
+      type: 'config-enabled-routing-inactive',
+      message: 'Config shows enabled but Claude routing is not configured',
+      suggestion: 'Run /plexor-enabled true to sync and configure routing'
+    };
+  }
+  if (!configEnabled && routingActive) {
+    return {
+      type: 'config-disabled-routing-active',
+      message: 'Config shows disabled but Claude routing is active',
+      suggestion: 'Run /plexor-enabled false to sync and disable routing'
+    };
+  }
+  return null;
+}
+
+async function main() {
+  // Read config with integrity checking
+  const config = loadConfig();
+  if (!config) {
+    console.log('Not configured. Run /plexor-login first.');
+    process.exit(1);
+  }
+
+  const apiKey = config.auth?.api_key;
+  const enabled = config.settings?.enabled ?? false;
+  const mode = config.settings?.mode || 'balanced';
+  const provider = config.settings?.preferred_provider || 'auto';
+  const localCache = config.settings?.localCacheEnabled ?? false;
+  const apiUrl = config.settings?.apiUrl || 'LOCALHOST_TUNNEL_URL';
+
+  if (!apiKey) {
+    console.log('Not authenticated. Run /plexor-login first.');
+    process.exit(1);
+  }
+
+  // Validate API key format
+  if (!isValidApiKeyFormat(apiKey)) {
+    console.log('Invalid API key format. Keys must start with "plx_" and be at least 20 characters.');
+    console.log('Run /plexor-login with a valid API key.');
+    process.exit(1);
+  }
+
+  // Fetch user info and stats
+  let user = { email: 'Unknown', tier: { name: 'Free', limits: {} } };
+  let stats = { period: {}, summary: {} };
+
+  try {
+    [user, stats] = await Promise.all([
+      fetchJson(apiUrl, '/v1/user', apiKey),
+      fetchJson(apiUrl, '/v1/stats', apiKey)
+    ]);
+  } catch (err) {
+    // Continue with defaults if API fails
+  }
+
+  // Load session stats
+  const session = loadSessionStats();
+
+  // Extract data
+  const email = user.email || 'Unknown';
+  const tierName = user.tier?.name || 'Free';
+  const monthlyOpts = user.tier?.limits?.monthly_optimizations || '∞';
+  const monthlyComps = user.tier?.limits?.monthly_completions || '∞';
+
+  const period = stats.period || {};
+  const summary = stats.summary || {};
+
+  const formatDate = (iso) => {
+    if (!iso) return '?';
+    const d = new Date(iso);
+    return d.toLocaleDateString('en-US', { month: 'short', day: 'numeric' });
+  };
+  const weekRange = `${formatDate(period.start)} - ${formatDate(period.end)}`;
+
+  // Format numbers
+  const formatNum = (n) => (n || 0).toLocaleString();
+  const formatPct = (n) => (n || 0).toFixed(1);
+  const formatCost = (n) => (n || 0).toFixed(2);
+
+  const status = enabled ? '● Active' : '○ Inactive';
+  const optEnabled = enabled ? 'Enabled' : 'Disabled';
+  const cacheEnabled = localCache ? 'Enabled' : 'Disabled';
+  const cacheRate = formatPct((summary.cache_hit_rate || 0) * 100);
+
+  // Build dashboard URL from API URL
+  // API: https://api.plexor.dev or https://staging.api.plexor.dev
+  // Dashboard: https://plexor.dev/dashboard or https://staging.plexor.dev/dashboard
+  let dashboardUrl = 'https://plexor.dev/dashboard';
+  try {
+    const url = new URL(apiUrl);
+    // Remove 'api.' prefix from hostname if present
+    const host = url.hostname.replace(/^api\./, '').replace(/\.api\./, '.');
+    dashboardUrl = `${url.protocol}//${host}/dashboard`;
+  } catch {
+    // If URL parsing fails, use default
+  }
+
+  // Output formatted status - each line is exactly 43 chars inner width
+  const line = (content) => `  │  ${content.padEnd(43)}│`;
+
+  // Session stats formatting
+  const formatDuration = (startedAt) => {
+    if (!startedAt) return '0m';
+    const elapsed = Date.now() - new Date(startedAt).getTime();
+    const minutes = Math.floor(elapsed / 60000);
+    if (minutes < 60) return `${minutes}m`;
+    const hours = Math.floor(minutes / 60);
+    return `${hours}h ${minutes % 60}m`;
+  };
+
+  const sessionDuration = session ? formatDuration(session.started_at) : '0m';
+  const sessionRequests = session ? formatNum(session.requests) : '0';
+  const sessionOptimizations = session ? formatNum(session.optimizations) : '0';
+  const sessionCacheHits = session ? formatNum(session.cache_hits) : '0';
+  const sessionTokensSaved = session ? formatNum(session.tokens_saved) : '0';
+  const sessionTokensSavedPct = session && session.original_tokens > 0
+    ? formatPct((session.tokens_saved / session.original_tokens) * 100)
+    : '0.0';
+  const sessionCostSaved = session ? formatCost(session.cost_saved) : '0.00';
+
+  // Build session section (only show if session exists)
+  const sessionSection = session ? `  ├─────────────────────────────────────────────┤
+${line(`This Session (${sessionDuration})`)}
+${line(`├── Requests: ${sessionRequests}`)}
+${line(`├── Optimizations: ${sessionOptimizations}`)}
+${line(`├── Cache hits: ${sessionCacheHits}`)}
+${line(`├── Tokens saved: ${sessionTokensSaved} (${sessionTokensSavedPct}%)`)}
+${line(`└── Cost saved: $${sessionCostSaved}`)}
+` : '';
+
+  // Get routing status from Claude settings.json
+  const routing = getRoutingStatus();
+  const routingIndicator = routing.active ? '🟢 PLEXOR MODE: ON' : '🔴 PLEXOR MODE: OFF';
+  const envLabel = routing.isStaging ? '(staging)' : '(production)';
+
+  // Check for environment mismatch
+  const envMismatch = checkEnvironmentMismatch(apiUrl, routing.baseUrl);
+  const mismatchWarning = envMismatch
+    ? `  ⚠ Warning: Config uses ${envMismatch.config} but routing is ${envMismatch.routing}\n`
+    : '';
+
+  if (mismatchWarning) {
+    console.log(mismatchWarning);
+  }
+
+  // Check for partial routing state (Plexor URL without valid auth)
+  const partialState = detectPartialState();
+  if (partialState.partial) {
+    console.log(`  ⚠ PARTIAL STATE DETECTED: ${partialState.issue}`);
+    console.log(`    Run /plexor-login to fix, or /plexor-logout to disable routing\n`);
+  }
+
+  // Check for state mismatch between config enabled flag and routing status
+  const stateMismatch = checkStateMismatch(enabled, routing.active);
+  if (stateMismatch) {
+    console.log(`  ⚠ State mismatch: ${stateMismatch.message}`);
+    console.log(`  └─ ${stateMismatch.suggestion}\n`);
+  }
+
+  console.log(`  ┌─────────────────────────────────────────────┐
+${line(routingIndicator + (routing.active ? ' ' + envLabel : ''))}
+  ├─────────────────────────────────────────────┤
+${line(`Account: ${tierName}`)}
+${line(`Email: ${email}`)}
+${line(`Status: ${status}`)}
+${sessionSection}  ├─────────────────────────────────────────────┤
+${line(`This Week (${weekRange})`)}
+${line(`├── Requests: ${formatNum(summary.total_requests)}`)}
+${line(`├── Original tokens: ${formatNum(summary.original_tokens)}`)}
+${line(`├── Optimized tokens: ${formatNum(summary.optimized_tokens)}`)}
+${line(`├── Tokens saved: ${formatNum(summary.tokens_saved)} (${formatPct(summary.tokens_saved_percent)}%)`)}
+${line(`├── Baseline cost: $${formatCost(summary.baseline_cost)}`)}
+${line(`├── Actual cost: $${formatCost(summary.total_cost)}`)}
+${line(`└── Cost saved: $${formatCost(summary.cost_saved)} (${formatPct(summary.cost_saved_percent)}%)`)}
+  ├─────────────────────────────────────────────┤
+${line('Performance')}
+${line(`└── Cache hit rate: ${cacheRate}%`)}
+  ├─────────────────────────────────────────────┤
+${line('Limits')}
+${line(`├── Monthly optimizations: ${formatNum(monthlyOpts)}`)}
+${line(`└── Monthly completions: ${formatNum(monthlyComps)}`)}
+  ├─────────────────────────────────────────────┤
+${line('Settings')}
+${line(`├── Optimization: ${optEnabled}`)}
+${line(`├── Local cache: ${cacheEnabled}`)}
+${line(`├── Mode: ${mode}`)}
+${line(`├── Provider routing: ${provider}`)}
+${line(`└── Endpoint: ${routing.baseUrl ? routing.baseUrl.replace('https://', '').substring(0, 30) : 'not configured'}`)}
+  └─────────────────────────────────────────────┘
+
+  Dashboard: ${dashboardUrl}
+`);
+}
+
+function fetchJson(apiUrl, endpoint, apiKey) {
+  return new Promise((resolve, reject) => {
+    let url;
+    try {
+      url = new URL(`${apiUrl}${endpoint}`);
+    } catch {
+      reject(new Error('Invalid API URL'));
+      return;
+    }
+
+    const options = {
+      hostname: url.hostname,
+      port: 443,
+      path: url.pathname,
+      method: 'GET',
+      headers: {
+        'X-Plexor-Key': apiKey
+      }
+    };
+
+    const req = https.request(options, (res) => {
+      let data = '';
+      res.on('data', chunk => data += chunk);
+      res.on('end', () => {
+        // Check HTTP status code first
+        if (res.statusCode === 401) {
+          reject(new Error('Invalid API key'));
+          return;
+        }
+        if (res.statusCode === 403) {
+          reject(new Error('Access denied'));
+          return;
+        }
+        if (res.statusCode >= 500) {
+          reject(new Error('Server error'));
+          return;
+        }
+        if (res.statusCode !== 200) {
+          reject(new Error(`HTTP ${res.statusCode}`));
+          return;
+        }
+
+        // Check for empty response
+        if (!data || data.trim() === '') {
+          reject(new Error('Empty response'));
+          return;
+        }
+
+        // Parse JSON
+        try {
+          const parsed = JSON.parse(data);
+          if (parsed === null) {
+            reject(new Error('Null response'));
+            return;
+          }
+          resolve(parsed);
+        } catch {
+          reject(new Error('Invalid JSON response'));
+        }
+      });
+    });
+
+    req.on('error', (err) => reject(new Error(`Connection failed: ${err.message}`)));
+    req.setTimeout(5000, () => {
+      req.destroy();
+      reject(new Error('Request timeout'));
+    });
+    req.end();
+  });
+}
+
+main().catch(err => {
+  console.error('Error:', err.message);
+  process.exit(1);
+});

package/commands/plexor-status.md

@@ -0,0 +1,21 @@
+---
+description: Show Plexor optimization statistics and savings (user)
+---
+
+# Plexor Status
+
+Run this command to display Plexor statistics:
+
+```bash
+node ~/.claude/plugins/plexor/commands/plexor-status.js
+```
+
+Use the Bash tool to execute this single command.
+
+**IMPORTANT**: After running this command and displaying the output, STOP. Do not:
+- Read any files
+- Explore the codebase
+- Run additional commands
+- Ask follow-up questions
+
+The command output is the complete response. Simply show the output and wait for the user's next input.

package/configure-localhost.sh

@@ -0,0 +1,90 @@
+#!/bin/bash
+#
+# Configure Plexor Localhost Plugin with Tunnel URL
+#
+# Usage:
+#   ./configure-localhost.sh https://your-ngrok-url.ngrok-free.app
+#
+# This script replaces the LOCALHOST_TUNNEL_URL placeholder in all plugin files
+# with your actual ngrok/tunnel URL.
+#
+
+set -e
+
+# Colors for output
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+NC='\033[0m' # No Color
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+
+if [ -z "$1" ]; then
+    echo -e "${RED}Error: No tunnel URL provided${NC}"
+    echo ""
+    echo "Usage: $0 <tunnel-url>"
+    echo ""
+    echo "Example:"
+    echo "  $0 https://abc123.ngrok-free.app"
+    echo "  $0 http://localhost:8000"
+    echo ""
+    exit 1
+fi
+
+TUNNEL_URL="$1"
+
+# Remove trailing slash if present
+TUNNEL_URL="${TUNNEL_URL%/}"
+
+echo -e "${YELLOW}Configuring Plexor localhost plugin...${NC}"
+echo "Tunnel URL: $TUNNEL_URL"
+echo ""
+
+# Files to update
+FILES=(
+    "lib/constants.js"
+    "lib/settings-manager.js"
+    "lib/plexor-client.js"
+    "hooks/intercept.js"
+    "hooks/track-response.js"
+    "scripts/postinstall.js"
+    "commands/plexor-enabled.js"
+    "commands/plexor-status.js"
+    "commands/plexor-login.js"
+    "commands/plexor-setup.md"
+    "README.md"
+)
+
+UPDATED=0
+FAILED=0
+
+for file in "${FILES[@]}"; do
+    filepath="$SCRIPT_DIR/$file"
+    if [ -f "$filepath" ]; then
+        if grep -q "LOCALHOST_TUNNEL_URL" "$filepath" 2>/dev/null; then
+            sed -i "s|LOCALHOST_TUNNEL_URL|${TUNNEL_URL}|g" "$filepath"
+            echo -e "  ${GREEN}[OK]${NC} $file"
+            ((UPDATED++))
+        else
+            echo -e "  ${YELLOW}[SKIP]${NC} $file (no placeholder found)"
+        fi
+    else
+        echo -e "  ${RED}[MISSING]${NC} $file"
+        ((FAILED++))
+    fi
+done
+
+echo ""
+echo -e "${GREEN}Configuration complete!${NC}"
+echo "  Files updated: $UPDATED"
+if [ $FAILED -gt 0 ]; then
+    echo -e "  ${RED}Files missing: $FAILED${NC}"
+fi
+
+echo ""
+echo "Next steps:"
+echo "  1. Pack the plugin:  cd $SCRIPT_DIR && npm pack"
+echo "  2. Copy to VM:       scp plexor-dev-claude-code-plugin-localhost-*.tgz user@vm:~/"
+echo "  3. Install on VM:    npm install -g ./plexor-dev-claude-code-plugin-localhost-*.tgz"
+echo "  4. Login:            /plexor-login <your-test-api-key>"
+echo ""