@plexor-dev/claude-code-plugin-staging 0.1.0-beta.23 → 0.1.0-beta.25

package/commands/plexor-setup.js

@@ -92,6 +92,32 @@ function getGatewayLabel(apiUrl) {
   return apiUrl.includes('staging') ? 'staging' : 'production';
 }
 
+function isRunningInsideClaudeSession(env = process.env) {
+  return Boolean(env.CLAUDECODE);
+}
+
+function createSkipVerifyResult() {
+  return { ok: true, reason: '', stdout: EXPECTED_VERIFY_RESPONSE, stderr: '', code: 0, pendingRestart: false };
+}
+
+function createPendingRestartVerifyResult() {
+  return {
+    ok: false,
+    reason: 'Restart Claude to finish Plexor activation in your current session.',
+    stdout: '',
+    stderr: '',
+    code: 0,
+    pendingRestart: true
+  };
+}
+
+function getVerifyLabel(verifyResult) {
+  if (verifyResult.pendingRestart) {
+    return 'Restart Claude';
+  }
+  return verifyResult.ok ? 'OK' : 'FAILED';
+}
+
 function updateHealth(config, state) {
   config.health = {
     installed: true,
@@ -102,6 +128,7 @@ function updateHealth(config, state) {
     verify_prompt: VERIFY_PROMPT,
     verify_expected: EXPECTED_VERIFY_RESPONSE,
     verify_error: state.verifyResult.ok ? null : state.verifyResult.reason,
+    activation_pending_restart: Boolean(state.verifyResult.pendingRestart),
     gateway: state.gateway,
     previous_auth_preserved: state.previousAuthPreserved
   };
@@ -124,10 +151,14 @@ function printReceipt({ user, gateway, previousAuthPreserved, verifyResult }) {
   console.log('├─────────────────────────────────────────────┤');
   console.log(line(`Connected: OK (${user.email || 'Unknown'})`));
   console.log(line(`Routing Active: OK (${gateway})`));
-  console.log(line(`Verified: ${verifyResult.ok ? 'OK' : 'FAILED'}`));
+  console.log(line(`Verified: ${getVerifyLabel(verifyResult)}`));
   console.log(line(`Previous Claude auth: ${previousAuthPreserved ? 'Saved' : 'None found'}`));
   console.log('├─────────────────────────────────────────────┤');
-  if (verifyResult.ok) {
+  if (verifyResult.pendingRestart) {
+    console.log(line('Plexor routing is configured'));
+    console.log(line('Restart Claude to activate Plexor'));
+    console.log(line('Then run /plexor-status'));
+  } else if (verifyResult.ok) {
     console.log(line('Plexor routing is configured'));
     console.log(line('Restart Claude, then send a prompt'));
     console.log(line('Logout/uninstall restores prior auth'));
@@ -221,9 +252,9 @@ async function main() {
     currentSettings.env?.PLEXOR_PREVIOUS_CLAUDE_PRIMARY_API_KEY
   );
 
-  const verifyResult = skipVerify
-    ? { ok: true, reason: '', stdout: EXPECTED_VERIFY_RESPONSE, stderr: '', code: 0 }
-    : runClaudeRouteVerification();
+  const verifyResult = isRunningInsideClaudeSession()
+    ? createPendingRestartVerifyResult()
+    : (skipVerify ? createSkipVerifyResult() : runClaudeRouteVerification());
 
   updateHealth(updatedConfig, {
     gateway: getGatewayLabel(apiUrl),
@@ -243,12 +274,22 @@ async function main() {
     verifyResult
   });
 
-  if (!verifyResult.ok) {
+  if (!verifyResult.ok && !verifyResult.pendingRestart) {
     process.exit(1);
   }
 }
 
-main().catch((err) => {
-  console.error(`Error: ${err.message}`);
-  process.exit(1);
-});
+if (require.main === module) {
+  main().catch((err) => {
+    console.error(`Error: ${err.message}`);
+    process.exit(1);
+  });
+} else {
+  module.exports = {
+    createPendingRestartVerifyResult,
+    createSkipVerifyResult,
+    getVerifyLabel,
+    isRunningInsideClaudeSession,
+    updateHealth
+  };
+}

package/commands/plexor-status.js

@@ -58,7 +58,7 @@ function getDirectClaudeAuthState() {
   try {
     const data = fs.readFileSync(CLAUDE_STATE_PATH, 'utf8');
     const state = JSON.parse(data);
-    if (state.primaryApiKey) {
+    if (state.primaryApiKey && !state.primaryApiKey.startsWith('plx_')) {
       return { present: true, source: '/login managed key' };
     }
   } catch {
@@ -172,6 +172,47 @@ function loadConfig() {
   }
 }
 
+function saveConfig(config) {
+  try {
+    const configDir = path.dirname(CONFIG_PATH);
+    if (!fs.existsSync(configDir)) {
+      fs.mkdirSync(configDir, { recursive: true, mode: 0o700 });
+    }
+    const tempPath = path.join(configDir, `.config.${Date.now()}.tmp`);
+    fs.writeFileSync(tempPath, JSON.stringify(config, null, 2), { mode: 0o600 });
+    fs.renameSync(tempPath, CONFIG_PATH);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function isActivationPendingRestart(verification = {}) {
+  return verification.activation_pending_restart === true;
+}
+
+function shouldPromotePendingRestart(verification = {}, routing = {}, userFetchWorked = false) {
+  return isActivationPendingRestart(verification) && routing.active && userFetchWorked;
+}
+
+function getVerificationSummary(verification = {}, options = {}) {
+  const { routingActive = false, userFetchWorked = false } = options;
+
+  if (shouldPromotePendingRestart(verification, { active: routingActive }, userFetchWorked)) {
+    return { verified: 'OK', nextAction: '/plexor-status', shouldPromote: true };
+  }
+
+  if (isActivationPendingRestart(verification)) {
+    return { verified: 'Restart Claude', nextAction: 'Restart Claude', shouldPromote: false };
+  }
+
+  return {
+    verified: verification.verified ? 'OK' : (verification.verify_error ? 'Failed' : 'Not yet'),
+    nextAction: null,
+    shouldPromote: false
+  };
+}
+
 /**
  * Check for environment mismatch between config and routing
  */
@@ -385,12 +426,33 @@ ${line(`└── Cost saved: $${sessionCostSaved}`)}
   const envLabel = routing.isStaging ? '(staging)' : '(production)';
   const stateMismatch = checkStateMismatch(enabled, routing.active);
   const connectedState = userFetchWorked ? 'OK' : 'Unknown';
-  const verifiedState = verification.verified
+  const verificationSummary = getVerificationSummary(verification, {
+    routingActive: routing.active,
+    userFetchWorked
+  });
+
+  if (verificationSummary.shouldPromote) {
+    config.health = {
+      ...verification,
+      verified: true,
+      verified_at: new Date().toISOString(),
+      verify_error: null,
+      activation_pending_restart: false
+    };
+    saveConfig(config);
+    verification.verified = true;
+    verification.verified_at = config.health.verified_at;
+    verification.verify_error = null;
+    verification.activation_pending_restart = false;
+  }
+
+  const verifiedState = verificationSummary.shouldPromote
     ? 'OK'
-    : (verification.verify_error ? 'Failed' : 'Not yet');
-  const nextAction = !routing.active || partialState.partial || stateMismatch || !verification.verified
-    ? '/plexor-setup'
-    : '/plexor-status';
+    : verificationSummary.verified;
+  const nextAction = verificationSummary.nextAction ||
+    (!routing.active || partialState.partial || stateMismatch || !verification.verified
+      ? '/plexor-setup'
+      : '/plexor-status');
 
   // Note: Environment mismatch warning removed - it caused false positives during
   // concurrent operations and transient states. The partial state and config/routing
@@ -521,7 +583,15 @@ function fetchJson(apiUrl, endpoint, apiKey) {
   });
 }
 
-main().catch(err => {
-  console.error('Error:', err.message);
-  process.exit(1);
-});
+if (require.main === module) {
+  main().catch(err => {
+    console.error('Error:', err.message);
+    process.exit(1);
+  });
+} else {
+  module.exports = {
+    getVerificationSummary,
+    isActivationPendingRestart,
+    shouldPromotePendingRestart
+  };
+}

package/commands/plexor-uninstall.js

@@ -18,6 +18,9 @@
 const fs = require('fs');
 const path = require('path');
 const os = require('os');
+const { removeManagedStatusLine } = require('../lib/statusline-manager');
+const { removeManagedHooks, cleanupLegacyManagedHooksFile } = require('../lib/hooks-manager');
+const { removeManagedClaudeCustomHeadersFromEnv } = require('../lib/config-utils');
 
 // Get home directory, handling sudo case
 function getHomeDir() {
@@ -36,22 +39,12 @@ const HOME_DIR = getHomeDir();
 const CLAUDE_DIR = path.join(HOME_DIR, '.claude');
 const CLAUDE_COMMANDS_DIR = path.join(CLAUDE_DIR, 'commands');
 const CLAUDE_PLUGINS_DIR = path.join(CLAUDE_DIR, 'plugins', 'plexor');
+const CLAUDE_SETTINGS_PATH = path.join(CLAUDE_DIR, 'settings.json');
+const CLAUDE_HOOKS_PATH = path.join(CLAUDE_DIR, 'settings.json');
+const CLAUDE_LEGACY_HOOKS_PATH = path.join(CLAUDE_DIR, 'hooks.json');
 const PLEXOR_CONFIG_DIR = path.join(HOME_DIR, '.plexor');
 
 // All Plexor slash command files
-const PLEXOR_COMMANDS = [
-  'plexor-enabled.md',
-  'plexor-login.md',
-  'plexor-logout.md',
-  'plexor-setup.md',
-  'plexor-status.md',
-  'plexor-uninstall.md',
-  'plexor-mode.md',
-  'plexor-provider.md',
-  'plexor-settings.md',
-  'plexor-config.md'
-];
-
 /**
  * Load settings manager if available
  */
@@ -115,10 +108,11 @@ function disableRoutingManually() {
     const hasManagedBaseUrl = isManagedGatewayUrl(settings.env.ANTHROPIC_BASE_URL || '');
     const hasPlexorAuthToken = isPlexorApiKey(settings.env.ANTHROPIC_AUTH_TOKEN || '');
     const hasPlexorApiKey = isPlexorApiKey(settings.env.ANTHROPIC_API_KEY || '');
+    const removedManagedHeaders = removeManagedClaudeCustomHeadersFromEnv(settings.env);
 
     const hasPreviousPrimaryApiKey = Boolean(settings.env[previousPrimaryApiKeyEnv]);
 
-    if (!hasManagedBaseUrl && !hasPlexorAuthToken && !hasPlexorApiKey && !hasPreviousPrimaryApiKey) {
+    if (!hasManagedBaseUrl && !hasPlexorAuthToken && !hasPlexorApiKey && !hasPreviousPrimaryApiKey && !removedManagedHeaders) {
       return { success: true, message: 'Plexor routing not active' };
     }
 
@@ -191,7 +185,12 @@ function removeSlashCommands() {
   let removed = 0;
   let restored = 0;
 
-  for (const cmd of PLEXOR_COMMANDS) {
+  if (!fs.existsSync(CLAUDE_COMMANDS_DIR)) {
+    return { removed, restored };
+  }
+
+  const plexorCommands = fs.readdirSync(CLAUDE_COMMANDS_DIR).filter((entry) => /^plexor-.*\.md$/i.test(entry));
+  for (const cmd of plexorCommands) {
     const cmdPath = path.join(CLAUDE_COMMANDS_DIR, cmd);
     const backupPath = cmdPath + '.backup';
 
@@ -229,6 +228,30 @@ function removePluginDirectory() {
   return false;
 }
 
+function removeManagedStatusLineConfig() {
+  try {
+    return removeManagedStatusLine(CLAUDE_SETTINGS_PATH, HOME_DIR);
+  } catch (err) {
+    return { changed: false, restored: false, error: err.message };
+  }
+}
+
+function removeManagedHooksConfig() {
+  try {
+    return removeManagedHooks(CLAUDE_HOOKS_PATH);
+  } catch (err) {
+    return { changed: false, removed: 0, error: err.message };
+  }
+}
+
+function removeLegacyManagedHooksConfig() {
+  try {
+    return cleanupLegacyManagedHooksFile(CLAUDE_LEGACY_HOOKS_PATH);
+  } catch (err) {
+    return { changed: false, removed: 0, error: err.message };
+  }
+}
+
 /**
  * Remove config directory
  */
@@ -255,7 +278,8 @@ function main() {
     console.log('  Cleans up Plexor integration before npm uninstall.');
     console.log('');
     console.log('  Options:');
-    console.log('    --remove-config, -c  Also remove ~/.plexor/ config directory');
+    console.log('    --keep-config, -k    Preserve ~/.plexor/ config directory');
+    console.log('    --remove-config, -c  Legacy alias (config is removed by default)');
     console.log('    --quiet, -q          Suppress output messages');
     console.log('    --help, -h           Show this help message');
     console.log('');
@@ -265,7 +289,7 @@ function main() {
     process.exit(0);
   }
 
-  const removeConfig = args.includes('--remove-config') || args.includes('-c');
+  const removeConfig = !(args.includes('--keep-config') || args.includes('-k'));
   const quiet = args.includes('--quiet') || args.includes('-q');
 
   if (!quiet) {
@@ -295,7 +319,36 @@ function main() {
       : `  ✗ Failed to remove routing: ${routingResult.message}`);
   }
 
-  // 2. Remove slash command .md files
+  // 2. Remove managed Plexor status line
+  const statusLineResult = removeManagedStatusLineConfig();
+  if (!quiet) {
+    if (statusLineResult.error) {
+      console.log(`  ✗ Failed to clean Plexor status line: ${statusLineResult.error}`);
+    } else if (statusLineResult.changed) {
+      console.log('  ✓ Restored Claude status line configuration');
+    } else {
+      console.log('  ○ Claude status line already clean');
+    }
+  }
+
+  const hooksResult = removeManagedHooksConfig();
+  const legacyHooksResult = removeLegacyManagedHooksConfig();
+  if (!quiet) {
+    if (hooksResult.error) {
+      console.log(`  ✗ Failed to clean Plexor hooks: ${hooksResult.error}`);
+    } else if (hooksResult.changed) {
+      console.log('  ✓ Restored Claude hook configuration');
+    } else {
+      console.log('  ○ Claude hooks already clean');
+    }
+    if (legacyHooksResult.error) {
+      console.log(`  ✗ Failed to clean legacy ~/.claude/hooks.json: ${legacyHooksResult.error}`);
+    } else if (legacyHooksResult.changed) {
+      console.log('  ✓ Cleaned legacy ~/.claude/hooks.json');
+    }
+  }
+
+  // 3. Remove slash command .md files
   const cmdResult = removeSlashCommands();
   if (!quiet) {
     console.log(`  ✓ Removed ${cmdResult.removed} slash command files`);
@@ -304,7 +357,7 @@ function main() {
     }
   }
 
-  // 3. Remove plugin directory
+  // 4. Remove plugin directory
   const pluginRemoved = removePluginDirectory();
   if (!quiet) {
     console.log(pluginRemoved
@@ -312,7 +365,7 @@ function main() {
       : '  ○ Plugin directory not found (already clean)');
   }
 
-  // 4. Optionally remove config directory
+  // 5. Remove config directory unless explicitly preserved
   if (removeConfig) {
     const configRemoved = removeConfigDirectory();
     if (!quiet) {
@@ -337,8 +390,7 @@ function main() {
 
     if (!removeConfig) {
       console.log('  Note: ~/.plexor/ config directory was preserved.');
-      console.log('  To also remove it: plexor-uninstall --remove-config');
-      console.log('  Or manually: rm -rf ~/.plexor');
+      console.log('  To remove it manually: rm -rf ~/.plexor');
       console.log('');
     }
   }

package/hooks/session-sync.js

@@ -0,0 +1,194 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+const https = require('https');
+const http = require('http');
+const { CONFIG_PATH, SESSION_PATH, PLEXOR_DIR } = require('../lib/constants');
+
+function readJson(filePath) {
+  try {
+    if (!fs.existsSync(filePath)) return null;
+    const raw = fs.readFileSync(filePath, 'utf8');
+    return raw && raw.trim() ? JSON.parse(raw) : null;
+  } catch {
+    return null;
+  }
+}
+
+function writeJsonAtomically(filePath, value) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true, mode: 0o700 });
+  const tempPath = `${filePath}.tmp.${Date.now()}`;
+  fs.writeFileSync(tempPath, JSON.stringify(value, null, 2), { mode: 0o600 });
+  fs.renameSync(tempPath, filePath);
+}
+
+function readStdin() {
+  return new Promise((resolve) => {
+    let data = '';
+    process.stdin.setEncoding('utf8');
+    process.stdin.on('data', (chunk) => { data += chunk; });
+    process.stdin.on('end', () => resolve(data));
+    process.stdin.resume();
+  });
+}
+
+function clampNonNegative(value) {
+  return Number.isFinite(value) ? Math.max(0, value) : 0;
+}
+
+function finiteOrZero(value) {
+  return Number.isFinite(value) ? value : 0;
+}
+
+function parseStats(payload) {
+  const summary = payload?.summary || payload || {};
+  return {
+    total_requests: Number(summary.total_requests ?? payload?.total_requests ?? 0),
+    total_optimizations: Number(summary.total_optimizations ?? payload?.total_optimizations ?? 0),
+    original_tokens: Number(summary.original_tokens ?? payload?.original_tokens ?? 0),
+    optimized_tokens: Number(summary.optimized_tokens ?? payload?.optimized_tokens ?? 0),
+    tokens_saved: Number(summary.tokens_saved ?? payload?.tokens_saved ?? 0),
+    total_cost: Number(summary.total_cost ?? payload?.total_cost ?? 0),
+    baseline_cost: Number(summary.baseline_cost ?? payload?.baseline_cost ?? payload?.total_baseline_cost ?? 0),
+    cost_saved: Number(summary.cost_saved ?? payload?.cost_saved ?? payload?.total_savings ?? 0)
+  };
+}
+
+function fetchJson(apiUrl, endpoint, apiKey) {
+  return new Promise((resolve, reject) => {
+    const url = new URL(endpoint, apiUrl.replace(/\/$/, '') + '/');
+    const client = url.protocol === 'https:' ? https : http;
+    const req = client.request({
+      hostname: url.hostname,
+      port: url.port || (url.protocol === 'https:' ? 443 : 80),
+      path: `${url.pathname}${url.search}`,
+      method: 'GET',
+      headers: {
+        'X-API-Key': apiKey,
+        'X-Plexor-Key': apiKey,
+        'User-Agent': 'plexor-session-sync/0.1.0-beta.24'
+      },
+      timeout: 5000
+    }, (res) => {
+      let body = '';
+      res.on('data', (chunk) => { body += chunk; });
+      res.on('end', () => {
+        try {
+          const parsed = JSON.parse(body);
+          if (res.statusCode >= 200 && res.statusCode < 300) {
+            resolve(parsed);
+          } else {
+            reject(new Error(parsed.message || `HTTP ${res.statusCode}`));
+          }
+        } catch {
+          reject(new Error(`Invalid JSON response: ${body.slice(0, 120)}`));
+        }
+      });
+    });
+    req.on('error', reject);
+    req.on('timeout', () => {
+      req.destroy(new Error('Request timeout'));
+    });
+    req.end();
+  });
+}
+
+function loadConfig() {
+  const config = readJson(CONFIG_PATH);
+  const apiKey = config?.auth?.api_key || '';
+  const apiUrl = config?.settings?.apiUrl || 'https://staging.api.plexor.dev';
+  const enabled = config?.settings?.enabled !== false;
+  if (!enabled || !apiKey.startsWith('plx_')) {
+    return null;
+  }
+  return { config, apiKey, apiUrl };
+}
+
+function buildSessionRecord(sessionId, baseline, nowIso) {
+  return {
+    session_id: sessionId || `session_${Date.now()}`,
+    started_at: nowIso,
+    last_activity: Date.now(),
+    requests: 0,
+    optimizations: 0,
+    cache_hits: 0,
+    passthroughs: 0,
+    original_tokens: 0,
+    optimized_tokens: 0,
+    tokens_saved: 0,
+    output_tokens: 0,
+    baseline_cost: 0,
+    actual_cost: 0,
+    cost_delta: 0,
+    cost_saved: 0,
+    _baseline: baseline
+  };
+}
+
+async function main() {
+  const mode = process.argv[2] || 'stop';
+  const inputRaw = await readStdin();
+  let input = {};
+  try {
+    input = inputRaw && inputRaw.trim() ? JSON.parse(inputRaw) : {};
+  } catch {
+    input = {};
+  }
+
+  if (mode === 'end') {
+    try {
+      fs.rmSync(SESSION_PATH, { force: true });
+    } catch {
+      // Session cleanup must not interrupt Claude shutdown.
+    }
+    process.exit(0);
+  }
+
+  const loaded = loadConfig();
+  if (!loaded) {
+    process.exit(0);
+  }
+
+  try {
+    const statsPayload = await fetchJson(loaded.apiUrl, '/v1/stats', loaded.apiKey);
+    const current = parseStats(statsPayload);
+    const nowIso = new Date().toISOString();
+    const sessionId = input.session_id || input.sessionId || null;
+    const existing = readJson(SESSION_PATH);
+
+    if (mode === 'start' || !existing || !existing._baseline || (sessionId && existing.session_id !== sessionId)) {
+      const baseline = { ...current };
+      writeJsonAtomically(SESSION_PATH, buildSessionRecord(sessionId, baseline, nowIso));
+      process.exit(0);
+    }
+
+    const baseline = existing._baseline || {};
+    const baselineCost = clampNonNegative(current.baseline_cost - Number(baseline.baseline_cost || 0));
+    const actualCost = clampNonNegative(current.total_cost - Number(baseline.total_cost || 0));
+    const next = {
+      ...existing,
+      session_id: sessionId || existing.session_id,
+      last_activity: Date.now(),
+      requests: clampNonNegative(current.total_requests - Number(baseline.total_requests || 0)),
+      optimizations: clampNonNegative(current.total_optimizations - Number(baseline.total_optimizations || 0)),
+      original_tokens: clampNonNegative(current.original_tokens - Number(baseline.original_tokens || 0)),
+      optimized_tokens: clampNonNegative(current.optimized_tokens - Number(baseline.optimized_tokens || 0)),
+      tokens_saved: clampNonNegative(current.tokens_saved - Number(baseline.tokens_saved || 0)),
+      baseline_cost: baselineCost,
+      actual_cost: actualCost,
+      cost_delta: finiteOrZero(baselineCost - actualCost),
+      cost_saved: clampNonNegative(current.cost_saved - Number(baseline.cost_saved || 0)),
+      _baseline: baseline
+    };
+
+    if (!fs.existsSync(PLEXOR_DIR)) {
+      fs.mkdirSync(PLEXOR_DIR, { recursive: true, mode: 0o700 });
+    }
+    writeJsonAtomically(SESSION_PATH, next);
+  } catch {
+    // Hook failures must not interrupt Claude.
+  }
+}
+
+main();