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

package/commands/plexor-config.js

@@ -0,0 +1,170 @@
+#!/usr/bin/env node
+
+/**
+ * Plexor Config Command
+ * Display raw configuration (for debugging)
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const CONFIG_PATH = path.join(process.env.HOME, '.plexor', 'config.json');
+const SESSION_PATH = path.join(process.env.HOME, '.plexor', 'session.json');
+const CACHE_PATH = path.join(process.env.HOME, '.plexor', 'cache.json');
+const PLEXOR_DIR = path.join(process.env.HOME, '.plexor');
+
+function fileExists(filePath) {
+  try {
+    return fs.existsSync(filePath);
+  } catch {
+    return false;
+  }
+}
+
+function getFileSize(filePath) {
+  try {
+    const stats = fs.statSync(filePath);
+    return stats.size;
+  } catch {
+    return 0;
+  }
+}
+
+function formatBytes(bytes) {
+  if (bytes === 0) return '0 B';
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+
+function loadConfig() {
+  try {
+    if (!fs.existsSync(CONFIG_PATH)) {
+      return { error: 'not_found', message: 'Config file does not exist' };
+    }
+    const data = fs.readFileSync(CONFIG_PATH, 'utf8');
+    return { config: JSON.parse(data) };
+  } catch (err) {
+    if (err.code === 'ENOENT') {
+      return { error: 'not_found', message: 'Config file does not exist' };
+    }
+    if (err.code === 'EACCES') {
+      return { error: 'permission', message: 'Permission denied reading config' };
+    }
+    if (err instanceof SyntaxError) {
+      return { error: 'invalid_json', message: 'Config file contains invalid JSON' };
+    }
+    return { error: 'unknown', message: err.message };
+  }
+}
+
+function maskApiKey(key) {
+  if (!key) return 'not set';
+  if (key.length <= 12) return '***masked***';
+  return key.substring(0, 8) + '...' + key.substring(key.length - 4);
+}
+
+function main() {
+  const args = process.argv.slice(2);
+  const showRaw = args.includes('--raw') || args.includes('-r');
+  const showPaths = args.includes('--paths') || args.includes('-p');
+
+  // Show paths only
+  if (showPaths) {
+    console.log(`┌─────────────────────────────────────────────┐`);
+    console.log(`│  Plexor File Paths                          │`);
+    console.log(`├─────────────────────────────────────────────┤`);
+    console.log(`│  Directory: ${PLEXOR_DIR.substring(0, 31).padEnd(31)}│`);
+    console.log(`│  Config: ${CONFIG_PATH.substring(0, 34).padEnd(34)}│`);
+    console.log(`│  Session: ${SESSION_PATH.substring(0, 33).padEnd(33)}│`);
+    console.log(`│  Cache: ${CACHE_PATH.substring(0, 35).padEnd(35)}│`);
+    console.log(`└─────────────────────────────────────────────┘`);
+    return;
+  }
+
+  const result = loadConfig();
+
+  if (result.error) {
+    const errorMessages = {
+      not_found: 'Config file does not exist',
+      permission: 'Permission denied reading config file',
+      invalid_json: 'Config file contains invalid JSON (corrupted?)',
+      unknown: result.message || 'Unknown error'
+    };
+    const errorMsg = errorMessages[result.error] || result.message;
+    const suggestion = result.error === 'invalid_json'
+      ? 'Try: rm ~/.plexor/config.json && /plexor-login'
+      : 'Run /plexor-login to create configuration.';
+
+    console.log(`┌─────────────────────────────────────────────┐`);
+    console.log(`│  Configuration Error                        │`);
+    console.log(`├─────────────────────────────────────────────┤`);
+    console.log(`│  Error: ${result.error.padEnd(35)}│`);
+    console.log(`│  ${errorMsg.substring(0, 42).padEnd(42)}│`);
+    console.log(`├─────────────────────────────────────────────┤`);
+    console.log(`│  ${suggestion.substring(0, 42).padEnd(42)}│`);
+    console.log(`├─────────────────────────────────────────────┤`);
+    console.log(`│  Expected path:                             │`);
+    console.log(`│  ${CONFIG_PATH.substring(0, 42).padEnd(42)}│`);
+    console.log(`└─────────────────────────────────────────────┘`);
+    return;
+  }
+
+  const config = result.config;
+
+  // Show raw JSON
+  if (showRaw) {
+    // Mask API key in raw output
+    const safeConfig = JSON.parse(JSON.stringify(config));
+    if (safeConfig.auth?.api_key) {
+      safeConfig.auth.api_key = maskApiKey(safeConfig.auth.api_key);
+    }
+    console.log(JSON.stringify(safeConfig, null, 2));
+    return;
+  }
+
+  // Show formatted config info
+  const configSize = getFileSize(CONFIG_PATH);
+  const sessionSize = getFileSize(SESSION_PATH);
+  const cacheSize = getFileSize(CACHE_PATH);
+  const hasSession = fileExists(SESSION_PATH);
+  const hasCache = fileExists(CACHE_PATH);
+
+  console.log(`┌─────────────────────────────────────────────┐`);
+  console.log(`│  Plexor Configuration                       │`);
+  console.log(`├─────────────────────────────────────────────┤`);
+  console.log(`│  Version: ${(config.version || 1).toString().padEnd(33)}│`);
+  console.log(`├─────────────────────────────────────────────┤`);
+  console.log(`│  Authentication                             │`);
+  console.log(`│  └── API Key: ${maskApiKey(config.auth?.api_key).padEnd(29)}│`);
+  console.log(`├─────────────────────────────────────────────┤`);
+  console.log(`│  Settings                                   │`);
+
+  const settings = config.settings || {};
+  const settingEntries = [
+    ['enabled', settings.enabled ?? false],
+    ['mode', settings.mode || 'balanced'],
+    ['preferred_provider', settings.preferred_provider || 'auto'],
+    ['apiUrl', settings.apiUrl || 'https://api.plexor.dev'],
+    ['timeout', (settings.timeout || 5000) + 'ms'],
+    ['localCacheEnabled', settings.localCacheEnabled ?? false]
+  ];
+
+  for (const [key, value] of settingEntries) {
+    const displayValue = String(value).substring(0, 25);
+    console.log(`│  ├── ${key.padEnd(18)} ${displayValue.padEnd(18)}│`);
+  }
+
+  console.log(`├─────────────────────────────────────────────┤`);
+  console.log(`│  Files                                      │`);
+  console.log(`│  ├── config.json: ${formatBytes(configSize).padEnd(24)}│`);
+  console.log(`│  ├── session.json: ${(hasSession ? formatBytes(sessionSize) : 'not found').padEnd(23)}│`);
+  console.log(`│  └── cache.json: ${(hasCache ? formatBytes(cacheSize) : 'not found').padEnd(25)}│`);
+  console.log(`├─────────────────────────────────────────────┤`);
+  console.log(`│  Options:                                   │`);
+  console.log(`│    /plexor-config --raw    Show raw JSON    │`);
+  console.log(`│    /plexor-config --paths  Show file paths  │`);
+  console.log(`└─────────────────────────────────────────────┘`);
+}
+
+main();

package/commands/plexor-enabled.js

@@ -0,0 +1,91 @@
+#!/usr/bin/env node
+
+/**
+ * Plexor Enabled Command
+ * Enable or disable Plexor optimization proxy
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const CONFIG_PATH = path.join(process.env.HOME, '.plexor', 'config.json');
+const PLEXOR_DIR = path.join(process.env.HOME, '.plexor');
+
+function loadConfig() {
+  try {
+    const data = fs.readFileSync(CONFIG_PATH, 'utf8');
+    return JSON.parse(data);
+  } catch {
+    return { version: 1, auth: {}, settings: {} };
+  }
+}
+
+function saveConfig(config) {
+  if (!fs.existsSync(PLEXOR_DIR)) {
+    fs.mkdirSync(PLEXOR_DIR, { recursive: true, mode: 0o700 });
+  }
+  fs.writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2), { mode: 0o600 });
+}
+
+function main() {
+  const args = process.argv.slice(2);
+  const config = loadConfig();
+  const currentEnabled = config.settings?.enabled ?? false;
+
+  // No args - show current status
+  if (args.length === 0) {
+    const status = currentEnabled ? '● Enabled' : '○ Disabled';
+    console.log(`┌─────────────────────────────────────────────┐`);
+    console.log(`│  Plexor Proxy Status                        │`);
+    console.log(`├─────────────────────────────────────────────┤`);
+    console.log(`│  Status: ${status.padEnd(34)}│`);
+    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);
+  }
+
+  if (newEnabled === currentEnabled) {
+    const state = currentEnabled ? 'enabled' : 'disabled';
+    console.log(`Plexor proxy is already ${state}`);
+    return;
+  }
+
+  config.settings = config.settings || {};
+  config.settings.enabled = newEnabled;
+  saveConfig(config);
+
+  const newStatus = newEnabled ? '● Enabled' : '○ Disabled';
+  const prevStatus = currentEnabled ? 'Enabled' : 'Disabled';
+  const message = newEnabled
+    ? 'All requests will be routed through Plexor'
+    : 'Requests will go directly to providers';
+
+  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(`│  ${message.padEnd(42)}│`);
+  console.log(`└─────────────────────────────────────────────┘`);
+}
+
+main();

package/commands/plexor-login.js

@@ -0,0 +1,169 @@
+#!/usr/bin/env node
+
+/**
+ * Plexor Login Command
+ * Authenticate with Plexor API
+ */
+
+const fs = require('fs');
+const path = require('path');
+const https = require('https');
+const http = require('http');
+
+const CONFIG_PATH = path.join(process.env.HOME, '.plexor', 'config.json');
+const PLEXOR_DIR = path.join(process.env.HOME, '.plexor');
+const DEFAULT_API_URL = 'https://api.plexor.dev';
+
+function loadConfig() {
+  try {
+    const data = fs.readFileSync(CONFIG_PATH, 'utf8');
+    return JSON.parse(data);
+  } catch {
+    return { version: 1, auth: {}, settings: {} };
+  }
+}
+
+function saveConfig(config) {
+  if (!fs.existsSync(PLEXOR_DIR)) {
+    fs.mkdirSync(PLEXOR_DIR, { recursive: true, mode: 0o700 });
+  }
+  fs.writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2), { mode: 0o600 });
+}
+
+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 promptForApiKey() {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+
+  return new Promise((resolve) => {
+    rl.question('Enter your Plexor API key: ', (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+
+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;
+    saveConfig(config);
+
+    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(`├─────────────────────────────────────────────┤`);
+    console.log(`│  Plexor proxy is now enabled.               │`);
+    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-logout.js

@@ -0,0 +1,92 @@
+#!/usr/bin/env node
+
+/**
+ * Plexor Logout Command
+ * Clear Plexor credentials and disable proxy
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const PLEXOR_DIR = path.join(process.env.HOME, '.plexor');
+const CONFIG_PATH = path.join(PLEXOR_DIR, 'config.json');
+const SESSION_PATH = path.join(PLEXOR_DIR, 'session.json');
+const CACHE_PATH = path.join(PLEXOR_DIR, 'cache.json');
+
+function loadConfig() {
+  try {
+    const data = fs.readFileSync(CONFIG_PATH, 'utf8');
+    return JSON.parse(data);
+  } catch {
+    return null;
+  }
+}
+
+function saveConfig(config) {
+  if (!fs.existsSync(PLEXOR_DIR)) {
+    fs.mkdirSync(PLEXOR_DIR, { recursive: true, mode: 0o700 });
+  }
+  fs.writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2), { mode: 0o600 });
+}
+
+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;
+  saveConfig(config);
+
+  // 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(`│  ✓ Plexor proxy disabled                    │`);
+  console.log(`│  ✓ Session cleared                          │`);
+  if (clearCache) {
+    console.log(`│  ${cacheCleared ? '✓' : '○'} Cache cleared                            │`);
+  }
+  console.log(`├─────────────────────────────────────────────┤`);
+  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-mode.js

@@ -0,0 +1,107 @@
+#!/usr/bin/env node
+
+/**
+ * Plexor Mode Command
+ * Set optimization mode: eco, balanced, quality, passthrough
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const CONFIG_PATH = path.join(process.env.HOME, '.plexor', 'config.json');
+const PLEXOR_DIR = path.join(process.env.HOME, '.plexor');
+
+const VALID_MODES = ['eco', 'balanced', 'quality', 'passthrough'];
+
+const MODE_INFO = {
+  eco: {
+    description: 'Maximum savings (~$0.04/1M tokens)',
+    models: 'Ministral 3B, small models'
+  },
+  balanced: {
+    description: 'Good balance (~$0.15/1M tokens)',
+    models: 'DeepSeek, Gemini Flash, Mistral Small'
+  },
+  quality: {
+    description: 'Premium models (~$5/1M tokens)',
+    models: 'Claude Opus, Gemini Pro, Mistral Large'
+  },
+  passthrough: {
+    description: 'No optimization',
+    models: 'Direct to requested model'
+  }
+};
+
+function loadConfig() {
+  try {
+    const data = fs.readFileSync(CONFIG_PATH, 'utf8');
+    return JSON.parse(data);
+  } catch {
+    return { version: 1, auth: {}, settings: {} };
+  }
+}
+
+function saveConfig(config) {
+  if (!fs.existsSync(PLEXOR_DIR)) {
+    fs.mkdirSync(PLEXOR_DIR, { recursive: true, mode: 0o700 });
+  }
+  fs.writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2), { mode: 0o600 });
+}
+
+function main() {
+  const args = process.argv.slice(2);
+  const config = loadConfig();
+  const currentMode = config.settings?.mode || 'balanced';
+
+  // No args - show current mode and options
+  if (args.length === 0) {
+    console.log(`┌─────────────────────────────────────────────┐`);
+    console.log(`│  Plexor Optimization Mode                   │`);
+    console.log(`├─────────────────────────────────────────────┤`);
+    console.log(`│  Current: ${currentMode.padEnd(33)}│`);
+    console.log(`├─────────────────────────────────────────────┤`);
+    console.log(`│  Available modes:                           │`);
+
+    for (const mode of VALID_MODES) {
+      const marker = mode === currentMode ? '●' : '○';
+      const info = MODE_INFO[mode];
+      console.log(`│  ${marker} ${mode.padEnd(12)} ${info.description.substring(0, 26).padEnd(26)}│`);
+    }
+
+    console.log(`├─────────────────────────────────────────────┤`);
+    console.log(`│  Usage: /plexor-mode <mode>                 │`);
+    console.log(`│  Example: /plexor-mode eco                  │`);
+    console.log(`└─────────────────────────────────────────────┘`);
+    return;
+  }
+
+  const newMode = args[0].toLowerCase();
+
+  if (!VALID_MODES.includes(newMode)) {
+    console.error(`Error: Invalid mode "${newMode}"`);
+    console.error(`Valid modes: ${VALID_MODES.join(', ')}`);
+    process.exit(1);
+  }
+
+  if (newMode === currentMode) {
+    console.log(`Mode is already set to "${currentMode}"`);
+    return;
+  }
+
+  config.settings = config.settings || {};
+  config.settings.mode = newMode;
+  saveConfig(config);
+
+  const info = MODE_INFO[newMode];
+  console.log(`┌─────────────────────────────────────────────┐`);
+  console.log(`│  ✓ Mode Updated                             │`);
+  console.log(`├─────────────────────────────────────────────┤`);
+  console.log(`│  Previous: ${currentMode.padEnd(32)}│`);
+  console.log(`│  New: ${newMode.padEnd(37)}│`);
+  console.log(`├─────────────────────────────────────────────┤`);
+  console.log(`│  ${info.description.padEnd(42)}│`);
+  console.log(`│  Models: ${info.models.substring(0, 34).padEnd(34)}│`);
+  console.log(`└─────────────────────────────────────────────┘`);
+}
+
+main();

package/commands/plexor-provider.js

@@ -0,0 +1,110 @@
+#!/usr/bin/env node
+
+/**
+ * Plexor Provider Command
+ * Force a specific LLM provider
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const CONFIG_PATH = path.join(process.env.HOME, '.plexor', 'config.json');
+const PLEXOR_DIR = path.join(process.env.HOME, '.plexor');
+
+const VALID_PROVIDERS = ['auto', 'claude', 'anthropic', 'openai', 'deepseek', 'mistral', 'gemini', 'google'];
+
+const PROVIDER_INFO = {
+  auto: 'Automatic routing based on task and mode',
+  claude: 'Anthropic Claude models (alias for anthropic)',
+  anthropic: 'Anthropic Claude models',
+  openai: 'OpenAI GPT models',
+  deepseek: 'DeepSeek models (excellent for code)',
+  mistral: 'Mistral AI models',
+  gemini: 'Google Gemini models',
+  google: 'Google Gemini models (alias for gemini)'
+};
+
+function loadConfig() {
+  try {
+    const data = fs.readFileSync(CONFIG_PATH, 'utf8');
+    return JSON.parse(data);
+  } catch {
+    return { version: 1, auth: {}, settings: {} };
+  }
+}
+
+function saveConfig(config) {
+  if (!fs.existsSync(PLEXOR_DIR)) {
+    fs.mkdirSync(PLEXOR_DIR, { recursive: true, mode: 0o700 });
+  }
+  fs.writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2), { mode: 0o600 });
+}
+
+function normalizeProvider(provider) {
+  const normalized = provider.toLowerCase();
+  if (normalized === 'claude') return 'anthropic';
+  if (normalized === 'google') return 'gemini';
+  return normalized;
+}
+
+function main() {
+  const args = process.argv.slice(2);
+  const config = loadConfig();
+  const currentProvider = config.settings?.preferred_provider || 'auto';
+
+  // No args - show current provider and options
+  if (args.length === 0) {
+    console.log(`┌─────────────────────────────────────────────┐`);
+    console.log(`│  Plexor Provider Routing                    │`);
+    console.log(`├─────────────────────────────────────────────┤`);
+    console.log(`│  Current: ${currentProvider.padEnd(33)}│`);
+    console.log(`├─────────────────────────────────────────────┤`);
+    console.log(`│  Available providers:                       │`);
+
+    const displayProviders = ['auto', 'anthropic', 'openai', 'deepseek', 'mistral', 'gemini'];
+    for (const provider of displayProviders) {
+      const marker = provider === currentProvider ? '●' : '○';
+      const info = PROVIDER_INFO[provider];
+      console.log(`│  ${marker} ${provider.padEnd(10)} ${info.substring(0, 29).padEnd(29)}│`);
+    }
+
+    console.log(`├─────────────────────────────────────────────┤`);
+    console.log(`│  Usage: /plexor-provider <provider>         │`);
+    console.log(`│  Example: /plexor-provider deepseek         │`);
+    console.log(`│  Aliases: claude→anthropic, google→gemini   │`);
+    console.log(`└─────────────────────────────────────────────┘`);
+    return;
+  }
+
+  const inputProvider = args[0].toLowerCase();
+
+  if (!VALID_PROVIDERS.includes(inputProvider)) {
+    console.error(`Error: Invalid provider "${args[0]}"`);
+    console.error(`Valid providers: auto, anthropic, openai, deepseek, mistral, gemini`);
+    console.error(`Aliases: claude (→anthropic), google (→gemini)`);
+    process.exit(1);
+  }
+
+  const newProvider = normalizeProvider(inputProvider);
+
+  if (newProvider === currentProvider) {
+    console.log(`Provider is already set to "${currentProvider}"`);
+    return;
+  }
+
+  config.settings = config.settings || {};
+  config.settings.preferred_provider = newProvider;
+  saveConfig(config);
+
+  const info = PROVIDER_INFO[newProvider];
+  console.log(`┌─────────────────────────────────────────────┐`);
+  console.log(`│  ✓ Provider Updated                         │`);
+  console.log(`├─────────────────────────────────────────────┤`);
+  console.log(`│  Previous: ${currentProvider.padEnd(32)}│`);
+  console.log(`│  New: ${newProvider.padEnd(37)}│`);
+  console.log(`├─────────────────────────────────────────────┤`);
+  console.log(`│  ${info.padEnd(42)}│`);
+  console.log(`└─────────────────────────────────────────────┘`);
+}
+
+main();

package/commands/plexor-settings.js

@@ -0,0 +1,155 @@
+#!/usr/bin/env node
+
+/**
+ * Plexor Settings Command
+ * View and update Plexor configuration settings
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const CONFIG_PATH = path.join(process.env.HOME, '.plexor', 'config.json');
+const PLEXOR_DIR = path.join(process.env.HOME, '.plexor');
+
+const SETTING_KEYS = {
+  'api-url': 'apiUrl',
+  'apiurl': 'apiUrl',
+  'url': 'apiUrl',
+  'timeout': 'timeout',
+  'cache': 'localCacheEnabled',
+  'local-cache': 'localCacheEnabled'
+};
+
+function loadConfig() {
+  try {
+    const data = fs.readFileSync(CONFIG_PATH, 'utf8');
+    return JSON.parse(data);
+  } catch {
+    return { version: 1, auth: {}, settings: {} };
+  }
+}
+
+function saveConfig(config) {
+  if (!fs.existsSync(PLEXOR_DIR)) {
+    fs.mkdirSync(PLEXOR_DIR, { recursive: true, mode: 0o700 });
+  }
+  fs.writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2), { mode: 0o600 });
+}
+
+function parseValue(key, value) {
+  const normalizedKey = SETTING_KEYS[key.toLowerCase()] || key;
+
+  switch (normalizedKey) {
+    case 'localCacheEnabled':
+      return ['true', 'on', 'yes', '1'].includes(value.toLowerCase());
+    case 'timeout':
+      const num = parseInt(value, 10);
+      if (isNaN(num) || num < 1000 || num > 60000) {
+        throw new Error('Timeout must be between 1000-60000ms');
+      }
+      return num;
+    case 'apiUrl':
+      if (!value.startsWith('http://') && !value.startsWith('https://')) {
+        throw new Error('API URL must start with http:// or https://');
+      }
+      return value;
+    default:
+      return value;
+  }
+}
+
+function main() {
+  const args = process.argv.slice(2);
+  const config = loadConfig();
+  const settings = config.settings || {};
+
+  // No args - show current settings
+  if (args.length === 0) {
+    const enabled = settings.enabled ?? false;
+    const mode = settings.mode || 'balanced';
+    const provider = settings.preferred_provider || 'auto';
+    const apiUrl = settings.apiUrl || 'https://api.plexor.dev';
+    const timeout = settings.timeout || 5000;
+    const cache = settings.localCacheEnabled ?? false;
+    const hasApiKey = !!config.auth?.api_key;
+
+    console.log(`┌─────────────────────────────────────────────┐`);
+    console.log(`│  Plexor Settings                            │`);
+    console.log(`├─────────────────────────────────────────────┤`);
+    console.log(`│  Authentication                             │`);
+    console.log(`│  └── API Key: ${(hasApiKey ? 'Configured' : 'Not set').padEnd(29)}│`);
+    console.log(`├─────────────────────────────────────────────┤`);
+    console.log(`│  Proxy                                      │`);
+    console.log(`│  ├── Enabled: ${(enabled ? 'Yes' : 'No').padEnd(29)}│`);
+    console.log(`│  └── API URL: ${apiUrl.substring(0, 29).padEnd(29)}│`);
+    console.log(`├─────────────────────────────────────────────┤`);
+    console.log(`│  Optimization                               │`);
+    console.log(`│  ├── Mode: ${mode.padEnd(32)}│`);
+    console.log(`│  └── Provider: ${provider.padEnd(27)}│`);
+    console.log(`├─────────────────────────────────────────────┤`);
+    console.log(`│  Performance                                │`);
+    console.log(`│  ├── Local Cache: ${(cache ? 'Enabled' : 'Disabled').padEnd(24)}│`);
+    console.log(`│  └── Timeout: ${(timeout + 'ms').padEnd(29)}│`);
+    console.log(`├─────────────────────────────────────────────┤`);
+    console.log(`│  Modify settings:                           │`);
+    console.log(`│    /plexor-settings <key> <value>           │`);
+    console.log(`│                                             │`);
+    console.log(`│  Available keys:                            │`);
+    console.log(`│    api-url, timeout, cache                  │`);
+    console.log(`│                                             │`);
+    console.log(`│  Other commands:                            │`);
+    console.log(`│    /plexor-mode     - Set optimization mode │`);
+    console.log(`│    /plexor-provider - Set provider routing  │`);
+    console.log(`│    /plexor-enabled  - Enable/disable proxy  │`);
+    console.log(`└─────────────────────────────────────────────┘`);
+    return;
+  }
+
+  // Get setting
+  if (args.length === 1) {
+    const key = args[0].toLowerCase();
+    const normalizedKey = SETTING_KEYS[key] || key;
+    const value = settings[normalizedKey];
+
+    if (value === undefined) {
+      console.error(`Unknown setting: ${args[0]}`);
+      console.error(`Available: api-url, timeout, cache`);
+      process.exit(1);
+    }
+
+    console.log(`${normalizedKey}: ${value}`);
+    return;
+  }
+
+  // Set setting
+  const key = args[0].toLowerCase();
+  const normalizedKey = SETTING_KEYS[key];
+
+  if (!normalizedKey) {
+    console.error(`Unknown setting: ${args[0]}`);
+    console.error(`Available: api-url, timeout, cache`);
+    process.exit(1);
+  }
+
+  try {
+    const value = parseValue(key, args[1]);
+    const oldValue = settings[normalizedKey];
+
+    config.settings = config.settings || {};
+    config.settings[normalizedKey] = value;
+    saveConfig(config);
+
+    console.log(`┌─────────────────────────────────────────────┐`);
+    console.log(`│  ✓ Setting Updated                          │`);
+    console.log(`├─────────────────────────────────────────────┤`);
+    console.log(`│  Key: ${normalizedKey.padEnd(37)}│`);
+    console.log(`│  Previous: ${String(oldValue ?? 'not set').substring(0, 32).padEnd(32)}│`);
+    console.log(`│  New: ${String(value).substring(0, 37).padEnd(37)}│`);
+    console.log(`└─────────────────────────────────────────────┘`);
+  } catch (err) {
+    console.error(`Error: ${err.message}`);
+    process.exit(1);
+  }
+}
+
+main();

package/lib/plexor-client.js

@@ -31,7 +31,7 @@ class PlexorClient {
           'Content-Type': 'application/json',
           'X-API-Key': this.apiKey,
           'X-Plexor-Key': this.apiKey,
-          'User-Agent': 'plexor-claude-code-plugin/0.1.0'
+          'User-Agent': 'plexor-claude-code-plugin/0.1.0-beta.21'
         },
         timeout: this.timeout
       };

package/package.json

@@ -1,8 +1,18 @@
 {
   "name": "@plexor-dev/claude-code-plugin",
-  "version": "0.1.0-beta.20",
+  "version": "0.1.0-beta.21",
   "description": "LLM cost optimization plugin for Claude Code - Save up to 90% on AI costs",
   "main": "lib/constants.js",
+  "bin": {
+    "plexor-status": "./commands/plexor-status.js",
+    "plexor-mode": "./commands/plexor-mode.js",
+    "plexor-enabled": "./commands/plexor-enabled.js",
+    "plexor-provider": "./commands/plexor-provider.js",
+    "plexor-login": "./commands/plexor-login.js",
+    "plexor-logout": "./commands/plexor-logout.js",
+    "plexor-settings": "./commands/plexor-settings.js",
+    "plexor-config": "./commands/plexor-config.js"
+  },
   "scripts": {
     "postinstall": "node scripts/postinstall.js",
     "preuninstall": "node scripts/uninstall.js",