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

package/commands/plexor-status.js

@@ -9,10 +9,29 @@ const fs = require('fs');
 const path = require('path');
 const https = require('https');
 
-const CONFIG_PATH = path.join(process.env.HOME, '.plexor', 'config.json');
-const SESSION_PATH = path.join(process.env.HOME, '.plexor', 'session.json');
-const CLAUDE_SETTINGS_PATH = path.join(process.env.HOME, '.claude', 'settings.json');
-const SESSION_TIMEOUT_MS = 30 * 60 * 1000; // 30 minutes
+// 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');
+
+function isManagedGatewayUrl(baseUrl = '') {
+  return (
+    baseUrl.includes('plexor') ||
+    baseUrl.includes('staging.api') ||
+    baseUrl.includes('ngrok') ||
+    baseUrl.includes('localtunnel') ||
+    baseUrl.includes('localhost') ||
+    baseUrl.includes('127.0.0.1')
+  );
+}
+
+function getPlexorAuthKey(env = {}) {
+  const apiKey = env.ANTHROPIC_API_KEY || '';
+  const authToken = env.ANTHROPIC_AUTH_TOKEN || '';
+
+  if (apiKey.startsWith('plx_')) return apiKey;
+  if (authToken.startsWith('plx_')) return authToken;
+  return apiKey || authToken || '';
+}
 
 /**
  * Check if Claude Code is actually routing through Plexor
@@ -23,10 +42,10 @@ function getRoutingStatus() {
     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');
+    const authKey = getPlexorAuthKey(settings.env);
+    const isPlexorRouting = isManagedGatewayUrl(baseUrl);
     return {
-      active: isPlexorRouting && hasToken,
+      active: isPlexorRouting && !!authKey,
       baseUrl,
       isStaging: baseUrl.includes('staging')
     };
@@ -35,6 +54,31 @@ function getRoutingStatus() {
   }
 }
 
+/**
+ * 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 authKey = getPlexorAuthKey(settings.env);
+    const isPlexorUrl = isManagedGatewayUrl(baseUrl);
+
+    if (isPlexorUrl && !authKey) {
+      return { partial: true, issue: 'Plexor URL set but no Plexor auth key' };
+    }
+    if (isPlexorUrl && !authKey.startsWith('plx_')) {
+      return { partial: true, issue: 'Plexor URL set but auth key 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');
@@ -49,14 +93,107 @@ function loadSessionStats() {
   }
 }
 
-async function main() {
-  // Read config
-  let config;
+/**
+ * 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');
-    config = JSON.parse(data);
+    if (!data || data.trim() === '') {
+      return null;
+    }
+    const config = JSON.parse(data);
+    if (typeof config !== 'object' || config === null) {
+      return null;
+    }
+    return config;
   } catch (err) {
-    console.log('Not configured. Run /plexor-login first.');
+    if (err instanceof SyntaxError) {
+      console.log('Config file is corrupted. Run /plexor-setup 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;
+}
+
+function printHealthSummary(summary) {
+  const line = (content) => `  │  ${String(content).slice(0, 43).padEnd(43)}│`;
+  console.log(`  ┌─────────────────────────────────────────────┐`);
+  console.log(line('Plexor health'));
+  console.log(`  ├─────────────────────────────────────────────┤`);
+  console.log(line(`Installed: ${summary.installed}`));
+  console.log(line(`Connected: ${summary.connected}`));
+  console.log(line(`Routing Active: ${summary.routing}`));
+  console.log(line(`Verified: ${summary.verified}`));
+  console.log(line(`Next action: ${summary.nextAction}`));
+  console.log(`  └─────────────────────────────────────────────┘`);
+}
+
+async function main() {
+  // Read config with integrity checking
+  const config = loadConfig();
+  if (!config) {
+    printHealthSummary({
+      installed: 'Missing',
+      connected: 'Not connected',
+      routing: 'Inactive',
+      verified: 'Not run',
+      nextAction: 'Run /plexor-setup'
+    });
     process.exit(1);
   }
 
@@ -66,21 +203,42 @@ async function main() {
   const provider = config.settings?.preferred_provider || 'auto';
   const localCache = config.settings?.localCacheEnabled ?? false;
   const apiUrl = config.settings?.apiUrl || 'https://api.plexor.dev';
+  const verification = config.health || {};
 
   if (!apiKey) {
-    console.log('Not authenticated. Run /plexor-login first.');
+    printHealthSummary({
+      installed: 'OK',
+      connected: 'Missing key',
+      routing: 'Inactive',
+      verified: 'Not run',
+      nextAction: 'Run /plexor-setup'
+    });
+    process.exit(1);
+  }
+
+  // Validate API key format
+  if (!isValidApiKeyFormat(apiKey)) {
+    printHealthSummary({
+      installed: 'OK',
+      connected: 'Invalid key',
+      routing: 'Needs repair',
+      verified: 'Failed',
+      nextAction: 'Run /plexor-setup'
+    });
     process.exit(1);
   }
 
   // Fetch user info and stats
   let user = { email: 'Unknown', tier: { name: 'Free', limits: {} } };
   let stats = { period: {}, summary: {} };
+  let userFetchWorked = false;
 
   try {
     [user, stats] = await Promise.all([
       fetchJson(apiUrl, '/v1/user', apiKey),
       fetchJson(apiUrl, '/v1/stats', apiKey)
     ]);
+    userFetchWorked = true;
   } catch (err) {
     // Continue with defaults if API fails
   }
@@ -114,15 +272,17 @@ async function main() {
   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
+  // Build dashboard URL from API URL.
+  // Staging uses a separate dashboard host.
   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`;
+    if (url.hostname.includes('staging.api.plexor.dev')) {
+      dashboardUrl = 'https://staging.plexorlabs.com/dashboard';
+    } else {
+      const host = url.hostname.replace(/^api\./, '').replace(/\.api\./, '.');
+      dashboardUrl = `${url.protocol}//${host}/dashboard`;
+    }
   } catch {
     // If URL parsing fails, use default
   }
@@ -164,6 +324,38 @@ ${line(`└── Cost saved: $${sessionCostSaved}`)}
   const routing = getRoutingStatus();
   const routingIndicator = routing.active ? '🟢 PLEXOR MODE: ON' : '🔴 PLEXOR MODE: OFF';
   const envLabel = routing.isStaging ? '(staging)' : '(production)';
+  const partialState = detectPartialState();
+  const stateMismatch = checkStateMismatch(enabled, routing.active);
+  const connectedState = userFetchWorked ? 'OK' : 'Unknown';
+  const verifiedState = verification.verified
+    ? 'OK'
+    : (verification.verify_error ? 'Failed' : 'Not yet');
+  const nextAction = !routing.active || partialState.partial || stateMismatch || !verification.verified
+    ? '/plexor-setup'
+    : '/plexor-status';
+
+  // Note: Environment mismatch warning removed - it caused false positives during
+  // concurrent operations and transient states. The partial state and config/routing
+  // mismatch warnings below provide more actionable feedback.
+
+  printHealthSummary({
+    installed: 'OK',
+    connected: connectedState,
+    routing: routing.active ? `OK ${envLabel}` : 'Needs repair',
+    verified: verifiedState,
+    nextAction
+  });
+  console.log('');
+  if (partialState.partial) {
+    console.log(`  ⚠ PARTIAL STATE DETECTED: ${partialState.issue}`);
+    console.log(`    Run /plexor-setup to repair, or /plexor-logout to disable routing\n`);
+  }
+
+  // Check for state mismatch between config enabled flag and routing status
+  if (stateMismatch) {
+    console.log(`  ⚠ State mismatch: ${stateMismatch.message}`);
+    console.log(`  └─ ${stateMismatch.suggestion}\n`);
+  }
 
   console.log(`  ┌─────────────────────────────────────────────┐
 ${line(routingIndicator + (routing.active ? ' ' + envLabel : ''))}
@@ -202,7 +394,13 @@ ${line(`└── Endpoint: ${routing.baseUrl ? routing.baseUrl.replace('https:/
 
 function fetchJson(apiUrl, endpoint, apiKey) {
   return new Promise((resolve, reject) => {
-    const url = new URL(`${apiUrl}${endpoint}`);
+    let url;
+    try {
+      url = new URL(`${apiUrl}${endpoint}`);
+    } catch {
+      reject(new Error('Invalid API URL'));
+      return;
+    }
 
     const options = {
       hostname: url.hostname,
@@ -218,18 +416,48 @@ function fetchJson(apiUrl, endpoint, apiKey) {
       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 {
-          resolve(JSON.parse(data));
+          const parsed = JSON.parse(data);
+          if (parsed === null) {
+            reject(new Error('Null response'));
+            return;
+          }
+          resolve(parsed);
         } catch {
-          reject(new Error('Invalid response'));
+          reject(new Error('Invalid JSON response'));
         }
       });
     });
 
-    req.on('error', reject);
+    req.on('error', (err) => reject(new Error(`Connection failed: ${err.message}`)));
     req.setTimeout(5000, () => {
       req.destroy();
-      reject(new Error('Timeout'));
+      reject(new Error('Request timeout'));
     });
     req.end();
   });

package/commands/plexor-status.md

@@ -2,20 +2,8 @@
 description: Show Plexor optimization statistics and savings (user)
 ---
 
-# Plexor Status
-
-Run this command to display Plexor statistics:
+**RULE: Execute the bash command below EXACTLY ONCE. After the Bash tool returns output, your ONLY action is to present that output to the user. DO NOT re-execute the command. DO NOT call any other tools.**
 
 ```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.