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

package/lib/config-utils.js

@@ -0,0 +1,314 @@
+/**
+ * Shared config utilities for Plexor slash commands.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+const os = require('os');
+const { PLEXOR_DIR, CONFIG_PATH } = require('./constants');
+
+const DISABLED_HINT_VALUES = new Set(['', 'auto', 'none', 'off']);
+const VALID_ORCHESTRATION_MODES = new Set(['supervised', 'autonomous', 'danger-full-auto']);
+const VALID_ROUTING_MODES = new Set(['eco', 'balanced', 'quality', 'passthrough', 'cost']);
+const MANAGED_HEADER_KEYS = new Set([
+  'x-force-provider',
+  'x-force-model',
+  'x-allow-providers',
+  'x-deny-providers',
+  'x-allow-models',
+  'x-deny-models',
+  'x-plexor-mode',
+  'x-plexor-orchestration-mode'
+]);
+const CLAUDE_SETTINGS_PATH = path.join(os.homedir(), '.claude', 'settings.json');
+
+function normalizeForcedProvider(value) {
+  if (typeof value !== 'string') {
+    return null;
+  }
+  const normalized = value.trim().toLowerCase();
+  if (!normalized || normalized === 'auto') {
+    return 'auto';
+  }
+  return normalized;
+}
+
+function normalizeForcedModel(value) {
+  if (typeof value !== 'string') {
+    return null;
+  }
+  const normalized = value.trim();
+  if (!normalized || DISABLED_HINT_VALUES.has(normalized.toLowerCase())) {
+    return null;
+  }
+  return normalized;
+}
+
+function normalizeCsv(value) {
+  if (typeof value !== 'string') {
+    return null;
+  }
+  const tokens = value
+    .split(',')
+    .map((token) => token.trim())
+    .filter(Boolean);
+  if (!tokens.length) {
+    return null;
+  }
+  return tokens.join(',');
+}
+
+function parseCustomHeaders(raw) {
+  if (typeof raw !== 'string' || !raw.trim()) {
+    return {};
+  }
+  const trimmedRaw = raw.trim();
+
+  // Backward compatibility: older plugin versions persisted ANTHROPIC_CUSTOM_HEADERS
+  // as a JSON object string. Parse that first so managed key replacement works.
+  if (trimmedRaw.startsWith('{')) {
+    try {
+      const legacy = JSON.parse(trimmedRaw);
+      if (legacy && typeof legacy === 'object' && !Array.isArray(legacy)) {
+        const out = {};
+        for (const [key, value] of Object.entries(legacy)) {
+          const normalizedKey = String(key || '').trim().toLowerCase();
+          const normalizedValue = String(value ?? '').trim();
+          if (!normalizedKey || !normalizedValue) {
+            continue;
+          }
+          out[normalizedKey] = normalizedValue;
+        }
+        return out;
+      }
+    } catch {
+      // Fall through to line-based parser.
+    }
+  }
+
+  const parsed = {};
+  for (const line of raw.split('\n')) {
+    const trimmed = line.trim();
+    if (!trimmed) {
+      continue;
+    }
+    const idx = trimmed.indexOf(':');
+    if (idx <= 0) {
+      continue;
+    }
+    const key = trimmed.slice(0, idx).trim().toLowerCase();
+    const value = trimmed.slice(idx + 1).trim();
+    if (!key || !value) {
+      continue;
+    }
+    parsed[key] = value;
+  }
+  return parsed;
+}
+
+function serializeCustomHeaders(headers) {
+  return Object.entries(headers)
+    .map(([key, value]) => `${key}: ${value}`)
+    .join('\n');
+}
+
+function buildManagedAnthropicHeaders(config) {
+  const settings = config?.settings || {};
+  const headers = {};
+
+  const modeRaw = String(settings.mode || '')
+    .trim()
+    .toLowerCase();
+  if (VALID_ROUTING_MODES.has(modeRaw)) {
+    headers['x-plexor-mode'] = modeRaw === 'cost' ? 'eco' : modeRaw;
+  }
+
+  const orchestrationRaw = String(
+    settings.orchestrationMode || settings.orchestration_mode || ''
+  )
+    .trim()
+    .toLowerCase();
+  if (VALID_ORCHESTRATION_MODES.has(orchestrationRaw)) {
+    headers['x-plexor-orchestration-mode'] = orchestrationRaw;
+  }
+
+  const forceProvider = normalizeForcedProvider(
+    settings.preferred_provider ?? settings.preferredProvider ?? 'auto'
+  );
+  if (forceProvider && forceProvider !== 'auto') {
+    headers['x-force-provider'] = forceProvider;
+  }
+
+  const forceModel = normalizeForcedModel(settings.preferred_model ?? settings.preferredModel);
+  if (forceModel) {
+    headers['x-force-model'] = forceModel;
+  }
+
+  const allowProviders = normalizeCsv(
+    settings.provider_allowlist ?? settings.providerAllowlist ?? ''
+  );
+  if (allowProviders) {
+    headers['x-allow-providers'] = allowProviders;
+  }
+
+  const denyProviders = normalizeCsv(settings.provider_denylist ?? settings.providerDenylist ?? '');
+  if (denyProviders) {
+    headers['x-deny-providers'] = denyProviders;
+  }
+
+  const allowModels = normalizeCsv(settings.model_allowlist ?? settings.modelAllowlist ?? '');
+  if (allowModels) {
+    headers['x-allow-models'] = allowModels;
+  }
+
+  const denyModels = normalizeCsv(settings.model_denylist ?? settings.modelDenylist ?? '');
+  if (denyModels) {
+    headers['x-deny-models'] = denyModels;
+  }
+
+  return headers;
+}
+
+function syncClaudeCustomHeaders(config) {
+  try {
+    let settings = {};
+    if (fs.existsSync(CLAUDE_SETTINGS_PATH)) {
+      const raw = fs.readFileSync(CLAUDE_SETTINGS_PATH, 'utf8');
+      settings = raw.trim() ? JSON.parse(raw) : {};
+    }
+
+    if (typeof settings !== 'object' || settings === null || Array.isArray(settings)) {
+      settings = {};
+    }
+    settings.env = settings.env && typeof settings.env === 'object' ? settings.env : {};
+
+    const existing = parseCustomHeaders(settings.env.ANTHROPIC_CUSTOM_HEADERS);
+    for (const key of MANAGED_HEADER_KEYS) {
+      delete existing[key];
+    }
+
+    const managed = buildManagedAnthropicHeaders(config);
+    const merged = { ...existing, ...managed };
+
+    if (Object.keys(merged).length) {
+      settings.env.ANTHROPIC_CUSTOM_HEADERS = serializeCustomHeaders(merged);
+    } else {
+      delete settings.env.ANTHROPIC_CUSTOM_HEADERS;
+    }
+
+    const claudeDir = path.dirname(CLAUDE_SETTINGS_PATH);
+    if (!fs.existsSync(claudeDir)) {
+      fs.mkdirSync(claudeDir, { recursive: true, mode: 0o700 });
+    }
+    const tempPath = path.join(claudeDir, `.settings.${crypto.randomBytes(8).toString('hex')}.tmp`);
+    fs.writeFileSync(tempPath, JSON.stringify(settings, null, 2), { mode: 0o600 });
+    fs.renameSync(tempPath, CLAUDE_SETTINGS_PATH);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function hasForcedHintConflict(config) {
+  const settings = config?.settings || {};
+  const provider = normalizeForcedProvider(
+    settings.preferred_provider ?? settings.preferredProvider ?? 'auto'
+  );
+  const model = normalizeForcedModel(settings.preferred_model ?? settings.preferredModel);
+  return Boolean(model) && provider !== 'auto';
+}
+
+function validateForcedHintConfig(config) {
+  if (!hasForcedHintConflict(config)) {
+    return { ok: true };
+  }
+  return {
+    ok: false,
+    message:
+      'Invalid Plexor config: set only one force hint. Use preferred_provider OR preferred_model, not both.'
+  };
+}
+
+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) {
+      try { fs.copyFileSync(CONFIG_PATH, CONFIG_PATH + '.corrupted'); } catch { /* ignore */ }
+    }
+    return { version: 1, auth: {}, settings: {} };
+  }
+}
+
+function saveConfig(config) {
+  try {
+    const validation = validateForcedHintConfig(config);
+    if (!validation.ok) {
+      console.error(`Error: ${validation.message}`);
+      return false;
+    }
+
+    if (!fs.existsSync(PLEXOR_DIR)) {
+      fs.mkdirSync(PLEXOR_DIR, { recursive: true, mode: 0o700 });
+    }
+    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);
+    // Best-effort sync to Claude client headers so force hints are respected.
+    syncClaudeCustomHeaders(config);
+    return true;
+  } catch (err) {
+    if (err.code === 'EACCES' || err.code === 'EPERM') {
+      console.error('Error: Cannot write to ~/.plexor/config.json');
+    } else {
+      console.error('Failed to save config:', err.message);
+    }
+    return false;
+  }
+}
+
+/**
+ * Read a setting with env-var → config → default precedence.
+ * @param {object} config - Loaded config object
+ * @param {string} configKey - Primary key in config.settings (camelCase)
+ * @param {string|null} configKeyAlt - Alternative key (snake_case legacy)
+ * @param {string} envVar - Environment variable name
+ * @param {string[]} validValues - Accepted values
+ * @param {string} defaultValue - Fallback
+ * @returns {{ value: string, source: string }}
+ */
+function readSetting(config, configKey, configKeyAlt, envVar, validValues, defaultValue) {
+  const env = process.env[envVar];
+  if (env && validValues.includes(env.toLowerCase())) {
+    return { value: env.toLowerCase(), source: 'environment' };
+  }
+  const cfg = config.settings?.[configKey] || (configKeyAlt && config.settings?.[configKeyAlt]);
+  if (cfg && validValues.includes(cfg.toLowerCase())) {
+    return { value: cfg.toLowerCase(), source: 'config' };
+  }
+  return { value: defaultValue, source: 'default' };
+}
+
+module.exports = {
+  loadConfig,
+  saveConfig,
+  readSetting,
+  hasForcedHintConflict,
+  validateForcedHintConfig,
+  parseCustomHeaders,
+  serializeCustomHeaders,
+  buildManagedAnthropicHeaders
+};

package/lib/config.js

@@ -5,6 +5,7 @@
 const fs = require('fs');
 const path = require('path');
 const { CONFIG_PATH, PLEXOR_DIR, DEFAULT_API_URL, DEFAULT_TIMEOUT } = require('./constants');
+const { validateForcedHintConfig } = require('./config-utils');
 
 class ConfigManager {
   constructor() {
@@ -22,7 +23,10 @@ class ConfigManager {
         timeout: cfg.settings?.timeout || DEFAULT_TIMEOUT,
         localCacheEnabled: cfg.settings?.localCacheEnabled ?? false,
         mode: cfg.settings?.mode || 'balanced',
-        preferredProvider: cfg.settings?.preferred_provider || 'auto'
+        preferredProvider: cfg.settings?.preferred_provider || 'auto',
+        preferredModel: cfg.settings?.preferredModel || cfg.settings?.preferred_model || null,
+        orchestrationMode:
+          cfg.settings?.orchestrationMode || cfg.settings?.orchestration_mode || 'autonomous'
       };
     } catch {
       return { enabled: false, apiKey: '', apiUrl: DEFAULT_API_URL };
@@ -52,11 +56,26 @@ class ConfigManager {
           timeout: config.timeout ?? existing.settings?.timeout,
           localCacheEnabled: config.localCacheEnabled ?? existing.settings?.localCacheEnabled,
           mode: config.mode ?? existing.settings?.mode,
-          preferred_provider: config.preferredProvider ?? existing.settings?.preferred_provider
+          preferred_provider: config.preferredProvider ?? existing.settings?.preferred_provider,
+          preferred_model:
+            config.preferredModel ??
+            config.preferred_model ??
+            existing.settings?.preferredModel ??
+            existing.settings?.preferred_model,
+          orchestrationMode:
+            config.orchestrationMode ??
+            config.orchestration_mode ??
+            existing.settings?.orchestrationMode ??
+            existing.settings?.orchestration_mode
         }
       };
 
-      fs.writeFileSync(this.configPath, JSON.stringify(updated, null, 2));
+      const validation = validateForcedHintConfig(updated);
+      if (!validation.ok) {
+        return false;
+      }
+
+      fs.writeFileSync(this.configPath, JSON.stringify(updated, null, 2), { mode: 0o600 });
       return true;
     } catch {
       return false;

package/lib/constants.js

@@ -4,7 +4,23 @@
 
 const path = require('path');
 
-const PLEXOR_DIR = path.join(process.env.HOME || process.env.USERPROFILE || '', '.plexor');
+/**
+ * Get the user's home directory with proper validation
+ * @returns {string} Home directory path
+ * @throws {Error} If HOME is not set or empty
+ */
+function getHomeDir() {
+  const home = process.env.HOME || process.env.USERPROFILE;
+  if (!home || home.trim() === '') {
+    console.error('Error: HOME environment variable is not set.');
+    console.error('       Please set HOME to your user directory before running Plexor commands.');
+    process.exit(1);
+  }
+  return home;
+}
+
+const HOME_DIR = getHomeDir();
+const PLEXOR_DIR = path.join(HOME_DIR, '.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');
@@ -16,6 +32,8 @@ const DEFAULT_API_URL = 'https://staging.api.plexor.dev';
 const DEFAULT_TIMEOUT = 5000;
 
 module.exports = {
+  getHomeDir,
+  HOME_DIR,
   PLEXOR_DIR,
   CONFIG_PATH,
   SESSION_PATH,

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;