@plexor-dev/claude-code-plugin 0.1.0-beta.3 → 0.1.0-beta.31

package/README.md

@@ -32,14 +32,11 @@ This installs slash commands to `~/.claude/commands/`.
 
 | Command | Description |
 |---------|-------------|
-| `/plexor-login` | Authenticate with Plexor |
-| `/plexor-status` | View usage stats and savings |
-| `/plexor-mode` | Set optimization mode (eco/balanced/quality/passthrough) |
-| `/plexor-provider` | Force specific provider (auto/claude/deepseek/mistral/gemini) |
-| `/plexor-config` | Quick config (enable/disable/cache/reset) |
-| `/plexor-settings` | Advanced settings (API URL, mode, provider) |
-| `/plexor-enabled` | Enable/disable the proxy |
+| `/plexor-setup` | First-time setup wizard |
+| `/plexor-login` | Authenticate with Plexor API key |
 | `/plexor-logout` | Sign out and clear credentials |
+| `/plexor-status` | View usage stats and savings |
+| `/plexor-enabled` | Enable/disable Plexor routing |
 
 ## How It Works
 

package/commands/plexor-enabled.js

@@ -0,0 +1,221 @@
+#!/usr/bin/env node
+
+/**
+ * Plexor Enabled Command
+ * Enable or disable Plexor optimization proxy
+ *
+ * KEY FEATURE: When toggling on/off, automatically updates ~/.claude/settings.json
+ * to route or un-route ALL Claude Code sessions through Plexor gateway.
+ *
+ * THE DREAM: User just runs "/plexor-enabled off" to disable, "/plexor-enabled on" to enable.
+ * No manual environment variables or config updates required!
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+// Import settings manager with error handling for missing lib
+let settingsManager, PLEXOR_STAGING_URL, PLEXOR_PROD_URL;
+try {
+  const lib = require('../lib/settings-manager');
+  settingsManager = lib.settingsManager;
+  PLEXOR_STAGING_URL = lib.PLEXOR_STAGING_URL;
+  PLEXOR_PROD_URL = lib.PLEXOR_PROD_URL;
+} catch (err) {
+  if (err.code === 'MODULE_NOT_FOUND') {
+    console.error('Error: Plexor plugin files are missing or corrupted.');
+    console.error('       Please reinstall: npm install @plexor-dev/claude-code-plugin');
+    process.exit(1);
+  }
+  throw err;
+}
+
+const CONFIG_PATH = path.join(process.env.HOME, '.plexor', 'config.json');
+const PLEXOR_DIR = path.join(process.env.HOME, '.plexor');
+
+function loadConfig() {
+  try {
+    if (!fs.existsSync(CONFIG_PATH)) {
+      return { version: 1, auth: {}, settings: {} };
+    }
+    const data = fs.readFileSync(CONFIG_PATH, 'utf8');
+    if (!data || data.trim() === '') {
+      return { version: 1, auth: {}, settings: {} };
+    }
+    const config = JSON.parse(data);
+    if (typeof config !== 'object' || config === null) {
+      console.warn('Warning: Config file has invalid format, using defaults');
+      return { version: 1, auth: {}, settings: {} };
+    }
+    return config;
+  } catch (err) {
+    if (err instanceof SyntaxError) {
+      console.warn('Warning: Config file is corrupted, using defaults');
+      // Backup corrupted file
+      try {
+        fs.copyFileSync(CONFIG_PATH, CONFIG_PATH + '.corrupted');
+      } catch { /* ignore */ }
+    }
+    return { version: 1, auth: {}, settings: {} };
+  }
+}
+
+function saveConfig(config) {
+  try {
+    if (!fs.existsSync(PLEXOR_DIR)) {
+      fs.mkdirSync(PLEXOR_DIR, { recursive: true, mode: 0o700 });
+    }
+
+    // Atomic write: write to temp file, then rename
+    const crypto = require('crypto');
+    const tempId = crypto.randomBytes(8).toString('hex');
+    const tempPath = path.join(PLEXOR_DIR, `.config.${tempId}.tmp`);
+
+    fs.writeFileSync(tempPath, JSON.stringify(config, null, 2), { mode: 0o600 });
+    fs.renameSync(tempPath, CONFIG_PATH);
+    return true;
+  } catch (err) {
+    if (err.code === 'EACCES' || err.code === 'EPERM') {
+      console.error(`Error: Cannot write to ~/.plexor/config.json`);
+      console.error('       Check file permissions or run with appropriate access.');
+    } else {
+      console.error('Failed to save config:', err.message);
+    }
+    return false;
+  }
+}
+
+/**
+ * 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;
+}
+
+function main() {
+  const args = process.argv.slice(2);
+  const config = loadConfig();
+  const currentEnabled = config.settings?.enabled ?? false;
+  const apiKey = config.auth?.api_key;
+
+  // Get current Claude settings.json routing status
+  const routingStatus = settingsManager.getRoutingStatus();
+
+  // No args - show current status
+  if (args.length === 0) {
+    const status = currentEnabled ? '● Enabled' : '○ Disabled';
+    const routingStr = routingStatus.enabled ? '● Active' : '○ Inactive';
+    console.log(`┌─────────────────────────────────────────────┐`);
+    console.log(`│  Plexor Proxy Status                        │`);
+    console.log(`├─────────────────────────────────────────────┤`);
+    console.log(`│  Plugin Config: ${status.padEnd(27)}│`);
+    console.log(`│  Claude Routing: ${routingStr.padEnd(26)}│`);
+    if (routingStatus.enabled) {
+    console.log(`│  Endpoint: ${(routingStatus.isStaging ? 'Staging' : 'Production').padEnd(32)}│`);
+    }
+    console.log(`├─────────────────────────────────────────────┤`);
+    console.log(`│  Usage:                                     │`);
+    console.log(`│    /plexor-enabled true   - Enable proxy    │`);
+    console.log(`│    /plexor-enabled false  - Disable proxy   │`);
+    console.log(`│    /plexor-enabled on     - Enable proxy    │`);
+    console.log(`│    /plexor-enabled off    - Disable proxy   │`);
+    console.log(`└─────────────────────────────────────────────┘`);
+    return;
+  }
+
+  const arg = args[0].toLowerCase();
+  let newEnabled;
+
+  if (['true', 'on', 'yes', '1', 'enable'].includes(arg)) {
+    newEnabled = true;
+  } else if (['false', 'off', 'no', '0', 'disable'].includes(arg)) {
+    newEnabled = false;
+  } else {
+    console.error(`Error: Invalid value "${args[0]}"`);
+    console.error(`Use: true/false, on/off, yes/no, enable/disable`);
+    process.exit(1);
+  }
+
+  // THE KEY FEATURE: Update Claude Code settings.json routing
+  let routingUpdated = false;
+  let missingApiKey = false;
+  let invalidApiKey = false;
+
+  if (newEnabled) {
+    // Enable routing - need valid API key from config
+    if (!apiKey) {
+      missingApiKey = true;
+    } else if (!isValidApiKeyFormat(apiKey)) {
+      invalidApiKey = true;
+    } else {
+      // Update Plexor plugin config first
+      config.settings = config.settings || {};
+      config.settings.enabled = newEnabled;
+      if (!saveConfig(config)) {
+        process.exit(1);
+      }
+
+      // PRODUCTION PACKAGE - uses production API
+      const apiUrl = config.settings?.apiUrl || 'https://api.plexor.dev';
+      const useStaging = apiUrl.includes('staging');
+      routingUpdated = settingsManager.enablePlexorRouting(apiKey, { useStaging });
+    }
+  } else {
+    // Update Plexor plugin config
+    config.settings = config.settings || {};
+    config.settings.enabled = newEnabled;
+    if (!saveConfig(config)) {
+      process.exit(1);
+    }
+
+    // Disable routing - remove env vars from settings.json
+    routingUpdated = settingsManager.disablePlexorRouting();
+  }
+
+  // Show error if no API key when enabling
+  if (missingApiKey) {
+    console.log(`┌─────────────────────────────────────────────┐`);
+    console.log(`│  ✗ Cannot Enable Plexor                     │`);
+    console.log(`├─────────────────────────────────────────────┤`);
+    console.log(`│  No API key configured.                     │`);
+    console.log(`│  Run /plexor-login <api-key> first.         │`);
+    console.log(`├─────────────────────────────────────────────┤`);
+    console.log(`│  Get your API key at:                       │`);
+    console.log(`│  https://plexor.dev/dashboard/api-keys      │`);
+    console.log(`└─────────────────────────────────────────────┘`);
+    process.exit(1);
+  }
+
+  // Show error if API key format is invalid
+  if (invalidApiKey) {
+    console.log(`┌─────────────────────────────────────────────┐`);
+    console.log(`│  ✗ Cannot Enable Plexor                     │`);
+    console.log(`├─────────────────────────────────────────────┤`);
+    console.log(`│  Invalid API key format in config.          │`);
+    console.log(`│  Keys must start with "plx_" (20+ chars).   │`);
+    console.log(`├─────────────────────────────────────────────┤`);
+    console.log(`│  Run /plexor-login <api-key> to fix.        │`);
+    console.log(`└─────────────────────────────────────────────┘`);
+    process.exit(1);
+  }
+
+  const newStatus = newEnabled ? '● Enabled' : '○ Disabled';
+  const prevStatus = currentEnabled ? 'Enabled' : 'Disabled';
+  const routingMsg = routingUpdated
+    ? (newEnabled ? 'Claude Code now routes through Plexor' : 'Claude Code now connects directly')
+    : 'Manual routing update may be needed';
+
+  console.log(`┌─────────────────────────────────────────────┐`);
+  console.log(`│  ✓ Plexor Proxy Updated                     │`);
+  console.log(`├─────────────────────────────────────────────┤`);
+  console.log(`│  Previous: ${prevStatus.padEnd(32)}│`);
+  console.log(`│  New: ${newStatus.padEnd(37)}│`);
+  console.log(`├─────────────────────────────────────────────┤`);
+  console.log(`│  ${routingMsg.padEnd(42)}│`);
+  console.log(`│  Changes take effect immediately.           │`);
+  console.log(`└─────────────────────────────────────────────┘`);
+}
+
+main();

package/commands/plexor-enabled.md

@@ -4,51 +4,25 @@ description: Enable or disable Plexor proxy (routes all traffic through Plexor A
 
 # Plexor Enabled
 
-Toggle Plexor proxy mode on or off.
+Run this command to view or toggle the Plexor proxy:
 
-## Steps
-
-**Step 1: Read current configuration**
-
-Use the Read tool to read `~/.plexor/config.json` and check the current `enabled` status.
-
-**Step 2: Ask user what they want to do**
-
-Use the `AskUserQuestion` tool to present options:
-
-Question: "Enable or disable Plexor proxy?"
-Header: "Proxy"
-Options:
-1. **Enable** - Route traffic through Plexor for optimization (60-90% cost savings)
-2. **Disable** - Direct to Anthropic (no optimization, full price)
-
-**Step 3: Update the configuration**
-
-Use the Read tool to get the current config, then use the Write tool to update `~/.plexor/config.json`:
-- If **Enable**: Set `"enabled": true`
-- If **Disable**: Set `"enabled": false`
-
-Keep all other settings unchanged.
-
-**Step 4: Show confirmation**
-
-If **Enabled**:
+```bash
+node ~/.claude/plugins/plexor/commands/plexor-enabled.js
 ```
-Plexor Proxy: ENABLED
 
-Benefits:
-- 60-90% cost reduction via intelligent provider routing
-- Automatic selection of Mistral/DeepSeek/Gemini based on task
-- Usage tracking and savings analytics
+To enable or disable, pass an argument:
 
-Your prompts will now be routed through Plexor for optimization.
-Run /plexor-status to see your savings.
+```bash
+node ~/.claude/plugins/plexor/commands/plexor-enabled.js true
+node ~/.claude/plugins/plexor/commands/plexor-enabled.js false
 ```
 
-If **Disabled**:
-```
-Plexor Proxy: DISABLED
+Use the Bash tool to execute this command.
 
-Your prompts will go directly to Anthropic at full price.
-Run /plexor-enabled to re-enable optimization.
-```
+**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/commands/plexor-login.js

@@ -0,0 +1,218 @@
+#!/usr/bin/env node
+
+/**
+ * Plexor Login Command
+ * Authenticate with Plexor API and auto-configure Claude Code routing
+ *
+ * KEY FEATURE: After successful login, automatically configures ~/.claude/settings.json
+ * to route ALL Claude Code sessions through Plexor gateway.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const https = require('https');
+const http = require('http');
+
+// Import settings manager with error handling for missing lib
+let settingsManager;
+try {
+  settingsManager = require('../lib/settings-manager').settingsManager;
+} catch (err) {
+  if (err.code === 'MODULE_NOT_FOUND') {
+    console.error('Error: Plexor plugin files are missing or corrupted.');
+    console.error('       Please reinstall: npm install @plexor-dev/claude-code-plugin');
+    process.exit(1);
+  }
+  throw err;
+}
+
+const CONFIG_PATH = path.join(process.env.HOME, '.plexor', 'config.json');
+const PLEXOR_DIR = path.join(process.env.HOME, '.plexor');
+// PRODUCTION PACKAGE - uses production API
+const DEFAULT_API_URL = 'https://api.plexor.dev';
+
+function loadConfig() {
+  try {
+    if (!fs.existsSync(CONFIG_PATH)) {
+      return { version: 1, auth: {}, settings: {} };
+    }
+    const data = fs.readFileSync(CONFIG_PATH, 'utf8');
+    if (!data || data.trim() === '') {
+      return { version: 1, auth: {}, settings: {} };
+    }
+    const config = JSON.parse(data);
+    if (typeof config !== 'object' || config === null) {
+      return { version: 1, auth: {}, settings: {} };
+    }
+    return config;
+  } catch (err) {
+    if (err instanceof SyntaxError) {
+      console.warn('Warning: Config file is corrupted, will be overwritten');
+    }
+    return { version: 1, auth: {}, settings: {} };
+  }
+}
+
+function saveConfig(config) {
+  try {
+    if (!fs.existsSync(PLEXOR_DIR)) {
+      fs.mkdirSync(PLEXOR_DIR, { recursive: true, mode: 0o700 });
+    }
+
+    // Atomic write: write to temp file, then rename
+    const crypto = require('crypto');
+    const tempId = crypto.randomBytes(8).toString('hex');
+    const tempPath = path.join(PLEXOR_DIR, `.config.${tempId}.tmp`);
+
+    fs.writeFileSync(tempPath, JSON.stringify(config, null, 2), { mode: 0o600 });
+    fs.renameSync(tempPath, CONFIG_PATH);
+    return true;
+  } catch (err) {
+    if (err.code === 'EACCES' || err.code === 'EPERM') {
+      console.error('Error: Cannot write to ~/.plexor/config.json');
+      console.error('       Check file permissions or run with appropriate access.');
+    } else {
+      console.error('Failed to save config:', err.message);
+    }
+    return false;
+  }
+}
+
+function validateApiKey(apiUrl, apiKey) {
+  return new Promise((resolve, reject) => {
+    const url = new URL(`${apiUrl}/v1/user`);
+    const isHttps = url.protocol === 'https:';
+    const lib = isHttps ? https : http;
+
+    const options = {
+      hostname: url.hostname,
+      port: url.port || (isHttps ? 443 : 80),
+      path: url.pathname,
+      method: 'GET',
+      headers: {
+        'X-Plexor-Key': apiKey
+      }
+    };
+
+    const req = lib.request(options, (res) => {
+      let data = '';
+      res.on('data', chunk => data += chunk);
+      res.on('end', () => {
+        if (res.statusCode === 200) {
+          try {
+            resolve(JSON.parse(data));
+          } catch {
+            reject(new Error('Invalid response from server'));
+          }
+        } else if (res.statusCode === 401) {
+          reject(new Error('Invalid API key'));
+        } else {
+          reject(new Error(`Server error: ${res.statusCode}`));
+        }
+      });
+    });
+
+    req.on('error', (err) => reject(new Error(`Connection failed: ${err.message}`)));
+    req.setTimeout(10000, () => {
+      req.destroy();
+      reject(new Error('Connection timeout'));
+    });
+    req.end();
+  });
+}
+
+async function main() {
+  const args = process.argv.slice(2);
+  let apiKey = args[0];
+
+  // Check for existing login
+  const config = loadConfig();
+  const existingKey = config.auth?.api_key;
+
+  if (existingKey && !apiKey) {
+    console.log(`┌─────────────────────────────────────────────┐`);
+    console.log(`│  Already Logged In                          │`);
+    console.log(`├─────────────────────────────────────────────┤`);
+    console.log(`│  API Key: ${(existingKey.substring(0, 8) + '...').padEnd(33)}│`);
+    console.log(`│  To re-login, provide a new key:            │`);
+    console.log(`│    /plexor-login <api-key>                  │`);
+    console.log(`│  To logout:                                 │`);
+    console.log(`│    /plexor-logout                           │`);
+    console.log(`└─────────────────────────────────────────────┘`);
+    return;
+  }
+
+  // If no key provided, prompt for it
+  if (!apiKey) {
+    console.log(`┌─────────────────────────────────────────────┐`);
+    console.log(`│  Plexor Login                               │`);
+    console.log(`├─────────────────────────────────────────────┤`);
+    console.log(`│  Get your API key at:                       │`);
+    console.log(`│  https://plexor.dev/dashboard/api-keys      │`);
+    console.log(`├─────────────────────────────────────────────┤`);
+    console.log(`│  Usage: /plexor-login <api-key>             │`);
+    console.log(`└─────────────────────────────────────────────┘`);
+    return;
+  }
+
+  // Validate key format
+  if (!apiKey.startsWith('plx_') || apiKey.length < 20) {
+    console.error(`Error: Invalid API key format`);
+    console.error(`API keys start with "plx_" and are at least 20 characters`);
+    process.exit(1);
+  }
+
+  const apiUrl = config.settings?.apiUrl || DEFAULT_API_URL;
+
+  console.log('Validating API key...');
+
+  try {
+    const user = await validateApiKey(apiUrl, apiKey);
+
+    config.auth = config.auth || {};
+    config.auth.api_key = apiKey;
+    config.settings = config.settings || {};
+    config.settings.enabled = true;
+    if (!saveConfig(config)) {
+      process.exit(1);
+    }
+
+    // AUTO-CONFIGURE CLAUDE CODE ROUTING
+    // This is the key feature: automatically set ANTHROPIC_BASE_URL and ANTHROPIC_AUTH_TOKEN
+    // in ~/.claude/settings.json so ALL Claude Code sessions route through Plexor
+    const useStaging = apiUrl.includes('staging');
+    const routingEnabled = settingsManager.enablePlexorRouting(apiKey, { useStaging });
+
+    const email = user.email || 'Unknown';
+    const tier = user.tier?.name || 'Free';
+
+    console.log(`┌─────────────────────────────────────────────┐`);
+    console.log(`│  ✓ Login Successful                         │`);
+    console.log(`├─────────────────────────────────────────────┤`);
+    console.log(`│  Email: ${email.substring(0, 35).padEnd(35)}│`);
+    console.log(`│  Tier: ${tier.padEnd(36)}│`);
+    console.log(`├─────────────────────────────────────────────┤`);
+    if (routingEnabled) {
+    console.log(`│  ✓ Claude Code routing: CONFIGURED          │`);
+    console.log(`│    All sessions now route through Plexor    │`);
+    } else {
+    console.log(`│  ⚠ Claude Code routing: MANUAL SETUP NEEDED │`);
+    console.log(`│    Set ANTHROPIC_BASE_URL in environment    │`);
+    }
+    console.log(`├─────────────────────────────────────────────┤`);
+    console.log(`│  Run /plexor-status to see your stats.      │`);
+    console.log(`└─────────────────────────────────────────────┘`);
+  } catch (err) {
+    console.error(`┌─────────────────────────────────────────────┐`);
+    console.error(`│  ✗ Login Failed                             │`);
+    console.error(`├─────────────────────────────────────────────┤`);
+    console.error(`│  ${err.message.padEnd(42)}│`);
+    console.error(`└─────────────────────────────────────────────┘`);
+    process.exit(1);
+  }
+}
+
+main().catch(err => {
+  console.error('Error:', err.message);
+  process.exit(1);
+});

package/commands/plexor-login.md

@@ -4,73 +4,24 @@ description: Authenticate with Plexor to enable optimization (user)
 
 # Plexor Login
 
-Authenticate with your Plexor account to enable LLM cost optimization.
+Run this command to authenticate with Plexor:
 
-## Steps
-
-**Step 1: Check existing authentication**
-
-Use the Read tool to read `~/.plexor/config.json`.
-
-If the file exists and has an `apiKey` field that starts with "plx_", the user is already authenticated. Show them:
-```
-Plexor Login
-============
-Already authenticated!
-API Key: plx_****[last 4 chars]
-API URL: [apiUrl from config]
-Status: [Enabled/Disabled]
-
-Run /plexor-status to see your usage statistics.
-Run /plexor-logout to sign out.
+```bash
+node ~/.claude/plugins/plexor/commands/plexor-login.js
 ```
 
-**Step 2: If not authenticated, ask for API key**
-
-Ask the user to provide their Plexor API key. They can get one from:
-- https://plexor.dev/dashboard (if they have an account)
-- https://plexor.dev/signup (to create an account)
-
-Tell them: "Please provide your Plexor API key (starts with 'plx_'):"
-
-**Step 3: Save the configuration**
-
-Once the user provides an API key, use the Write tool to create/update `~/.plexor/config.json`:
+To login with an API key:
 
-```json
-{
-  "enabled": true,
-  "apiUrl": "https://api.plexor.dev",
-  "apiKey": "[user's API key]",
-  "mode": "balanced",
-  "preferredProvider": "auto",
-  "localCacheEnabled": true,
-  "timeout": 5000
-}
+```bash
+node ~/.claude/plugins/plexor/commands/plexor-login.js plx_your_api_key_here
 ```
 
-**Step 4: Verify the key works**
+Use the Bash tool to execute this command.
 
-Make a test request to verify authentication:
-```
-GET https://api.plexor.dev/api/users/me
-Authorization: Bearer [apiKey]
-```
-
-If successful, show:
-```
-Plexor Login
-============
-Authentication successful!
-
-Your API key has been saved to ~/.plexor/config.json
-
-Next steps:
-1. Run /plexor-status to see your usage
-2. Run /plexor-enabled true to enable the proxy
-3. Start saving on LLM costs!
-
-Dashboard: https://plexor.dev/dashboard
-```
+**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
 
-If the API call fails, tell the user the key may be invalid and ask them to check it.
+The command output is the complete response. Simply show the output and wait for the user's next input.