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

package/scripts/postinstall.js

@@ -11,6 +11,12 @@ const fs = require('fs');
 const path = require('path');
 const os = require('os');
 const { execSync } = require('child_process');
+const {
+  applyManagedClaudeCustomHeadersToEnv,
+  getManagedPlexorAuthHeader
+} = require('../lib/config-utils');
+const { upsertManagedStatusLine } = require('../lib/statusline-manager');
+const { upsertManagedHooks, cleanupLegacyManagedHooksFile } = require('../lib/hooks-manager');
 
 /**
  * Resolve the home directory for a given username by querying /etc/passwd.
@@ -137,12 +143,16 @@ function chownRecursive(dirPath, uid, gid) {
 
 const HOME_DIR = getHomeDir();
 const COMMANDS_SOURCE = path.join(__dirname, '..', 'commands');
+const HOOKS_SOURCE = path.join(__dirname, '..', 'hooks');
 const LIB_SOURCE = path.join(__dirname, '..', 'lib');
 const CLAUDE_COMMANDS_DIR = path.join(HOME_DIR, '.claude', 'commands');
 const PLEXOR_PLUGINS_DIR = path.join(HOME_DIR, '.claude', 'plugins', 'plexor', 'commands');
+const PLEXOR_HOOKS_DIR = path.join(HOME_DIR, '.claude', 'plugins', 'plexor', 'hooks');
 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');
+const CLAUDE_SETTINGS_FILE = path.join(HOME_DIR, '.claude', 'settings.json');
+const CLAUDE_LEGACY_HOOKS_FILE = path.join(HOME_DIR, '.claude', 'hooks.json');
 
 /**
  * Check if a base URL is a Plexor-managed gateway URL.
@@ -172,61 +182,80 @@ const PREVIOUS_PRIMARY_API_KEY_ENV = 'PLEXOR_PREVIOUS_CLAUDE_PRIMARY_API_KEY';
 /**
  * Check for orphaned Plexor routing in settings.json without valid config.
  * Also detects variant mismatch (e.g., localhost plugin was installed, now
- * installing staging plugin) and migrates ANTHROPIC_BASE_URL + syncs
- * Claude auth env vars for Plexor-managed gateways.
+ * installing staging plugin) and migrates legacy env-based Plexor auth into
+ * managed Claude custom headers.
  */
-function selectManagedAuthKey(env = {}) {
+function selectManagedAuthKey(env = {}, config = {}) {
+  const configApiKey = config.auth?.api_key || config.auth?.apiKey || config.apiKey || '';
   const apiKey = env.ANTHROPIC_API_KEY || '';
   const authToken = env.ANTHROPIC_AUTH_TOKEN || '';
+  const headerApiKey = getManagedPlexorAuthHeader(env);
 
+  if (configApiKey.startsWith('plx_')) return configApiKey;
+  if (headerApiKey.startsWith('plx_')) return headerApiKey;
   if (apiKey.startsWith('plx_')) return apiKey;
   if (authToken.startsWith('plx_')) return authToken;
-  return apiKey || authToken || '';
+  return '';
 }
 
-function syncManagedAuthEnv(env, managedAuthKey) {
-  const currentApiKey = env.ANTHROPIC_API_KEY || '';
-  const currentAuthToken = env.ANTHROPIC_AUTH_TOKEN || '';
+function restoreLegacyManagedAuthEnvValue(env, field, backupField) {
+  let changed = false;
+  const currentValue = env[field] || '';
+  const backupValue = env[backupField] || '';
 
-  if (currentApiKey && !currentApiKey.startsWith('plx_') && currentApiKey !== managedAuthKey) {
-    env[PREVIOUS_API_KEY_ENV] = currentApiKey;
+  if (currentValue.startsWith('plx_')) {
+    if (backupValue && !backupValue.startsWith('plx_')) {
+      env[field] = backupValue;
+    } else {
+      delete env[field];
+    }
+    changed = true;
   }
-  if (currentAuthToken && !currentAuthToken.startsWith('plx_') && currentAuthToken !== managedAuthKey) {
-    env[PREVIOUS_AUTH_TOKEN_ENV] = currentAuthToken;
+
+  if (backupValue) {
+    delete env[backupField];
+    changed = true;
   }
 
-  env.ANTHROPIC_API_KEY = managedAuthKey;
-  env.ANTHROPIC_AUTH_TOKEN = managedAuthKey;
+  return changed;
 }
 
-function syncManagedPrimaryApiKey(env, managedAuthKey) {
-  const statePath = path.join(HOME_DIR, '.claude.json');
-  try {
-    if (!fs.existsSync(statePath)) {
-      return false;
-    }
-
-    const data = fs.readFileSync(statePath, 'utf8');
-    if (!data || !data.trim()) {
-      return false;
-    }
+function writeJsonAtomically(filePath, value) {
+  const tempPath = `${filePath}.tmp.${Date.now()}`;
+  fs.writeFileSync(tempPath, JSON.stringify(value, null, 2), { mode: 0o600 });
+  fs.renameSync(tempPath, filePath);
+}
 
-    const claudeState = JSON.parse(data);
-    const primaryApiKey = claudeState.primaryApiKey || '';
-    if (!primaryApiKey || primaryApiKey.startsWith('plx_') || primaryApiKey === managedAuthKey) {
-      return false;
-    }
+function migrateManagedAuthState(env, claudeState, config = {}) {
+  let settingsChanged = false;
+  let claudeStateChanged = false;
+  const managedAuthKey = selectManagedAuthKey(env, config);
+
+  if (managedAuthKey) {
+    const managedConfig = {
+      ...config,
+      auth: {
+        ...(config.auth || {}),
+        api_key: managedAuthKey
+      }
+    };
+    settingsChanged = applyManagedClaudeCustomHeadersToEnv(env, managedConfig) || settingsChanged;
+  }
 
-    env[PREVIOUS_PRIMARY_API_KEY_ENV] = primaryApiKey;
-    delete claudeState.primaryApiKey;
+  settingsChanged = restoreLegacyManagedAuthEnvValue(env, 'ANTHROPIC_API_KEY', PREVIOUS_API_KEY_ENV) || settingsChanged;
+  settingsChanged = restoreLegacyManagedAuthEnvValue(env, 'ANTHROPIC_AUTH_TOKEN', PREVIOUS_AUTH_TOKEN_ENV) || settingsChanged;
 
-    const tempPath = `${statePath}.tmp.${Date.now()}`;
-    fs.writeFileSync(tempPath, JSON.stringify(claudeState, null, 2), { mode: 0o600 });
-    fs.renameSync(tempPath, statePath);
-    return true;
-  } catch {
-    return false;
+  const previousPrimaryApiKey = env[PREVIOUS_PRIMARY_API_KEY_ENV] || '';
+  if (previousPrimaryApiKey) {
+    if (!claudeState.primaryApiKey) {
+      claudeState.primaryApiKey = previousPrimaryApiKey;
+      claudeStateChanged = true;
+    }
+    delete env[PREVIOUS_PRIMARY_API_KEY_ENV];
+    settingsChanged = true;
   }
+
+  return { settingsChanged, claudeStateChanged };
 }
 
 function checkOrphanedRouting() {
@@ -240,30 +269,19 @@ function checkOrphanedRouting() {
     const settings = JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
     const env = settings.env || {};
     let settingsChanged = false;
+    let claudeStateChanged = false;
+    let claudeState = {};
+    const statePath = path.join(HOME_DIR, '.claude.json');
 
     const hasPlexorUrl = isManagedGatewayUrl(env.ANTHROPIC_BASE_URL);
 
     if (hasPlexorUrl) {
-      // Keep both Claude auth env vars aligned to the Plexor key so Claude API
-      // auth cannot override the gateway after plugin setup.
-      const managedAuthKey = selectManagedAuthKey(env);
-      if (managedAuthKey &&
-          (env.ANTHROPIC_API_KEY !== managedAuthKey || env.ANTHROPIC_AUTH_TOKEN !== managedAuthKey)) {
-        syncManagedAuthEnv(env, managedAuthKey);
-        settings.env = env;
-        settingsChanged = true;
-        console.log('\n  Synced Plexor auth into ANTHROPIC_API_KEY and ANTHROPIC_AUTH_TOKEN');
-      }
-      if (managedAuthKey && syncManagedPrimaryApiKey(env, managedAuthKey)) {
-        settings.env = env;
-        settingsChanged = true;
-        console.log('\n  Suspended Claude managed API key while Plexor is active');
-      }
       // Check if there's a valid Plexor config
       let hasValidConfig = false;
+      let config = null;
       try {
         if (fs.existsSync(configPath)) {
-          const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+          config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
           hasValidConfig = (config.auth?.api_key || config.apiKey || '').startsWith('plx_');
         }
       } catch (e) {}
@@ -274,6 +292,22 @@ function checkOrphanedRouting() {
         console.log('  Run /plexor-login to reconfigure, or');
         console.log('  Run /plexor-uninstall to clean up\n');
       } else {
+        try {
+          if (fs.existsSync(statePath)) {
+            const data = fs.readFileSync(statePath, 'utf8');
+            if (data && data.trim()) {
+              claudeState = JSON.parse(data);
+            }
+          }
+        } catch {
+          claudeState = {};
+        }
+
+        const migration = migrateManagedAuthState(env, claudeState, config);
+        settings.env = env;
+        settingsChanged = migration.settingsChanged || settingsChanged;
+        claudeStateChanged = migration.claudeStateChanged || claudeStateChanged;
+
         // Fix #2176: Detect variant mismatch and migrate URL
         const currentUrl = env.ANTHROPIC_BASE_URL;
         if (currentUrl !== THIS_VARIANT_URL) {
@@ -299,6 +333,16 @@ function checkOrphanedRouting() {
       fs.writeFileSync(tempPath, JSON.stringify(settings, null, 2), { mode: 0o600 });
       fs.renameSync(tempPath, settingsPath);
     }
+
+    if (claudeStateChanged) {
+      try {
+        writeJsonAtomically(statePath, claudeState);
+        console.log('\n  Restored saved Claude auth alongside Plexor header routing');
+      } catch (e) {
+        console.log('\n  Warning: Migrated Plexor auth headers but could not restore saved Claude auth');
+        console.log(`  ${e.message}`);
+      }
+    }
   } catch (e) {
     // Ignore errors in detection - don't break install
   }
@@ -334,6 +378,9 @@ function main() {
     // Create ~/.claude/plugins/plexor/commands/ for JS executors
     fs.mkdirSync(PLEXOR_PLUGINS_DIR, { recursive: true });
 
+    // Create ~/.claude/plugins/plexor/hooks/ for hook scripts
+    fs.mkdirSync(PLEXOR_HOOKS_DIR, { recursive: true });
+
     // Create ~/.claude/plugins/plexor/lib/ for shared modules
     fs.mkdirSync(PLEXOR_LIB_DIR, { recursive: true });
 
@@ -356,6 +403,9 @@ function main() {
       .filter(f => f.endsWith('.md'));
     const jsFiles = fs.readdirSync(COMMANDS_SOURCE)
       .filter(f => f.endsWith('.js'));
+    const hookFiles = fs.existsSync(HOOKS_SOURCE)
+      ? fs.readdirSync(HOOKS_SOURCE).filter(f => f.endsWith('.js'))
+      : [];
 
     if (mdFiles.length === 0) {
       console.error('No command files found in package. Installation may be corrupt.');
@@ -397,6 +447,16 @@ function main() {
       jsInstalled.push(file);
     }
 
+    // Copy hook files to ~/.claude/plugins/plexor/hooks/
+    const hooksInstalled = [];
+    for (const file of hookFiles) {
+      const src = path.join(HOOKS_SOURCE, file);
+      const dest = path.join(PLEXOR_HOOKS_DIR, file);
+      fs.copyFileSync(src, dest);
+      fs.chmodSync(dest, 0o755);
+      hooksInstalled.push(file);
+    }
+
     // Copy lib files to ~/.claude/plugins/plexor/lib/
     // CRITICAL: These are required for commands to work
     const libInstalled = [];
@@ -431,6 +491,10 @@ function main() {
       console.error('');
     }
 
+    const statusLineRegistration = upsertManagedStatusLine(CLAUDE_SETTINGS_FILE, HOME_DIR);
+    const hooksRegistration = upsertManagedHooks(CLAUDE_SETTINGS_FILE, HOME_DIR);
+    const legacyHooksCleanup = cleanupLegacyManagedHooksFile(CLAUDE_LEGACY_HOOKS_FILE);
+
     // Fix file ownership when running with sudo
     // Files are created as root but should be owned by the original user
     if (targetUser) {
@@ -457,9 +521,21 @@ function main() {
     if (jsInstalled.length > 0) {
       console.log(`  ✓ Installed ${jsInstalled.length} executors to ~/.claude/plugins/plexor/commands/`);
     }
+    if (hooksInstalled.length > 0) {
+      console.log(`  ✓ Installed ${hooksInstalled.length} hook scripts to ~/.claude/plugins/plexor/hooks/`);
+    }
     if (libInstalled.length > 0) {
       console.log(`  ✓ Installed ${libInstalled.length} lib modules to ~/.claude/plugins/plexor/lib/`);
     }
+    if (statusLineRegistration.changed || statusLineRegistration.existed) {
+      console.log('  ✓ Registered Plexor status line in ~/.claude/settings.json');
+    }
+    if (hooksRegistration.changed || hooksRegistration.existed) {
+      console.log('  ✓ Registered Plexor hooks in ~/.claude/settings.json');
+    }
+    if (legacyHooksCleanup.changed) {
+      console.log('  ✓ Cleaned up legacy ~/.claude/hooks.json entries');
+    }
     if (targetUser) {
       console.log(`  ✓ Set file ownership to ${targetUser.user}`);
     }
@@ -474,10 +550,11 @@ function main() {
     console.log('    2. Write ~/.plexor/config.json');
     console.log('    3. Point Claude at the Plexor staging gateway');
     console.log('    4. Preserve prior Claude auth for restore on logout');
-    console.log('    5. Verify Claude routing with a deterministic check');
+    console.log('    5. Show Plexor state in Claude footer via status line');
+    console.log('    6. Update session savings in real time via Claude hooks');
     console.log('');
     console.log('  ┌─────────────────────────────────────────────────────────────────┐');
-    console.log('  │  No shell edits or Claude restart required after setup        │');
+    console.log('  │  After /plexor-setup, restart Claude before first prompt     │');
     console.log('  └─────────────────────────────────────────────────────────────────┘');
     console.log('');
     console.log('  Available commands:');

package/scripts/uninstall.js

@@ -17,6 +17,9 @@ const fs = require('fs');
 const path = require('path');
 const os = require('os');
 const { execSync } = require('child_process');
+const { removeManagedStatusLine } = require('../lib/statusline-manager');
+const { removeManagedHooks, cleanupLegacyManagedHooksFile } = require('../lib/hooks-manager');
+const { removeManagedClaudeCustomHeadersFromEnv } = require('../lib/config-utils');
 
 /**
  * Get the correct home directory for the process's effective user.
@@ -52,11 +55,17 @@ console.log('');
 
 const results = {
   routing: false,
+  statusLine: false,
+  hooks: false,
   commands: [],
   restored: [],
-  pluginDir: false
+  pluginDir: false,
+  configDir: false
 };
 const PREVIOUS_PRIMARY_API_KEY_ENV = 'PLEXOR_PREVIOUS_CLAUDE_PRIMARY_API_KEY';
+const CLAUDE_SETTINGS_PATH = path.join(home, '.claude', 'settings.json');
+const CLAUDE_HOOKS_PATH = path.join(home, '.claude', 'settings.json');
+const CLAUDE_LEGACY_HOOKS_PATH = path.join(home, '.claude', 'hooks.json');
 
 function isManagedGatewayUrl(baseUrl = '') {
   return (
@@ -77,8 +86,9 @@ function clearPlexorRoutingEnv(env = {}) {
   const hasManagedBaseUrl = isManagedGatewayUrl(env.ANTHROPIC_BASE_URL || '');
   const hasPlexorAuthToken = isPlexorApiKey(env.ANTHROPIC_AUTH_TOKEN || '');
   const hasPlexorApiKey = isPlexorApiKey(env.ANTHROPIC_API_KEY || '');
+  const removedManagedHeaders = removeManagedClaudeCustomHeadersFromEnv(env);
 
-  if (!hasManagedBaseUrl && !hasPlexorAuthToken && !hasPlexorApiKey) {
+  if (!hasManagedBaseUrl && !hasPlexorAuthToken && !hasPlexorApiKey && !removedManagedHeaders) {
     return false;
   }
 
@@ -105,10 +115,16 @@ function clearPlexorRoutingEnv(env = {}) {
   return true;
 }
 
+function writeJsonAtomically(filePath, value) {
+  const tempPath = `${filePath}.tmp.${Date.now()}`;
+  fs.writeFileSync(tempPath, JSON.stringify(value, null, 2), { mode: 0o600 });
+  fs.renameSync(tempPath, filePath);
+}
+
 function restoreClaudePrimaryApiKey(env = {}) {
   const previousPrimaryApiKey = env[PREVIOUS_PRIMARY_API_KEY_ENV] || '';
   if (!previousPrimaryApiKey) {
-    return false;
+    return { restored: false, warning: null };
   }
 
   const statePath = path.join(home, '.claude.json');
@@ -127,12 +143,14 @@ function restoreClaudePrimaryApiKey(env = {}) {
   if (!claudeState.primaryApiKey) {
     claudeState.primaryApiKey = previousPrimaryApiKey;
   }
-  delete env[PREVIOUS_PRIMARY_API_KEY_ENV];
 
-  const tempPath = `${statePath}.tmp.${Date.now()}`;
-  fs.writeFileSync(tempPath, JSON.stringify(claudeState, null, 2), { mode: 0o600 });
-  fs.renameSync(tempPath, statePath);
-  return true;
+  try {
+    writeJsonAtomically(statePath, claudeState);
+    delete env[PREVIOUS_PRIMARY_API_KEY_ENV];
+    return { restored: true, warning: null };
+  } catch (e) {
+    return { restored: false, warning: e.message };
+  }
 }
 
 // 1. Remove routing from settings.json
@@ -145,17 +163,20 @@ try {
       const settings = JSON.parse(data);
       if (settings.env) {
         const routingChanged = clearPlexorRoutingEnv(settings.env);
-        const primaryApiKeyRestored = restoreClaudePrimaryApiKey(settings.env);
+        const primaryApiKeyRestore = restoreClaudePrimaryApiKey(settings.env);
 
         // Clean up empty env block
         if (Object.keys(settings.env).length === 0) {
           delete settings.env;
         }
 
-        if (routingChanged || primaryApiKeyRestored) {
+        if (routingChanged || primaryApiKeyRestore.restored) {
           fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2), { mode: 0o600 });
           results.routing = true;
         }
+        if (primaryApiKeyRestore.warning) {
+          console.log(`  Warning: Could not restore Claude managed API key: ${primaryApiKeyRestore.warning}`);
+        }
       }
     }
   }
@@ -163,24 +184,34 @@ try {
   console.log(`  Warning: Could not clean settings.json: ${e.message}`);
 }
 
-// 2. Remove slash command files
-// These are the Plexor-specific command files that get installed to ~/.claude/commands/
-const plexorCommands = [
-  'plexor-config.md',
-  'plexor-enabled.md',
-  'plexor-login.md',
-  'plexor-logout.md',
-  'plexor-mode.md',
-  'plexor-provider.md',
-  'plexor-settings.md',
-  'plexor-setup.md',
-  'plexor-status.md',
-  'plexor-uninstall.md'
-];
+// 2. Remove managed Claude status line
+try {
+  const statusLineRemoval = removeManagedStatusLine(CLAUDE_SETTINGS_PATH, home);
+  results.statusLine = statusLineRemoval.changed;
+} catch (e) {
+  console.log(`  Warning: Could not clean Plexor status line: ${e.message}`);
+}
+
+// 2b. Remove managed Claude hooks
+try {
+  const hooksRemoval = removeManagedHooks(CLAUDE_HOOKS_PATH);
+  results.hooks = hooksRemoval.changed;
+} catch (e) {
+  console.log(`  Warning: Could not clean Plexor hooks: ${e.message}`);
+}
+try {
+  const legacyHooksRemoval = cleanupLegacyManagedHooksFile(CLAUDE_LEGACY_HOOKS_PATH);
+  results.hooks = results.hooks || legacyHooksRemoval.changed;
+} catch (e) {
+  console.log(`  Warning: Could not clean legacy Plexor hooks file: ${e.message}`);
+}
 
+// 3. Remove slash command files
+// These are the Plexor-specific command files that get installed to ~/.claude/commands/
 try {
   const commandsDir = path.join(home, '.claude', 'commands');
   if (fs.existsSync(commandsDir)) {
+    const plexorCommands = fs.readdirSync(commandsDir).filter((entry) => /^plexor-.*\.md$/i.test(entry));
     for (const cmd of plexorCommands) {
       const cmdPath = path.join(commandsDir, cmd);
       const backupPath = cmdPath + '.backup';
@@ -201,7 +232,7 @@ try {
   console.log(`  Warning: Could not clean commands: ${e.message}`);
 }
 
-// 3. Remove plugin directory
+// 4. Remove plugin directory
 try {
   const pluginDir = path.join(home, '.claude', 'plugins', 'plexor');
   if (fs.existsSync(pluginDir)) {
@@ -212,8 +243,26 @@ try {
   console.log(`  Warning: Could not remove plugin directory: ${e.message}`);
 }
 
+// 5. Remove config directory
+try {
+  const configDir = path.join(home, '.plexor');
+  if (fs.existsSync(configDir)) {
+    fs.rmSync(configDir, { recursive: true, force: true });
+    results.configDir = true;
+  }
+} catch (e) {
+  console.log(`  Warning: Could not remove ~/.plexor config directory: ${e.message}`);
+}
+
 // Output results
-if (results.routing || results.commands.length > 0 || results.pluginDir) {
+if (
+  results.routing ||
+  results.statusLine ||
+  results.hooks ||
+  results.commands.length > 0 ||
+  results.pluginDir ||
+  results.configDir
+) {
   console.log('  Plexor plugin uninstalled');
   console.log('');
 
@@ -223,6 +272,16 @@ if (results.routing || results.commands.length > 0 || results.pluginDir) {
     console.log('');
   }
 
+  if (results.statusLine) {
+    console.log('  Removed Plexor Claude status line');
+    console.log('');
+  }
+
+  if (results.hooks) {
+    console.log('  Removed Plexor Claude hooks');
+    console.log('');
+  }
+
   if (results.commands.length > 0) {
     console.log('  Removed commands:');
     results.commands.forEach(cmd => console.log(`    /${cmd}`));
@@ -239,10 +298,10 @@ if (results.routing || results.commands.length > 0 || results.pluginDir) {
     console.log('  Removed plugin directory');
     console.log('');
   }
-
-  console.log('  Note: ~/.plexor/ config directory was preserved.');
-  console.log('  To remove it: rm -rf ~/.plexor');
-  console.log('');
+  if (results.configDir) {
+    console.log('  Removed ~/.plexor config directory');
+    console.log('');
+  }
 } else {
   console.log('  No Plexor components found to clean up.');
   console.log('');