@plexor-dev/claude-code-plugin-staging 0.1.0-beta.24 → 0.1.0-beta.26

package/lib/config-utils.js

@@ -12,6 +12,7 @@ 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-plexor-key',
   'x-force-provider',
   'x-force-model',
   'x-allow-providers',
@@ -23,6 +24,10 @@ const MANAGED_HEADER_KEYS = new Set([
 ]);
 const CLAUDE_SETTINGS_PATH = path.join(os.homedir(), '.claude', 'settings.json');
 
+function isPlexorApiKey(value = '') {
+  return typeof value === 'string' && value.startsWith('plx_');
+}
+
 function normalizeForcedProvider(value) {
   if (typeof value !== 'string') {
     return null;
@@ -113,9 +118,63 @@ function serializeCustomHeaders(headers) {
     .join('\n');
 }
 
+function removeManagedClaudeCustomHeadersFromEnv(env = {}) {
+  const existing = parseCustomHeaders(env.ANTHROPIC_CUSTOM_HEADERS);
+  let removed = false;
+
+  for (const key of MANAGED_HEADER_KEYS) {
+    if (Object.prototype.hasOwnProperty.call(existing, key)) {
+      delete existing[key];
+      removed = true;
+    }
+  }
+
+  if (!removed) {
+    return false;
+  }
+
+  if (Object.keys(existing).length) {
+    env.ANTHROPIC_CUSTOM_HEADERS = serializeCustomHeaders(existing);
+  } else {
+    delete env.ANTHROPIC_CUSTOM_HEADERS;
+  }
+
+  return true;
+}
+
+function getManagedPlexorAuthHeader(env = {}) {
+  const existing = parseCustomHeaders(env.ANTHROPIC_CUSTOM_HEADERS);
+  const managedAuthKey = existing['x-plexor-key'] || '';
+  return isPlexorApiKey(managedAuthKey) ? managedAuthKey : '';
+}
+
+function upsertManagedPlexorAuthHeader(env = {}, apiKey = '') {
+  const existing = parseCustomHeaders(env.ANTHROPIC_CUSTOM_HEADERS);
+  const previousHeaders = env.ANTHROPIC_CUSTOM_HEADERS || '';
+
+  if (isPlexorApiKey(apiKey)) {
+    existing['x-plexor-key'] = apiKey;
+  } else {
+    delete existing['x-plexor-key'];
+  }
+
+  if (Object.keys(existing).length) {
+    env.ANTHROPIC_CUSTOM_HEADERS = serializeCustomHeaders(existing);
+  } else {
+    delete env.ANTHROPIC_CUSTOM_HEADERS;
+  }
+
+  return (env.ANTHROPIC_CUSTOM_HEADERS || '') !== previousHeaders;
+}
+
 function buildManagedAnthropicHeaders(config) {
   const settings = config?.settings || {};
   const headers = {};
+  const apiKey = config?.auth?.api_key || config?.auth?.apiKey || config?.apiKey || '';
+
+  if (isPlexorApiKey(apiKey)) {
+    headers['x-plexor-key'] = apiKey;
+  }
 
   const modeRaw = String(settings.mode || '')
     .trim()
@@ -170,6 +229,25 @@ function buildManagedAnthropicHeaders(config) {
   return headers;
 }
 
+function applyManagedClaudeCustomHeadersToEnv(env = {}, config = {}) {
+  const previousHeaders = env.ANTHROPIC_CUSTOM_HEADERS || '';
+  const existing = parseCustomHeaders(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) {
+    env.ANTHROPIC_CUSTOM_HEADERS = serializeCustomHeaders(merged);
+  } else {
+    delete env.ANTHROPIC_CUSTOM_HEADERS;
+  }
+
+  return (env.ANTHROPIC_CUSTOM_HEADERS || '') !== previousHeaders;
+}
+
 function syncClaudeCustomHeaders(config) {
   try {
     let settings = {};
@@ -183,19 +261,7 @@ function syncClaudeCustomHeaders(config) {
     }
     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;
-    }
+    applyManagedClaudeCustomHeadersToEnv(settings.env, config);
 
     const claudeDir = path.dirname(CLAUDE_SETTINGS_PATH);
     if (!fs.existsSync(claudeDir)) {
@@ -308,6 +374,10 @@ module.exports = {
   readSetting,
   hasForcedHintConflict,
   validateForcedHintConfig,
+  applyManagedClaudeCustomHeadersToEnv,
+  getManagedPlexorAuthHeader,
+  upsertManagedPlexorAuthHeader,
+  removeManagedClaudeCustomHeadersFromEnv,
   parseCustomHeaders,
   serializeCustomHeaders,
   buildManagedAnthropicHeaders

package/lib/hooks-manager.js

@@ -0,0 +1,209 @@
+const fs = require('fs');
+const path = require('path');
+
+function quoteForPosixShell(value) {
+  return `'${String(value).replace(/'/g, `'\"'\"'`)}'`;
+}
+
+function writeJsonAtomically(filePath, value) {
+  const dir = path.dirname(filePath);
+  fs.mkdirSync(dir, { recursive: true });
+  const tempPath = `${filePath}.tmp.${Date.now()}`;
+  fs.writeFileSync(tempPath, JSON.stringify(value, null, 2), { mode: 0o600 });
+  fs.renameSync(tempPath, filePath);
+}
+
+function normalizeSettings(value) {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) {
+    return {};
+  }
+  return { ...value };
+}
+
+function normalizeHookMatchers(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return value.filter((entry) => entry && typeof entry === 'object' && !Array.isArray(entry));
+}
+
+function normalizeHookList(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return value.filter((entry) => entry && typeof entry === 'object' && !Array.isArray(entry));
+}
+
+function readSettings(settingsPath) {
+  if (!fs.existsSync(settingsPath)) {
+    return { settings: {}, existed: false };
+  }
+
+  try {
+    const raw = fs.readFileSync(settingsPath, 'utf8');
+    if (!raw || !raw.trim()) {
+      return { settings: {}, existed: true };
+    }
+    return { settings: normalizeSettings(JSON.parse(raw)), existed: true };
+  } catch {
+    return { settings: {}, existed: true };
+  }
+}
+
+function getManagedSessionSyncPath(homeDir) {
+  return path.join(homeDir, '.claude', 'plugins', 'plexor', 'hooks', 'session-sync.js');
+}
+
+function getSafeManagedCommand(scriptPath, args = []) {
+  const quotedPath = quoteForPosixShell(scriptPath);
+  const quotedArgs = args.map(quoteForPosixShell).join(' ');
+  const argSuffix = quotedArgs ? ` ${quotedArgs}` : '';
+  return `/bin/sh -lc 'script=$1; shift; [ -x \"$script\" ] || exit 0; exec \"$script\" \"$@\"' -- ${quotedPath}${argSuffix}`;
+}
+
+function getManagedSessionSyncCommand(homeDir, mode) {
+  return getSafeManagedCommand(getManagedSessionSyncPath(homeDir), [mode]);
+}
+
+function getManagedHookMatchers(homeDir) {
+  return {
+    SessionStart: [{
+      matcher: 'startup|resume|clear|compact',
+      hooks: [{
+        type: 'command',
+        command: getManagedSessionSyncCommand(homeDir, 'start'),
+        timeout: 5
+      }]
+    }],
+    Stop: [{
+      hooks: [{
+        type: 'command',
+        command: getManagedSessionSyncCommand(homeDir, 'stop'),
+        timeout: 5
+      }]
+    }],
+    SessionEnd: [{
+      hooks: [{
+        type: 'command',
+        command: getManagedSessionSyncCommand(homeDir, 'end'),
+        timeout: 5
+      }]
+    }]
+  };
+}
+
+function isManagedCommandHook(hook) {
+  const command = String(hook?.command || '');
+  return command.includes('/.claude/plugins/plexor/hooks/session-sync.js');
+}
+
+function isManagedMatcher(entry) {
+  const hooks = normalizeHookList(entry?.hooks);
+  return hooks.some(isManagedCommandHook);
+}
+
+function upsertManagedHooks(settingsPath, homeDir) {
+  const { settings, existed } = readSettings(settingsPath);
+  const currentSettings = normalizeSettings(settings);
+  const currentHooks = normalizeSettings(currentSettings.hooks);
+  const managedMatchers = getManagedHookMatchers(homeDir);
+  const nextHooks = { ...currentHooks };
+
+  for (const [eventName, managedEntries] of Object.entries(managedMatchers)) {
+    const preserved = normalizeHookMatchers(currentHooks[eventName]).filter((entry) => !isManagedMatcher(entry));
+    nextHooks[eventName] = [...preserved, ...managedEntries];
+  }
+
+  const nextSettings = { ...currentSettings, hooks: nextHooks };
+  const changed = JSON.stringify(currentSettings) !== JSON.stringify(nextSettings);
+  if (changed) {
+    writeJsonAtomically(settingsPath, nextSettings);
+  }
+
+  return { changed, existed };
+}
+
+function removeManagedHooks(settingsPath) {
+  const { settings, existed } = readSettings(settingsPath);
+  if (!existed) {
+    return { changed: false, removed: 0 };
+  }
+
+  const currentSettings = normalizeSettings(settings);
+  const currentHooks = normalizeSettings(currentSettings.hooks);
+  const nextHooks = { ...currentHooks };
+  let removed = 0;
+
+  for (const [eventName, entries] of Object.entries(currentHooks)) {
+    const normalizedEntries = normalizeHookMatchers(entries);
+    const filteredEntries = normalizedEntries.filter((entry) => !isManagedMatcher(entry));
+    removed += normalizedEntries.length - filteredEntries.length;
+    if (filteredEntries.length > 0) {
+      nextHooks[eventName] = filteredEntries;
+    } else {
+      delete nextHooks[eventName];
+    }
+  }
+
+  const nextSettings = { ...currentSettings };
+  if (Object.keys(nextHooks).length > 0) {
+    nextSettings.hooks = nextHooks;
+  } else {
+    delete nextSettings.hooks;
+  }
+
+  const changed = JSON.stringify(currentSettings) !== JSON.stringify(nextSettings);
+  if (changed) {
+    writeJsonAtomically(settingsPath, nextSettings);
+  }
+
+  return { changed, removed };
+}
+
+function cleanupLegacyManagedHooksFile(legacyHooksPath) {
+  if (!fs.existsSync(legacyHooksPath)) {
+    return { changed: false, removed: 0 };
+  }
+
+  try {
+    const raw = fs.readFileSync(legacyHooksPath, 'utf8');
+    if (!raw || !raw.trim()) {
+      fs.rmSync(legacyHooksPath, { force: true });
+      return { changed: true, removed: 0 };
+    }
+
+    const parsed = JSON.parse(raw);
+    const currentHooks = normalizeHookList(parsed.hooks);
+    const nextHooks = currentHooks.filter((entry) => {
+      const event = String(entry?.event || '');
+      const script = String(entry?.script || '');
+      const isLegacyManagedEvent = event === 'pre_model_request' || event === 'post_model_response';
+      const isLegacyManagedScript = script.includes('/.claude/plugins/plexor/hooks/intercept.js') ||
+        script.includes('/.claude/plugins/plexor/hooks/track-response.js');
+      return !(isLegacyManagedEvent && isLegacyManagedScript);
+    });
+    const removed = currentHooks.length - nextHooks.length;
+
+    if (removed === 0) {
+      return { changed: false, removed: 0 };
+    }
+
+    if (nextHooks.length === 0) {
+      fs.rmSync(legacyHooksPath, { force: true });
+    } else {
+      writeJsonAtomically(legacyHooksPath, { ...parsed, hooks: nextHooks });
+    }
+    return { changed: true, removed };
+  } catch {
+    return { changed: false, removed: 0 };
+  }
+}
+
+module.exports = {
+  getManagedSessionSyncPath,
+  getManagedSessionSyncCommand,
+  getManagedHookMatchers,
+  upsertManagedHooks,
+  removeManagedHooks,
+  cleanupLegacyManagedHooksFile
+};

package/lib/settings-manager.js

@@ -14,11 +14,15 @@ const fs = require('fs');
 const path = require('path');
 const os = require('os');
 const crypto = require('crypto');
+const {
+  getManagedPlexorAuthHeader,
+  removeManagedClaudeCustomHeadersFromEnv,
+  upsertManagedPlexorAuthHeader
+} = require('./config-utils');
 
 const CLAUDE_DIR = path.join(process.env.HOME || process.env.USERPROFILE || '', '.claude');
 const CLAUDE_STATE_PATH = path.join(process.env.HOME || process.env.USERPROFILE || '', '.claude.json');
 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';
@@ -48,52 +52,56 @@ function isPlexorApiKey(value = '') {
 }
 
 function getPlexorAuthKey(env = {}) {
+  const headerKey = getManagedPlexorAuthHeader(env);
   const apiKey = env.ANTHROPIC_API_KEY || '';
   const authToken = env.ANTHROPIC_AUTH_TOKEN || '';
 
+  if (isPlexorApiKey(headerKey)) return headerKey;
   if (isPlexorApiKey(apiKey)) return apiKey;
   if (isPlexorApiKey(authToken)) return authToken;
-  return apiKey || authToken || '';
+  return '';
 }
 
-function hasPlexorManagedAuth(env = {}) {
-  return (
-    isManagedGatewayUrl(env.ANTHROPIC_BASE_URL || '') ||
-    isPlexorApiKey(env.ANTHROPIC_API_KEY || '') ||
-    isPlexorApiKey(env.ANTHROPIC_AUTH_TOKEN || '')
-  );
-}
-
-function stashDirectAuthEnv(env, plexorApiKey) {
-  const alreadyManaged = hasPlexorManagedAuth(env);
-  const currentApiKey = env.ANTHROPIC_API_KEY || '';
-  const currentAuthToken = env.ANTHROPIC_AUTH_TOKEN || '';
+function clearLegacyPlexorAuthValue(env = {}, field, backupField) {
+  let changed = false;
+  const currentValue = env[field] || '';
+  const backupValue = env[backupField] || '';
 
-  if (currentApiKey && !isPlexorApiKey(currentApiKey) && currentApiKey !== plexorApiKey) {
-    env[PREVIOUS_API_KEY_ENV] = currentApiKey;
-  } else if (!alreadyManaged) {
-    delete env[PREVIOUS_API_KEY_ENV];
+  if (isPlexorApiKey(currentValue)) {
+    if (backupValue && !isPlexorApiKey(backupValue)) {
+      env[field] = backupValue;
+    } else {
+      delete env[field];
+    }
+    changed = true;
   }
 
-  if (currentAuthToken && !isPlexorApiKey(currentAuthToken) && currentAuthToken !== plexorApiKey) {
-    env[PREVIOUS_AUTH_TOKEN_ENV] = currentAuthToken;
-  } else if (!alreadyManaged) {
-    delete env[PREVIOUS_AUTH_TOKEN_ENV];
+  if (backupValue) {
+    delete env[backupField];
+    changed = true;
   }
+
+  return changed;
 }
 
-function setPlexorAuthKey(env, apiKey) {
-  stashDirectAuthEnv(env, apiKey);
-  env.ANTHROPIC_API_KEY = apiKey;
-  env.ANTHROPIC_AUTH_TOKEN = apiKey;
+function migrateLegacyPlexorAuthEnv(env = {}, claudeState = {}) {
+  let changed = false;
+
+  changed = clearLegacyPlexorAuthValue(env, 'ANTHROPIC_API_KEY', PREVIOUS_API_KEY_ENV) || changed;
+  changed = clearLegacyPlexorAuthValue(env, 'ANTHROPIC_AUTH_TOKEN', PREVIOUS_AUTH_TOKEN_ENV) || changed;
+
+  changed = restoreDirectPrimaryApiKey(env, claudeState) || changed;
+
+  return changed;
 }
 
 function clearPlexorRoutingEnv(env = {}) {
   const hasManagedBaseUrl = isManagedGatewayUrl(env.ANTHROPIC_BASE_URL || '');
   const hasPlexorApiKey = isPlexorApiKey(env.ANTHROPIC_API_KEY || '');
   const hasPlexorAuthToken = isPlexorApiKey(env.ANTHROPIC_AUTH_TOKEN || '');
+  const removedManagedHeaders = removeManagedClaudeCustomHeadersFromEnv(env);
 
-  if (!hasManagedBaseUrl && !hasPlexorApiKey && !hasPlexorAuthToken) {
+  if (!hasManagedBaseUrl && !hasPlexorApiKey && !hasPlexorAuthToken && !removedManagedHeaders) {
     return false;
   }
 
@@ -120,17 +128,6 @@ function clearPlexorRoutingEnv(env = {}) {
   return true;
 }
 
-function stashDirectPrimaryApiKey(env = {}, claudeState = {}, plexorApiKey = '') {
-  const currentPrimaryApiKey = claudeState.primaryApiKey || '';
-  if (!currentPrimaryApiKey || isPlexorApiKey(currentPrimaryApiKey) || currentPrimaryApiKey === plexorApiKey) {
-    return false;
-  }
-
-  env[PREVIOUS_PRIMARY_API_KEY_ENV] = currentPrimaryApiKey;
-  delete claudeState.primaryApiKey;
-  return true;
-}
-
 function restoreDirectPrimaryApiKey(env = {}, claudeState = {}, options = {}) {
   const { consumeBackup = true } = options;
   const previousPrimaryApiKey = env[PREVIOUS_PRIMARY_API_KEY_ENV] || '';
@@ -346,6 +343,7 @@ class ClaudeSettingsManager {
 
     try {
       const settings = this.load();
+      const previousSettings = JSON.parse(JSON.stringify(settings));
       const claudeState = this.loadClaudeState();
 
       // Initialize env block if doesn't exist
@@ -353,11 +351,9 @@ class ClaudeSettingsManager {
         settings.env = {};
       }
 
-      // Mirror the Plexor key into both Claude auth env vars so every Claude
-      // runtime path uses the gateway instead of any previously saved direct key.
       settings.env.ANTHROPIC_BASE_URL = apiUrl;
-      setPlexorAuthKey(settings.env, apiKey);
-      const claudeStateChanged = stashDirectPrimaryApiKey(settings.env, claudeState, apiKey);
+      upsertManagedPlexorAuthHeader(settings.env, apiKey);
+      const claudeStateChanged = migrateLegacyPlexorAuthEnv(settings.env, claudeState);
 
       const success = this.save(settings);
       if (!success) {
@@ -365,6 +361,7 @@ class ClaudeSettingsManager {
       }
 
       if (claudeStateChanged && !this.saveClaudeState(claudeState)) {
+        this.save(previousSettings);
         return false;
       }
 
@@ -489,9 +486,6 @@ class ClaudeSettingsManager {
       if (isPlexorUrl && !isPlexorApiKey(authKey)) {
         return { partial: true, issue: 'Plexor URL set but auth key is not a Plexor key' };
       }
-      if (isPlexorUrl && claudeState.primaryApiKey && !isPlexorApiKey(claudeState.primaryApiKey)) {
-        return { partial: true, issue: 'Plexor URL set but Claude managed API key is still active' };
-      }
       return { partial: false, issue: null };
     } catch {
       return { partial: false, issue: null };
@@ -511,8 +505,19 @@ class ClaudeSettingsManager {
         settings.env = {};
       }
 
-      setPlexorAuthKey(settings.env, apiKey);
-      return this.save(settings);
+      const previousSettings = JSON.parse(JSON.stringify(settings));
+      const claudeState = this.loadClaudeState();
+      upsertManagedPlexorAuthHeader(settings.env, apiKey);
+      const claudeStateChanged = migrateLegacyPlexorAuthEnv(settings.env, claudeState);
+      const success = this.save(settings);
+      if (!success) {
+        return false;
+      }
+      if (claudeStateChanged && !this.saveClaudeState(claudeState)) {
+        this.save(previousSettings);
+        return false;
+      }
+      return true;
     } catch (err) {
       console.error('Failed to update API key:', err.message);
       return false;

package/lib/statusline-manager.js

@@ -0,0 +1,135 @@
+const fs = require('fs');
+const path = require('path');
+
+const PREVIOUS_STATUS_LINE_KEY = 'PLEXOR_PREVIOUS_STATUS_LINE';
+
+function quoteForPosixShell(value) {
+  return `'${String(value).replace(/'/g, `'\"'\"'`)}'`;
+}
+
+function writeJsonAtomically(filePath, value) {
+  const dir = path.dirname(filePath);
+  fs.mkdirSync(dir, { recursive: true });
+  const tempPath = `${filePath}.tmp.${Date.now()}`;
+  fs.writeFileSync(tempPath, JSON.stringify(value, null, 2), { mode: 0o600 });
+  fs.renameSync(tempPath, filePath);
+}
+
+function normalizeSettings(value) {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) {
+    return {};
+  }
+  return { ...value };
+}
+
+function readSettings(settingsPath) {
+  if (!fs.existsSync(settingsPath)) {
+    return { settings: {}, existed: false };
+  }
+
+  try {
+    const raw = fs.readFileSync(settingsPath, 'utf8');
+    if (!raw || !raw.trim()) {
+      return { settings: {}, existed: true };
+    }
+    return { settings: normalizeSettings(JSON.parse(raw)), existed: true };
+  } catch {
+    return { settings: {}, existed: true };
+  }
+}
+
+function getManagedStatusLinePath(homeDir) {
+  return path.join(homeDir, '.claude', 'plugins', 'plexor', 'hooks', 'statusline.js');
+}
+
+function getManagedStatusLineCommand(homeDir) {
+  const scriptPath = getManagedStatusLinePath(homeDir);
+  return `/bin/sh -lc 'script=$1; [ -x \"$script\" ] || exit 0; exec \"$script\"' -- ${quoteForPosixShell(scriptPath)}`;
+}
+
+function isManagedStatusLine(statusLine, homeDir) {
+  const managedCommand = getManagedStatusLineCommand(homeDir);
+  const normalizedManaged = managedCommand.replace(/^"|"$/g, '');
+  const command = String(statusLine?.command || '');
+
+  return (
+    statusLine?.type === 'command' &&
+    (
+      command === managedCommand ||
+      command === normalizedManaged ||
+      command.includes('/.claude/plugins/plexor/hooks/statusline.js')
+    )
+  );
+}
+
+function getManagedStatusLine(homeDir) {
+  return {
+    type: 'command',
+    command: getManagedStatusLineCommand(homeDir),
+    padding: 0
+  };
+}
+
+function upsertManagedStatusLine(settingsPath, homeDir) {
+  const { settings, existed } = readSettings(settingsPath);
+  const currentSettings = normalizeSettings(settings);
+  const nextSettings = { ...currentSettings };
+  const currentStatusLine = currentSettings.statusLine;
+
+  if (
+    currentStatusLine &&
+    !isManagedStatusLine(currentStatusLine, homeDir) &&
+    !Object.prototype.hasOwnProperty.call(currentSettings, PREVIOUS_STATUS_LINE_KEY)
+  ) {
+    nextSettings[PREVIOUS_STATUS_LINE_KEY] = currentStatusLine;
+  }
+
+  nextSettings.statusLine = getManagedStatusLine(homeDir);
+
+  const changed = JSON.stringify(currentSettings) !== JSON.stringify(nextSettings);
+  if (changed) {
+    writeJsonAtomically(settingsPath, nextSettings);
+  }
+
+  return { changed, existed };
+}
+
+function removeManagedStatusLine(settingsPath, homeDir) {
+  const { settings, existed } = readSettings(settingsPath);
+  if (!existed) {
+    return { changed: false, restored: false };
+  }
+
+  const currentSettings = normalizeSettings(settings);
+  const nextSettings = { ...currentSettings };
+  const managed = isManagedStatusLine(currentSettings.statusLine, homeDir);
+  const previousStatusLine = currentSettings[PREVIOUS_STATUS_LINE_KEY];
+  let restored = false;
+
+  if (managed) {
+    if (previousStatusLine && typeof previousStatusLine === 'object') {
+      nextSettings.statusLine = previousStatusLine;
+      restored = true;
+    } else {
+      delete nextSettings.statusLine;
+    }
+  }
+
+  delete nextSettings[PREVIOUS_STATUS_LINE_KEY];
+
+  const changed = JSON.stringify(currentSettings) !== JSON.stringify(nextSettings);
+  if (changed) {
+    writeJsonAtomically(settingsPath, nextSettings);
+  }
+
+  return { changed, restored };
+}
+
+module.exports = {
+  PREVIOUS_STATUS_LINE_KEY,
+  getManagedStatusLine,
+  getManagedStatusLineCommand,
+  isManagedStatusLine,
+  upsertManagedStatusLine,
+  removeManagedStatusLine
+};

package/package.json

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

package/scripts/plexor-cli.sh

@@ -21,7 +21,12 @@ if [ -f "$CONFIG_FILE" ]; then
     if [ "$ENABLED" = "True" ] && [ -n "$API_URL" ] && [ -n "$API_KEY" ]; then
         # Set ANTHROPIC_BASE_URL to Plexor gateway (hypervisor mode)
         export ANTHROPIC_BASE_URL="${API_URL}/gateway/anthropic/v1"
-        export ANTHROPIC_API_KEY="$API_KEY"
+        if [ -n "$ANTHROPIC_CUSTOM_HEADERS" ]; then
+            export ANTHROPIC_CUSTOM_HEADERS="x-plexor-key: ${API_KEY}
+${ANTHROPIC_CUSTOM_HEADERS}"
+        else
+            export ANTHROPIC_CUSTOM_HEADERS="x-plexor-key: ${API_KEY}"
+        fi
 
         # Show Plexor branding
         echo -e "${CYAN}"