@plexor-dev/claude-code-plugin-staging 0.1.0-beta.14 → 0.1.0-beta.16

package/lib/logger.js

@@ -2,35 +2,94 @@
  * Plexor Logger
  *
  * Simple logger that outputs to stderr to avoid interfering with stdout JSON.
+ * Uses ANSI-colored badges for branded Plexor messages.
  */
 
+// ANSI color codes for branded badge output
+const RESET = '\x1b[0m';
+const BOLD = '\x1b[1m';
+const DIM = '\x1b[2m';
+const WHITE = '\x1b[37m';
+const YELLOW_FG = '\x1b[33m';
+const RED_FG = '\x1b[31m';
+const CYAN_FG = '\x1b[36m';
+const BLUE_BG = '\x1b[44m';
+const YELLOW_BG = '\x1b[43m';
+const RED_BG = '\x1b[41m';
+
+// Pre-built badge strings
+const BADGE_INFO = `${BOLD}${WHITE}${BLUE_BG} PLEXOR ${RESET}`;
+const BADGE_WARN = `${BOLD}${WHITE}${YELLOW_BG} PLEXOR ${RESET}`;
+const BADGE_ERROR = `${BOLD}${WHITE}${RED_BG} PLEXOR ${RESET}`;
+
+function parseBooleanEnv(name, defaultValue) {
+  const raw = process.env[name];
+  if (raw === undefined || raw === null || raw === '') {
+    return defaultValue;
+  }
+  const normalized = String(raw).trim().toLowerCase();
+  if (['1', 'true', 'yes', 'on'].includes(normalized)) {
+    return true;
+  }
+  if (['0', 'false', 'no', 'off'].includes(normalized)) {
+    return false;
+  }
+  return defaultValue;
+}
+
+function formatUxMessage(message) {
+  const text = String(message || '').trim();
+  if (!text) {
+    return '[PLEXOR: message]';
+  }
+  if (text.startsWith('[PLEXOR:')) {
+    return text;
+  }
+  if (text.startsWith('[PLEXOR') && text.endsWith(']')) {
+    return text.replace(/^\[PLEXOR[^\]]*\]\s*/i, '[PLEXOR: ');
+  }
+  return `[PLEXOR: ${text}]`;
+}
+
 class Logger {
   constructor(component = 'plexor') {
     this.component = component;
-    this.debug_enabled = process.env.PLEXOR_DEBUG === '1' || process.env.PLEXOR_DEBUG === 'true';
+    this.debug_enabled = parseBooleanEnv('PLEXOR_DEBUG', false);
+    this.ux_messages_enabled =
+      parseBooleanEnv('PLEXOR_UX_MESSAGES', true) &&
+      parseBooleanEnv('PLEXOR_UX_DEBUG_MESSAGES', true);
   }
 
   debug(msg, data = null) {
     if (this.debug_enabled) {
-      const output = data ? `[DEBUG][${this.component}] ${msg} ${JSON.stringify(data)}` : `[DEBUG][${this.component}] ${msg}`;
+      const output = data ? `${DIM}[${this.component}]${RESET} ${msg} ${JSON.stringify(data)}` : `${DIM}[${this.component}]${RESET} ${msg}`;
       console.error(output);
     }
   }
 
   info(msg, data = null) {
-    const output = data ? `${msg} ${JSON.stringify(data)}` : msg;
+    const output = data ? `${BADGE_INFO} ${msg} ${JSON.stringify(data)}` : `${BADGE_INFO} ${msg}`;
     console.error(output);
   }
 
   warn(msg, data = null) {
-    const output = data ? `[WARN][${this.component}] ${msg} ${JSON.stringify(data)}` : `[WARN][${this.component}] ${msg}`;
+    const output = data ? `${BADGE_WARN} ${YELLOW_FG}${msg} ${JSON.stringify(data)}${RESET}` : `${BADGE_WARN} ${YELLOW_FG}${msg}${RESET}`;
     console.error(output);
   }
 
   error(msg, data = null) {
-    const output = data ? `[ERROR][${this.component}] ${msg} ${JSON.stringify(data)}` : `[ERROR][${this.component}] ${msg}`;
+    const output = data ? `${BADGE_ERROR} ${RED_FG}${msg} ${JSON.stringify(data)}${RESET}` : `${BADGE_ERROR} ${RED_FG}${msg}${RESET}`;
     console.error(output);
   }
+
+  ux(msg, data = null) {
+    if (!this.ux_messages_enabled) {
+      return;
+    }
+    const prefixed = formatUxMessage(msg);
+    const output = data ? `${prefixed} ${JSON.stringify(data)}` : prefixed;
+    console.error(`${CYAN_FG}${output}${RESET}`);
+  }
 }
 
 module.exports = Logger;

package/lib/settings-manager.js

@@ -23,6 +23,22 @@ const LOCK_TIMEOUT_MS = 5000; // 5 second lock timeout
 const PLEXOR_STAGING_URL = 'https://staging.api.plexor.dev/gateway/anthropic';
 const PLEXOR_PROD_URL = 'https://api.plexor.dev/gateway/anthropic';
 
+/**
+ * Check if a base URL is a Plexor-managed gateway URL.
+ * Detects all variants: production, staging, localhost, tunnels.
+ */
+function isManagedGatewayUrl(baseUrl) {
+  if (!baseUrl) return false;
+  return (
+    baseUrl.includes('plexor') ||
+    baseUrl.includes('staging.api') ||
+    baseUrl.includes('localhost') ||
+    baseUrl.includes('127.0.0.1') ||
+    baseUrl.includes('ngrok') ||
+    baseUrl.includes('localtunnel')
+  );
+}
+
 class ClaudeSettingsManager {
   constructor() {
     this.settingsPath = SETTINGS_PATH;
@@ -248,11 +264,8 @@ class ClaudeSettingsManager {
       const baseUrl = settings.env?.ANTHROPIC_BASE_URL || null;
       const hasToken = !!settings.env?.ANTHROPIC_AUTH_TOKEN;
 
-      // Check if routing to Plexor
-      const isPlexorRouting = baseUrl && (
-        baseUrl.includes('plexor') ||
-        baseUrl.includes('staging.api')
-      );
+      // Check if routing to Plexor (any variant: prod, staging, localhost, tunnel)
+      const isPlexorRouting = isManagedGatewayUrl(baseUrl);
 
       return {
         enabled: isPlexorRouting,
@@ -276,7 +289,7 @@ class ClaudeSettingsManager {
       const settings = this.load();
       const baseUrl = settings.env?.ANTHROPIC_BASE_URL || '';
       const authToken = settings.env?.ANTHROPIC_AUTH_TOKEN || '';
-      const isPlexorUrl = baseUrl.includes('plexor') || baseUrl.includes('staging.api');
+      const isPlexorUrl = isManagedGatewayUrl(baseUrl);
 
       if (isPlexorUrl && !authToken) {
         return { partial: true, issue: 'Plexor URL set but no auth token' };
@@ -345,6 +358,7 @@ const settingsManager = new ClaudeSettingsManager();
 module.exports = {
   ClaudeSettingsManager,
   settingsManager,
+  isManagedGatewayUrl,
   CLAUDE_DIR,
   SETTINGS_PATH,
   PLEXOR_STAGING_URL,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plexor-dev/claude-code-plugin-staging",
-  "version": "0.1.0-beta.14",
+  "version": "0.1.0-beta.16",
   "description": "STAGING - LLM cost optimization plugin for Claude Code (internal testing)",
   "main": "lib/constants.js",
   "bin": {
@@ -8,7 +8,11 @@
     "plexor-enabled": "./commands/plexor-enabled.js",
     "plexor-login": "./commands/plexor-login.js",
     "plexor-logout": "./commands/plexor-logout.js",
-    "plexor-uninstall": "./commands/plexor-uninstall.js"
+    "plexor-uninstall": "./commands/plexor-uninstall.js",
+    "plexor-settings": "./commands/plexor-settings.js",
+    "plexor-routing": "./commands/plexor-routing.js",
+    "plexor-agent": "./commands/plexor-agent.js",
+    "plexor-provider": "./commands/plexor-provider.js"
   },
   "scripts": {
     "postinstall": "node scripts/postinstall.js",

package/scripts/postinstall.js

@@ -13,42 +13,109 @@ const os = require('os');
 const { execSync } = require('child_process');
 
 /**
- * Get the correct home directory, accounting for sudo.
- * When running with sudo, os.homedir() returns /root, but we want
- * the actual user's home directory.
+ * Resolve the home directory for a given username by querying /etc/passwd.
+ * This is the authoritative source and handles non-standard home paths
+ * (e.g., /root, /opt/users/foo, NIS/LDAP users, etc.).
+ * Returns null if lookup fails (Windows, missing getent, etc.).
+ */
+function getHomeDirFromPasswd(username) {
+  try {
+    const entry = execSync(`getent passwd ${username}`, { encoding: 'utf8' }).trim();
+    // Format: username:x:uid:gid:gecos:homedir:shell
+    const fields = entry.split(':');
+    if (fields.length >= 6 && fields[5]) {
+      return fields[5];
+    }
+  } catch {
+    // getent not available or user not found
+  }
+  return null;
+}
+
+/**
+ * Get the correct home directory for the process's effective user.
+ *
+ * Handles three scenarios:
+ *   1. Normal execution:           HOME is correct, os.homedir() is correct.
+ *   2. `sudo npm install`:         SUDO_USER is set, os.homedir() returns /root,
+ *                                   but we want the SUDO_USER's home.
+ *   3. `sudo -u target npm install`:
+ *                                   HOME may still be the *caller's* home (e.g.,
+ *                                   /home/azureuser), SUDO_USER is the *caller*
+ *                                   (not the target), but process.getuid() returns
+ *                                   the *target* UID. We must resolve home from
+ *                                   /etc/passwd by UID.
+ *
+ * Resolution order (most authoritative first):
+ *   a) Look up the effective UID in /etc/passwd via getent (handles sudo -u)
+ *   b) Fall back to os.homedir() (works for normal execution)
+ *   c) Fall back to HOME / USERPROFILE env vars (last resort)
  */
 function getHomeDir() {
-  // Check if running with sudo - SUDO_USER contains the original username
-  if (process.env.SUDO_USER) {
-    // On Linux/Mac, home directories are typically /home/<user> or /Users/<user>
-    const platform = os.platform();
-    if (platform === 'darwin') {
-      return path.join('/Users', process.env.SUDO_USER);
-    } else if (platform === 'linux') {
-      return path.join('/home', process.env.SUDO_USER);
+  // On non-Windows, resolve via the effective UID's passwd entry.
+  // This is the most reliable method and correctly handles both
+  // `sudo` and `sudo -u <target>` scenarios.
+  if (os.platform() !== 'win32') {
+    try {
+      const uid = process.getuid();
+      const entry = execSync(`getent passwd ${uid}`, { encoding: 'utf8' }).trim();
+      const fields = entry.split(':');
+      if (fields.length >= 6 && fields[5]) {
+        return fields[5];
+      }
+    } catch {
+      // Fall through to other methods
     }
   }
-  return os.homedir();
+
+  // Fallback: os.homedir() (reads HOME env var, then passwd on Unix)
+  const home = os.homedir();
+  if (home) return home;
+
+  // Last resort: environment variables
+  return process.env.HOME || process.env.USERPROFILE || '/tmp';
 }
 
 /**
- * Get uid/gid for the target user (handles sudo case).
- * Returns null if not running with sudo or on Windows.
+ * Get uid/gid for the effective user running this process.
+ * Under `sudo`, the effective user is root but we want to chown to the
+ * original (SUDO_USER) or target (`sudo -u target`) user.
+ * Under `sudo -u target`, process.getuid() IS the target, so we use that.
+ * Returns null on Windows or if no privilege elevation detected.
  */
 function getTargetUserIds() {
-  const sudoUser = process.env.SUDO_USER;
-  if (!sudoUser || os.platform() === 'win32') {
+  if (os.platform() === 'win32') {
     return null;
   }
 
   try {
-    // Get uid and gid for the sudo user
-    const uid = parseInt(execSync(`id -u ${sudoUser}`, { encoding: 'utf8' }).trim(), 10);
-    const gid = parseInt(execSync(`id -g ${sudoUser}`, { encoding: 'utf8' }).trim(), 10);
-    return { uid, gid, user: sudoUser };
+    const effectiveUid = process.getuid();
+
+    // If we're running as root (uid 0), we were likely invoked via `sudo`.
+    // Chown files to SUDO_USER (the human who ran sudo).
+    if (effectiveUid === 0 && process.env.SUDO_USER) {
+      const uid = parseInt(execSync(`id -u ${process.env.SUDO_USER}`, { encoding: 'utf8' }).trim(), 10);
+      const gid = parseInt(execSync(`id -g ${process.env.SUDO_USER}`, { encoding: 'utf8' }).trim(), 10);
+      return { uid, gid, user: process.env.SUDO_USER };
+    }
+
+    // If we're NOT root but SUDO_USER is set, we were invoked via `sudo -u target`.
+    // The effective UID is already the target user. Chown to that user.
+    if (effectiveUid !== 0 && process.env.SUDO_USER) {
+      const entry = execSync(`getent passwd ${effectiveUid}`, { encoding: 'utf8' }).trim();
+      const fields = entry.split(':');
+      if (fields.length >= 4) {
+        const username = fields[0];
+        const uid = parseInt(fields[2], 10);
+        const gid = parseInt(fields[3], 10);
+        return { uid, gid, user: username };
+      }
+    }
   } catch {
-    return null;
+    // Fall through
   }
+
+  return null;
 }
 
 /**
@@ -77,33 +144,71 @@ const PLEXOR_LIB_DIR = path.join(HOME_DIR, '.claude', 'plugins', 'plexor', 'lib'
 const PLEXOR_CONFIG_DIR = path.join(HOME_DIR, '.plexor');
 const PLEXOR_CONFIG_FILE = path.join(PLEXOR_CONFIG_DIR, 'config.json');
 
+/**
+ * Check if a base URL is a Plexor-managed gateway URL.
+ * Detects all variants: production, staging, localhost, tunnels.
+ */
+function isManagedGatewayUrl(baseUrl) {
+  if (!baseUrl) return false;
+  return (
+    baseUrl.includes('plexor') ||
+    baseUrl.includes('staging.api') ||
+    baseUrl.includes('localhost') ||
+    baseUrl.includes('127.0.0.1') ||
+    baseUrl.includes('ngrok') ||
+    baseUrl.includes('localtunnel')
+  );
+}
+
+/**
+ * The expected base URL for THIS plugin variant.
+ * Used to detect when a different variant was previously installed.
+ */
+const THIS_VARIANT_URL = 'https://staging.api.plexor.dev/gateway/anthropic';
+
 /**
  * Check for orphaned Plexor routing in settings.json without valid config.
- * This can happen if a previous uninstall was incomplete.
+ * Also detects variant mismatch (e.g., localhost plugin was installed, now
+ * installing staging plugin) and migrates ANTHROPIC_BASE_URL + fixes
+ * ANTHROPIC_API_KEY → ANTHROPIC_AUTH_TOKEN (#2174).
  */
 function checkOrphanedRouting() {
-  const home = process.env.HOME || process.env.USERPROFILE;
-  if (!home) return;
-
-  const settingsPath = path.join(home, '.claude', 'settings.json');
-  const configPath = path.join(home, '.plexor', 'config.json');
+  // Use the resolved HOME_DIR (not process.env.HOME which may be wrong under sudo -u)
+  const settingsPath = path.join(HOME_DIR, '.claude', 'settings.json');
+  const configPath = path.join(HOME_DIR, '.plexor', 'config.json');
 
   try {
     if (!fs.existsSync(settingsPath)) return;
 
     const settings = JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
     const env = settings.env || {};
+    let settingsChanged = false;
 
-    const hasPlexorUrl = env.ANTHROPIC_BASE_URL &&
-                         env.ANTHROPIC_BASE_URL.includes('plexor');
+    const hasPlexorUrl = isManagedGatewayUrl(env.ANTHROPIC_BASE_URL);
 
     if (hasPlexorUrl) {
+      // Fix #2174: Only migrate ANTHROPIC_API_KEY → ANTHROPIC_AUTH_TOKEN
+      // when routing through a Plexor-managed URL. Non-Plexor setups
+      // (direct Anthropic, etc.) should not have their auth mutated.
+      if (env.ANTHROPIC_API_KEY && !env.ANTHROPIC_AUTH_TOKEN) {
+        env.ANTHROPIC_AUTH_TOKEN = env.ANTHROPIC_API_KEY;
+        delete env.ANTHROPIC_API_KEY;
+        settings.env = env;
+        settingsChanged = true;
+        console.log('\n  Migrated ANTHROPIC_API_KEY → ANTHROPIC_AUTH_TOKEN (fix #2174)');
+      } else if (env.ANTHROPIC_API_KEY && env.ANTHROPIC_AUTH_TOKEN) {
+        // Both exist — remove the lower-precedence one to avoid confusion
+        delete env.ANTHROPIC_API_KEY;
+        settings.env = env;
+        settingsChanged = true;
+        console.log('\n  Removed redundant ANTHROPIC_API_KEY (ANTHROPIC_AUTH_TOKEN takes precedence)');
+      }
       // Check if there's a valid Plexor config
       let hasValidConfig = false;
       try {
         if (fs.existsSync(configPath)) {
           const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
-          hasValidConfig = config.apiKey && config.apiKey.startsWith('plx_');
+          hasValidConfig = (config.auth?.api_key || config.apiKey || '').startsWith('plx_');
         }
       } catch (e) {}
 
@@ -113,10 +218,31 @@ function checkOrphanedRouting() {
         console.log('  Run /plexor-login to reconfigure, or');
         console.log('  Run /plexor-uninstall to clean up\n');
       } else {
-        console.log('\n  Existing Plexor configuration detected');
-        console.log('  Your previous settings have been preserved.\n');
+        // Fix #2176: Detect variant mismatch and migrate URL
+        const currentUrl = env.ANTHROPIC_BASE_URL;
+        if (currentUrl !== THIS_VARIANT_URL) {
+          env.ANTHROPIC_BASE_URL = THIS_VARIANT_URL;
+          settings.env = env;
+          settingsChanged = true;
+          console.log(`\n  Migrated ANTHROPIC_BASE_URL to this variant's gateway:`);
+          console.log(`    Old: ${currentUrl}`);
+          console.log(`    New: ${THIS_VARIANT_URL}\n`);
+        } else {
+          console.log('\n  Existing Plexor configuration detected');
+          console.log('  Your previous settings have been preserved.\n');
+        }
       }
     }
+
+    // Write back settings if any migration was applied
+    if (settingsChanged) {
+      const crypto = require('crypto');
+      const claudeDir = path.join(HOME_DIR, '.claude');
+      const tempId = crypto.randomBytes(8).toString('hex');
+      const tempPath = path.join(claudeDir, `.settings.${tempId}.tmp`);
+      fs.writeFileSync(tempPath, JSON.stringify(settings, null, 2), { mode: 0o600 });
+      fs.renameSync(tempPath, settingsPath);
+    }
   } catch (e) {
     // Ignore errors in detection - don't break install
   }
@@ -295,13 +421,13 @@ function main() {
     console.log('');
     console.log('  For Claude MAX users (OAuth):');
     console.log('');
-    console.log(`    echo 'export ANTHROPIC_BASE_URL="https://api.plexor.dev/gateway/anthropic"' >> ${shellRc}`);
+    console.log(`    echo 'export ANTHROPIC_BASE_URL="https://staging.api.plexor.dev/gateway/anthropic"' >> ${shellRc}`);
     console.log(`    source ${shellRc}`);
     console.log('');
     console.log('  For API key users (get key at https://plexor.dev/dashboard):');
     console.log('');
-    console.log(`    echo 'export ANTHROPIC_BASE_URL="https://api.plexor.dev/gateway/anthropic"' >> ${shellRc}`);
-    console.log(`    echo 'export ANTHROPIC_API_KEY="plx_your_key_here"' >> ${shellRc}`);
+    console.log(`    echo 'export ANTHROPIC_BASE_URL="https://staging.api.plexor.dev/gateway/anthropic"' >> ${shellRc}`);
+    console.log(`    echo 'export ANTHROPIC_AUTH_TOKEN="plx_your_key_here"' >> ${shellRc}`);
     console.log(`    source ${shellRc}`);
     console.log('');
     console.log('  ┌─────────────────────────────────────────────────────────────────┐');

package/scripts/uninstall.js

@@ -15,11 +15,34 @@
 
 const fs = require('fs');
 const path = require('path');
+const os = require('os');
+const { execSync } = require('child_process');
 
-// Get home directory - support both Unix and Windows
-const home = process.env.HOME || process.env.USERPROFILE;
+/**
+ * Get the correct home directory for the process's effective user.
+ * Resolves via /etc/passwd to handle sudo and sudo -u correctly.
+ */
+function getHomeDir() {
+  if (os.platform() !== 'win32') {
+    try {
+      const uid = process.getuid();
+      const entry = execSync(`getent passwd ${uid}`, { encoding: 'utf8' }).trim();
+      const fields = entry.split(':');
+      if (fields.length >= 6 && fields[5]) {
+        return fields[5];
+      }
+    } catch {
+      // Fall through
+    }
+  }
+  const h = os.homedir();
+  if (h) return h;
+  return process.env.HOME || process.env.USERPROFILE || null;
+}
+
+const home = getHomeDir();
 if (!home) {
-  console.log('Warning: HOME not set, skipping cleanup');
+  console.log('Warning: Could not determine home directory, skipping cleanup');
   process.exit(0);
 }