@plexor-dev/claude-code-plugin-localhost 0.1.0-localhost.1

package/commands/plexor-login.js

@@ -0,0 +1,283 @@
+#!/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 centralized constants with HOME directory validation
+const { PLEXOR_DIR, CONFIG_PATH, DEFAULT_API_URL } = require('../lib/constants');
+
+// 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-localhost');
+    process.exit(1);
+  }
+  throw err;
+}
+
+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();
+  });
+}
+
+/**
+ * Read API key from stdin (for piped input)
+ * @returns {Promise<string>} The API key read from stdin
+ */
+function readFromStdin() {
+  return new Promise((resolve, reject) => {
+    let data = '';
+    const timeout = setTimeout(() => {
+      reject(new Error('Timeout reading from stdin'));
+    }, 5000);
+
+    process.stdin.setEncoding('utf8');
+    process.stdin.on('data', (chunk) => {
+      data += chunk;
+    });
+    process.stdin.on('end', () => {
+      clearTimeout(timeout);
+      resolve(data.trim());
+    });
+    process.stdin.on('error', (err) => {
+      clearTimeout(timeout);
+      reject(err);
+    });
+    process.stdin.resume();
+  });
+}
+
+async function main() {
+  const args = process.argv.slice(2);
+  let apiKey = null;
+  let keySource = null;
+
+  // SECURITY FIX: Check for API key in order of preference
+  // 1. Environment variable (most secure for scripts/CI)
+  // 2. Stdin pipe (secure for interactive use)
+  // 3. Command line argument (warns about security risk)
+
+  // Check environment variable first (most secure)
+  if (process.env.PLEXOR_API_KEY) {
+    apiKey = process.env.PLEXOR_API_KEY;
+    keySource = 'environment';
+  }
+  // Check if stdin has data (piped input)
+  else if (!process.stdin.isTTY && args.length === 0) {
+    try {
+      apiKey = await readFromStdin();
+      keySource = 'stdin';
+    } catch {
+      // Stdin read failed, continue to check args
+    }
+  }
+  // Check command line argument (least secure - shows in ps)
+  else if (args[0]) {
+    apiKey = args[0];
+    keySource = 'argument';
+  }
+
+  // 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(`│    echo $PLEXOR_API_KEY | /plexor-login     │`);
+    console.log(`│  To logout:                                 │`);
+    console.log(`│    /plexor-logout                           │`);
+    console.log(`└─────────────────────────────────────────────┘`);
+    return;
+  }
+
+  // If no key provided, show secure usage options
+  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(`│  Secure usage (recommended):                │`);
+    console.log(`│    echo "plx_..." | /plexor-login           │`);
+    console.log(`│    PLEXOR_API_KEY=plx_... /plexor-login     │`);
+    console.log(`├─────────────────────────────────────────────┤`);
+    console.log(`│  Direct usage (visible in ps):              │`);
+    console.log(`│    /plexor-login <api-key>                  │`);
+    console.log(`└─────────────────────────────────────────────┘`);
+    return;
+  }
+
+  // Warn if API key was passed as command line argument
+  if (keySource === 'argument') {
+    console.log(`⚠ Security note: API key passed as argument is visible in`);
+    console.log(`  process list (ps aux). For better security, use:`);
+    console.log(`    echo "plx_..." | /plexor-login`);
+    console.log(`    PLEXOR_API_KEY=plx_... /plexor-login`);
+    console.log('');
+  }
+
+  // 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

@@ -0,0 +1,27 @@
+---
+description: Authenticate with Plexor to enable optimization (user)
+---
+
+# Plexor Login
+
+Run this command to authenticate with Plexor:
+
+```bash
+node ~/.claude/plugins/plexor/commands/plexor-login.js
+```
+
+To login with an API key:
+
+```bash
+node ~/.claude/plugins/plexor/commands/plexor-login.js plx_your_api_key_here
+```
+
+Use the Bash tool to execute this 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/commands/plexor-logout.js

@@ -0,0 +1,143 @@
+#!/usr/bin/env node
+
+/**
+ * Plexor Logout Command
+ * Clear Plexor credentials and disable proxy
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+// Import centralized constants with HOME directory validation
+const { PLEXOR_DIR, CONFIG_PATH, SESSION_PATH, CACHE_PATH } = require('../lib/constants');
+
+// Import settings manager for Claude Code routing cleanup
+let settingsManager;
+try {
+  const lib = require('../lib/settings-manager');
+  settingsManager = lib.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-staging');
+    process.exit(1);
+  }
+  throw err;
+}
+
+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.warn('Warning: Config file is corrupted');
+    }
+    return null;
+  }
+}
+
+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 deleteFile(filePath) {
+  try {
+    if (fs.existsSync(filePath)) {
+      fs.unlinkSync(filePath);
+      return true;
+    }
+  } catch {
+    // Ignore errors
+  }
+  return false;
+}
+
+function main() {
+  const args = process.argv.slice(2);
+  const config = loadConfig();
+
+  if (!config || !config.auth?.api_key) {
+    console.log(`┌─────────────────────────────────────────────┐`);
+    console.log(`│  Not Logged In                              │`);
+    console.log(`├─────────────────────────────────────────────┤`);
+    console.log(`│  No active Plexor session found.            │`);
+    console.log(`│  Run /plexor-login to authenticate.         │`);
+    console.log(`└─────────────────────────────────────────────┘`);
+    return;
+  }
+
+  const clearCache = args.includes('--clear-cache') || args.includes('-c');
+
+  // Clear credentials
+  delete config.auth.api_key;
+  config.settings = config.settings || {};
+  config.settings.enabled = false;
+  if (!saveConfig(config)) {
+    process.exit(1);
+  }
+
+  // CRITICAL FIX: Disable Claude Code routing in ~/.claude/settings.json
+  // This removes ANTHROPIC_BASE_URL and ANTHROPIC_AUTH_TOKEN so Claude Code
+  // no longer tries to route through Plexor with removed credentials
+  const routingDisabled = settingsManager.disablePlexorRouting();
+
+  // Clear session
+  deleteFile(SESSION_PATH);
+
+  // Optionally clear cache
+  let cacheCleared = false;
+  if (clearCache) {
+    cacheCleared = deleteFile(CACHE_PATH);
+  }
+
+  console.log(`┌─────────────────────────────────────────────┐`);
+  console.log(`│  ✓ Logged Out                               │`);
+  console.log(`├─────────────────────────────────────────────┤`);
+  console.log(`│  ✓ API key removed                          │`);
+  console.log(`│  ${routingDisabled ? '✓' : '○'} Claude Code routing disabled             │`);
+  console.log(`│  ✓ Session cleared                          │`);
+  if (clearCache) {
+    console.log(`│  ${cacheCleared ? '✓' : '○'} Cache cleared                            │`);
+  }
+  console.log(`├─────────────────────────────────────────────┤`);
+  console.log(`│  Claude Code now connects directly.         │`);
+  console.log(`│  Run /plexor-login to re-authenticate.      │`);
+  if (!clearCache) {
+    console.log(`│  Use --clear-cache to also clear cache.     │`);
+  }
+  console.log(`└─────────────────────────────────────────────┘`);
+}
+
+main();

package/commands/plexor-logout.md

@@ -0,0 +1,27 @@
+---
+description: Log out from Plexor and clear credentials (user)
+---
+
+# Plexor Logout
+
+Run this command to log out and clear credentials:
+
+```bash
+node ~/.claude/plugins/plexor/commands/plexor-logout.js
+```
+
+To also clear the cache:
+
+```bash
+node ~/.claude/plugins/plexor/commands/plexor-logout.js --clear-cache
+```
+
+Use the Bash tool to execute this 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/commands/plexor-setup.md

@@ -0,0 +1,172 @@
+---
+description: First-time setup wizard for Plexor with Claude Code (user)
+---
+
+# Plexor Setup Wizard
+
+Guide users through first-time Plexor setup. **No manual environment variable configuration required!**
+
+The plugin automatically configures `~/.claude/settings.json` to route all Claude Code sessions through Plexor.
+
+## Steps
+
+**Step 1: Check if already configured**
+
+Use the Read tool to check if `~/.plexor/config.json` exists and has valid configuration.
+Also check `~/.claude/settings.json` for routing status.
+
+If configured, show:
+```
+Plexor Setup
+============
+Already configured!
+
+API URL: [apiUrl from config]
+Mode: [mode from config]
+Status: [Enabled/Disabled]
+Claude Routing: [Active/Inactive]
+
+Run /plexor-status to see your usage.
+Run /plexor-settings to modify configuration.
+Run /plexor-enabled off to disable routing.
+```
+
+**Step 2: Ask about Claude subscription**
+
+Use the AskUserQuestion tool:
+
+Question: "How do you pay for Claude usage?"
+Header: "Billing"
+Options:
+1. **Claude MAX subscription (Pro/Team/Enterprise)** - I have a subscription and want Plexor for optimization & tracking (you'll still need a Plexor API key)
+2. **Pay-per-use via Plexor** - I want Plexor to handle billing and route to the cheapest provider
+
+**Step 3A: Claude MAX User Setup**
+
+If user selected "Yes, I have Claude MAX":
+
+1. Ask for their Plexor API key:
+   "Please provide your Plexor API key (starts with 'plx_')."
+   "Get one at: https://plexor.dev/dashboard"
+   "Your MAX subscription will be used for Claude - the Plexor key is for tracking/optimization."
+
+2. Use the Write tool to create `~/.plexor/config.json`:
+```json
+{
+  "version": 1,
+  "auth": {
+    "api_key": "[user's Plexor key]",
+    "mode": "oauth_passthrough",
+    "authenticated_at": "[current ISO timestamp]"
+  },
+  "settings": {
+    "enabled": true,
+    "apiUrl": "http://localhost:8000",
+    "mode": "balanced",
+    "localCacheEnabled": true
+  }
+}
+```
+
+3. Use the Write tool to update `~/.claude/settings.json` env block:
+```json
+{
+  "env": {
+    "ANTHROPIC_BASE_URL": "http://localhost:8000/gateway/anthropic",
+    "ANTHROPIC_AUTH_TOKEN": "[user's Plexor key]"
+  }
+}
+```
+Note: Preserve any existing settings, just add/update the env block.
+
+4. Show the user:
+```
+Plexor Setup - Claude MAX User
+==============================
+Setup Complete! No manual configuration needed.
+
+What was configured:
+- ~/.plexor/config.json (Plexor plugin settings)
+- ~/.claude/settings.json (automatic Claude Code routing)
+
+How it works:
+- All Claude Code sessions now route through Plexor
+- Your MAX subscription OAuth token is passed through
+- You keep your MAX benefits ($0 cost, 20x rate limits)
+- Plexor optimizes prompts and tracks usage
+
+Commands:
+- /plexor-status    - See your usage stats
+- /plexor-enabled off - Temporarily disable Plexor
+- /plexor-enabled on  - Re-enable Plexor
+
+Changes take effect immediately in all Claude Code sessions!
+```
+
+**Step 3B: API Key User Setup**
+
+If user selected "No, I'll use a Plexor API key":
+
+1. Ask for their Plexor API key:
+   "Please provide your Plexor API key (starts with 'plx_')."
+   "Get one at: https://plexor.dev/dashboard"
+
+2. Once they provide the key, use the Write tool to create `~/.plexor/config.json`:
+```json
+{
+  "version": 1,
+  "auth": {
+    "api_key": "[user's API key]",
+    "mode": "api_key",
+    "authenticated_at": "[current ISO timestamp]"
+  },
+  "settings": {
+    "enabled": true,
+    "apiUrl": "http://localhost:8000",
+    "preferred_provider": "auto",
+    "mode": "balanced",
+    "localCacheEnabled": true
+  }
+}
+```
+
+3. Use the Write tool to update `~/.claude/settings.json` env block:
+```json
+{
+  "env": {
+    "ANTHROPIC_BASE_URL": "http://localhost:8000/gateway/anthropic",
+    "ANTHROPIC_AUTH_TOKEN": "[user's Plexor key]"
+  }
+}
+```
+Note: Preserve any existing settings, just add/update the env block.
+
+4. Show the user:
+```
+Plexor Setup - API Key User
+===========================
+Setup Complete! No manual configuration needed.
+
+What was configured:
+- ~/.plexor/config.json (Plexor plugin settings)
+- ~/.claude/settings.json (automatic Claude Code routing)
+
+How it works:
+- All Claude Code sessions now route through Plexor
+- Plexor picks the best provider (can save up to 90%)
+- Your usage is tracked and optimized
+
+Commands:
+- /plexor-status    - See your usage and savings
+- /plexor-mode eco  - Maximize savings
+- /plexor-mode quality - Maximize quality
+- /plexor-enabled off - Temporarily disable Plexor
+
+Changes take effect immediately in all Claude Code sessions!
+```
+
+**IMPORTANT NOTES**:
+- The `~/.claude/settings.json` env block is the KEY mechanism that routes Claude Code through Plexor
+- ANTHROPIC_AUTH_TOKEN takes precedence over ANTHROPIC_API_KEY (use AUTH_TOKEN for the Plexor key)
+- Changes take effect immediately - no shell restart needed
+- After completing setup, STOP. Do not run additional commands.