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

package/hooks/statusline.js

@@ -0,0 +1,130 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { execSync } = require('child_process');
+const { PREVIOUS_STATUS_LINE_KEY, getManagedStatusLineCommand } = require('../lib/statusline-manager');
+
+const ANSI_BLUE = '\x1b[38;5;153m';
+const ANSI_GREEN = '\x1b[32m';
+const ANSI_RESET = '\x1b[0m';
+
+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 isManagedGatewayUrl(baseUrl = '') {
+  return (
+    baseUrl.includes('plexor') ||
+    baseUrl.includes('staging.api') ||
+    baseUrl.includes('localhost') ||
+    baseUrl.includes('127.0.0.1') ||
+    baseUrl.includes('ngrok') ||
+    baseUrl.includes('localtunnel')
+  );
+}
+
+function getGatewayLabel(baseUrl = '') {
+  if (baseUrl.includes('staging.api')) return 'staging';
+  if (baseUrl.includes('localhost') || baseUrl.includes('127.0.0.1')) return 'localhost';
+  return 'prod';
+}
+
+function formatUsd(value) {
+  if (!Number.isFinite(value)) {
+    return '';
+  }
+
+  if (Math.abs(value) === 0) {
+    return '$0.00';
+  }
+  if (Math.abs(value) >= 1) {
+    return `$${value.toFixed(2)}`;
+  }
+  if (Math.abs(value) >= 0.01) {
+    return `$${value.toFixed(3)}`;
+  }
+  return `$${value.toFixed(4)}`;
+}
+
+function runPreviousStatusLine(statusLine, homeDir) {
+  if (!statusLine || typeof statusLine !== 'object' || statusLine.type !== 'command' || !statusLine.command) {
+    return '';
+  }
+
+  const managedCommand = getManagedStatusLineCommand(homeDir);
+  if (String(statusLine.command) === managedCommand) {
+    return '';
+  }
+
+  try {
+    const output = execSync(String(statusLine.command), {
+      cwd: homeDir,
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'ignore'],
+      timeout: 1000
+    }).trim();
+    return output.split('\n')[0] || '';
+  } catch {
+    return '';
+  }
+}
+
+function buildPlexorSegment(config, settings) {
+  const authKey = config?.auth?.api_key || '';
+  const enabled = config?.settings?.enabled !== false;
+  const baseUrl = settings?.env?.ANTHROPIC_BASE_URL || '';
+  if (!enabled || !authKey.startsWith('plx_') || !isManagedGatewayUrl(baseUrl)) {
+    return '';
+  }
+
+  const gateway = getGatewayLabel(baseUrl);
+  const mode = config?.settings?.mode || 'balanced';
+  const provider = config?.settings?.preferred_provider || 'auto';
+  return `PLEXOR ${gateway} ${mode} ${provider}`;
+}
+
+function buildSavingsSegment(session) {
+  const explicitDelta = Number(session?.cost_delta);
+  const costSaved = Number(session?.cost_saved);
+  const rawCostDelta = Number.isFinite(explicitDelta)
+    ? explicitDelta
+    : ((Number.isFinite(costSaved) && costSaved !== 0)
+      ? costSaved
+      : (Number(session?.baseline_cost) - Number(session?.actual_cost)));
+  const costDelta = Number.isFinite(rawCostDelta) ? rawCostDelta : 0;
+  return `cost-delta ${costDelta < 0 ? '-' : ''}${formatUsd(Math.abs(costDelta))}`;
+}
+
+function main() {
+  const homeDir = os.homedir();
+  const config = readJson(path.join(homeDir, '.plexor', 'config.json')) || {};
+  const settings = readJson(path.join(homeDir, '.claude', 'settings.json')) || {};
+  const session = readJson(path.join(homeDir, '.plexor', 'session.json')) || {};
+
+  const plexorSegment = buildPlexorSegment(config, settings);
+  const savingsSegment = plexorSegment ? buildSavingsSegment(session) : '';
+  const previous = runPreviousStatusLine(settings[PREVIOUS_STATUS_LINE_KEY], homeDir);
+
+  const coloredPlexor = plexorSegment ? `${ANSI_BLUE}${plexorSegment}${ANSI_RESET}` : '';
+  const coloredSavings = savingsSegment ? `${ANSI_GREEN}${savingsSegment}${ANSI_RESET}` : '';
+
+  if (!coloredPlexor && previous) {
+    process.stdout.write(previous);
+    return;
+  }
+
+  const line = [coloredPlexor, coloredSavings, previous].filter(Boolean).join(' · ');
+  if (line) {
+    process.stdout.write(line);
+  }
+}
+
+main();

package/lib/config-utils.js

@@ -113,6 +113,30 @@ 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 buildManagedAnthropicHeaders(config) {
   const settings = config?.settings || {};
   const headers = {};
@@ -308,6 +332,7 @@ module.exports = {
   readSetting,
   hasForcedHintConflict,
   validateForcedHintConfig,
+  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/plexor-client.js

@@ -31,7 +31,7 @@ class PlexorClient {
           'Content-Type': 'application/json',
           'X-API-Key': this.apiKey,
           'X-Plexor-Key': this.apiKey,
-          'User-Agent': 'plexor-claude-code-plugin/0.1.0-beta.23'
+          'User-Agent': 'plexor-claude-code-plugin/0.1.0-beta.24'
         },
         timeout: this.timeout
       };

package/lib/settings-manager.js

@@ -14,6 +14,7 @@ const fs = require('fs');
 const path = require('path');
 const os = require('os');
 const crypto = require('crypto');
+const { removeManagedClaudeCustomHeadersFromEnv } = 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');
@@ -92,8 +93,9 @@ 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;
   }
 
@@ -346,6 +348,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
@@ -365,6 +368,7 @@ class ClaudeSettingsManager {
       }
 
       if (claudeStateChanged && !this.saveClaudeState(claudeState)) {
+        this.save(previousSettings);
         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.23",
+  "version": "0.1.0-beta.25",
   "description": "STAGING - LLM cost optimization plugin for Claude Code (internal testing)",
   "main": "lib/constants.js",
   "bin": {