@plexor-dev/claude-code-plugin-staging 0.1.0-beta.7 → 0.1.0-beta.8

package/commands/plexor-enabled.js

@@ -22,18 +22,53 @@ 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');
-    return JSON.parse(data);
-  } catch {
+    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) {
-  if (!fs.existsSync(PLEXOR_DIR)) {
-    fs.mkdirSync(PLEXOR_DIR, { recursive: true, mode: 0o700 });
+  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);
+  } catch (err) {
+    if (err.code === 'EACCES' || err.code === 'EPERM') {
+      console.error(`Error: Cannot write to ${CONFIG_PATH}`);
+      console.error('       Check file permissions or run with appropriate access.');
+    } else {
+      console.error('Failed to save config:', err.message);
+    }
+    throw err;
   }
-  fs.writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2), { mode: 0o600 });
 }
 
 function main() {
@@ -80,28 +115,49 @@ function main() {
     process.exit(1);
   }
 
-  // Update Plexor plugin config
-  config.settings = config.settings || {};
-  config.settings.enabled = newEnabled;
-  saveConfig(config);
-
   // THE KEY FEATURE: Update Claude Code settings.json routing
   let routingUpdated = false;
+  let missingApiKey = false;
+
   if (newEnabled) {
     // Enable routing - need API key from config
     if (apiKey) {
+      // Update Plexor plugin config first
+      config.settings = config.settings || {};
+      config.settings.enabled = newEnabled;
+      saveConfig(config);
+
       // STAGING PACKAGE - uses staging API
       const apiUrl = config.settings?.apiUrl || 'https://staging.api.plexor.dev';
       const useStaging = apiUrl.includes('staging');
       routingUpdated = settingsManager.enablePlexorRouting(apiKey, { useStaging });
     } else {
-      console.log('⚠ No API key found. Run /plexor-login first.');
+      missingApiKey = true;
     }
   } else {
+    // Update Plexor plugin config
+    config.settings = config.settings || {};
+    config.settings.enabled = newEnabled;
+    saveConfig(config);
+
     // 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);
+  }
+
   const newStatus = newEnabled ? '● Enabled' : '○ Disabled';
   const prevStatus = currentEnabled ? 'Enabled' : 'Disabled';
   const routingMsg = routingUpdated

package/commands/plexor-login.js

@@ -23,18 +23,48 @@ const DEFAULT_API_URL = 'https://staging.api.plexor.dev';
 
 function loadConfig() {
   try {
+    if (!fs.existsSync(CONFIG_PATH)) {
+      return { version: 1, auth: {}, settings: {} };
+    }
     const data = fs.readFileSync(CONFIG_PATH, 'utf8');
-    return JSON.parse(data);
-  } catch {
+    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) {
-  if (!fs.existsSync(PLEXOR_DIR)) {
-    fs.mkdirSync(PLEXOR_DIR, { recursive: true, mode: 0o700 });
+  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);
+  } catch (err) {
+    if (err.code === 'EACCES' || err.code === 'EPERM') {
+      console.error(`Error: Cannot write to ${CONFIG_PATH}`);
+      console.error('       Check file permissions or run with appropriate access.');
+    } else {
+      console.error('Failed to save config:', err.message);
+    }
+    throw err;
   }
-  fs.writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2), { mode: 0o600 });
 }
 
 function validateApiKey(apiUrl, apiKey) {

package/commands/plexor-status.js

@@ -49,13 +49,63 @@ 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) {
+    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;
+}
+
+async function main() {
+  // Read config with integrity checking
+  const config = loadConfig();
+  if (!config) {
     console.log('Not configured. Run /plexor-login first.');
     process.exit(1);
   }
@@ -72,6 +122,13 @@ async function main() {
     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: {} };
@@ -165,6 +222,16 @@ ${line(`└── Cost saved: $${sessionCostSaved}`)}
   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);
+  }
+
   console.log(`  ┌─────────────────────────────────────────────┐
 ${line(routingIndicator + (routing.active ? ' ' + envLabel : ''))}
   ├─────────────────────────────────────────────┤
@@ -202,7 +269,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 +291,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/lib/settings-manager.js

@@ -12,9 +12,12 @@
 
 const fs = require('fs');
 const path = require('path');
+const os = require('os');
+const crypto = require('crypto');
 
 const CLAUDE_DIR = path.join(process.env.HOME || process.env.USERPROFILE || '', '.claude');
 const SETTINGS_PATH = path.join(CLAUDE_DIR, 'settings.json');
+const LOCK_TIMEOUT_MS = 5000; // 5 second lock timeout
 
 // Plexor gateway endpoints
 const PLEXOR_STAGING_URL = 'https://staging.api.plexor.dev/gateway/anthropic';
@@ -27,8 +30,8 @@ class ClaudeSettingsManager {
   }
 
   /**
-   * Load current Claude settings
-   * @returns {Object} settings object or empty object if not found
+   * Load current Claude settings with integrity checking
+   * @returns {Object} settings object or empty object if not found/corrupted
    */
   load() {
     try {
@@ -36,18 +39,60 @@ class ClaudeSettingsManager {
         return {};
       }
       const data = fs.readFileSync(this.settingsPath, 'utf8');
-      return JSON.parse(data);
+
+      // Check for empty file
+      if (!data || data.trim() === '') {
+        return {};
+      }
+
+      const parsed = JSON.parse(data);
+
+      // Basic schema validation - must be an object
+      if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {
+        console.warn('Warning: Claude settings file has invalid format, using defaults');
+        this._backupCorruptedFile();
+        return {};
+      }
+
+      return parsed;
     } catch (err) {
-      // Log unexpected errors (not ENOENT which is handled above)
-      if (err.code !== 'ENOENT') {
-        console.warn('Warning: Failed to load Claude settings:', err.message);
+      if (err.code === 'ENOENT') {
+        return {};
+      }
+      // JSON parse error or corrupted file
+      if (err instanceof SyntaxError) {
+        console.warn('Warning: Claude settings file is corrupted, using defaults');
+        console.warn('         A backup has been saved to settings.json.corrupted');
+        this._backupCorruptedFile();
+        return {};
+      }
+      // Permission error
+      if (err.code === 'EACCES' || err.code === 'EPERM') {
+        console.warn(`Warning: Cannot read ${this.settingsPath} (permission denied)`);
+        return {};
       }
+      console.warn('Warning: Failed to load Claude settings:', err.message);
       return {};
     }
   }
 
   /**
-   * Save Claude settings
+   * Backup a corrupted settings file for debugging
+   */
+  _backupCorruptedFile() {
+    try {
+      if (fs.existsSync(this.settingsPath)) {
+        const backupPath = this.settingsPath + '.corrupted';
+        fs.copyFileSync(this.settingsPath, backupPath);
+      }
+    } catch {
+      // Ignore backup errors
+    }
+  }
+
+  /**
+   * Save Claude settings using atomic write pattern
+   * Prevents race conditions by writing to temp file then renaming
    * @param {Object} settings - settings object to save
    * @returns {boolean} success status
    */
@@ -58,10 +103,27 @@ class ClaudeSettingsManager {
         fs.mkdirSync(this.claudeDir, { recursive: true });
       }
 
-      fs.writeFileSync(this.settingsPath, JSON.stringify(settings, null, 2), { mode: 0o600 });
+      // Atomic write: write to temp file, then rename
+      // This prevents race conditions where concurrent writes corrupt the file
+      const tempId = crypto.randomBytes(8).toString('hex');
+      const tempPath = path.join(this.claudeDir, `.settings.${tempId}.tmp`);
+
+      // Write to temp file
+      const content = JSON.stringify(settings, null, 2);
+      fs.writeFileSync(tempPath, content, { mode: 0o600 });
+
+      // Atomic rename (on POSIX systems, rename is atomic)
+      fs.renameSync(tempPath, this.settingsPath);
+
       return true;
     } catch (err) {
-      console.error('Failed to save Claude settings:', err.message);
+      // Clean error message for permission errors
+      if (err.code === 'EACCES' || err.code === 'EPERM') {
+        console.error(`Error: Cannot write to ${this.settingsPath}`);
+        console.error('       Check file permissions or run with appropriate access.');
+      } else {
+        console.error('Failed to save Claude settings:', err.message);
+      }
       return false;
     }
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plexor-dev/claude-code-plugin-staging",
-  "version": "0.1.0-beta.7",
+  "version": "0.1.0-beta.8",
   "description": "STAGING - LLM cost optimization plugin for Claude Code (internal testing)",
   "main": "lib/constants.js",
   "bin": {

package/scripts/postinstall.js

@@ -168,15 +168,37 @@ function main() {
     }
 
     // Copy lib files to ~/.claude/plugins/plexor/lib/
+    // CRITICAL: These are required for commands to work
     const libInstalled = [];
     if (fs.existsSync(LIB_SOURCE)) {
       const libFiles = fs.readdirSync(LIB_SOURCE).filter(f => f.endsWith('.js'));
+      if (libFiles.length === 0) {
+        console.warn('  ⚠ Warning: No lib files found in package. Commands may not work.');
+      }
       for (const file of libFiles) {
-        const src = path.join(LIB_SOURCE, file);
-        const dest = path.join(PLEXOR_LIB_DIR, file);
-        fs.copyFileSync(src, dest);
-        libInstalled.push(file);
+        try {
+          const src = path.join(LIB_SOURCE, file);
+          const dest = path.join(PLEXOR_LIB_DIR, file);
+          fs.copyFileSync(src, dest);
+          libInstalled.push(file);
+        } catch (err) {
+          console.error(`  ✗ Failed to copy lib/${file}: ${err.message}`);
+        }
       }
+    } else {
+      console.error('  ✗ CRITICAL: lib/ directory not found in package.');
+      console.error('    Commands will fail. Please reinstall the package.');
+      console.error(`    Expected location: ${LIB_SOURCE}`);
+    }
+
+    // Verify critical lib file exists
+    const criticalLibFile = path.join(PLEXOR_LIB_DIR, 'settings-manager.js');
+    if (!fs.existsSync(criticalLibFile)) {
+      console.error('');
+      console.error('  ✗ CRITICAL: settings-manager.js was not installed.');
+      console.error('    This file is required for commands to work.');
+      console.error('    Try reinstalling: npm install @plexor-dev/claude-code-plugin-staging');
+      console.error('');
     }
 
     // Fix file ownership when running with sudo