@plexor-dev/claude-code-plugin-localhost 0.1.0-localhost.1

package/scripts/postinstall.js

@@ -0,0 +1,342 @@
+#!/usr/bin/env node
+
+/**
+ * Plexor Claude Code Plugin - Postinstall Script
+ *
+ * Copies slash commands to ~/.claude/commands/ and creates
+ * the ~/.plexor/ configuration directory.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { execSync } = require('child_process');
+
+/**
+ * Get the correct home directory, accounting for sudo.
+ * When running with sudo, os.homedir() returns /root, but we want
+ * the actual user's home directory.
+ */
+function getHomeDir() {
+  // Check if running with sudo - SUDO_USER contains the original username
+  if (process.env.SUDO_USER) {
+    // On Linux/Mac, home directories are typically /home/<user> or /Users/<user>
+    const platform = os.platform();
+    if (platform === 'darwin') {
+      return path.join('/Users', process.env.SUDO_USER);
+    } else if (platform === 'linux') {
+      return path.join('/home', process.env.SUDO_USER);
+    }
+  }
+  return os.homedir();
+}
+
+/**
+ * Get uid/gid for the target user (handles sudo case).
+ * Returns null if not running with sudo or on Windows.
+ */
+function getTargetUserIds() {
+  const sudoUser = process.env.SUDO_USER;
+  if (!sudoUser || os.platform() === 'win32') {
+    return null;
+  }
+
+  try {
+    // Get uid and gid for the sudo user
+    const uid = parseInt(execSync(`id -u ${sudoUser}`, { encoding: 'utf8' }).trim(), 10);
+    const gid = parseInt(execSync(`id -g ${sudoUser}`, { encoding: 'utf8' }).trim(), 10);
+    return { uid, gid, user: sudoUser };
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Recursively chown a directory and all its contents.
+ */
+function chownRecursive(dirPath, uid, gid) {
+  if (!fs.existsSync(dirPath)) return;
+
+  const stat = fs.statSync(dirPath);
+  fs.chownSync(dirPath, uid, gid);
+
+  if (stat.isDirectory()) {
+    const entries = fs.readdirSync(dirPath);
+    for (const entry of entries) {
+      chownRecursive(path.join(dirPath, entry), uid, gid);
+    }
+  }
+}
+
+const HOME_DIR = getHomeDir();
+const COMMANDS_SOURCE = path.join(__dirname, '..', 'commands');
+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_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');
+
+/**
+ * Check for orphaned Plexor routing in settings.json without valid config.
+ * This can happen if a previous uninstall was incomplete.
+ */
+function checkOrphanedRouting() {
+  const home = process.env.HOME || process.env.USERPROFILE;
+  if (!home) return;
+
+  const settingsPath = path.join(home, '.claude', 'settings.json');
+  const configPath = path.join(home, '.plexor', 'config.json');
+
+  try {
+    if (!fs.existsSync(settingsPath)) return;
+
+    const settings = JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
+    const env = settings.env || {};
+
+    const hasPlexorUrl = env.ANTHROPIC_BASE_URL &&
+                         env.ANTHROPIC_BASE_URL.includes('plexor');
+
+    if (hasPlexorUrl) {
+      // Check if there's a valid Plexor config
+      let hasValidConfig = false;
+      try {
+        if (fs.existsSync(configPath)) {
+          const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+          hasValidConfig = config.apiKey && config.apiKey.startsWith('plx_');
+        }
+      } catch (e) {}
+
+      if (!hasValidConfig) {
+        console.log('\n  Warning: Detected orphaned Plexor routing in Claude settings');
+        console.log('  This may be from a previous installation.\n');
+        console.log('  Run /plexor-login to reconfigure, or');
+        console.log('  Run /plexor-uninstall to clean up\n');
+      } else {
+        console.log('\n  Existing Plexor configuration detected');
+        console.log('  Your previous settings have been preserved.\n');
+      }
+    }
+  } catch (e) {
+    // Ignore errors in detection - don't break install
+  }
+}
+
+// Default configuration for new installs
+// LOCALHOST PACKAGE
+const DEFAULT_CONFIG = {
+  version: 1,
+  auth: {
+    mode: "pending",
+    authenticated_at: null
+  },
+  settings: {
+    enabled: true,
+    apiUrl: "http://localhost:8000",
+    mode: "balanced",
+    localCacheEnabled: true
+  }
+};
+
+function main() {
+  // Check for orphaned routing at start of postinstall
+  checkOrphanedRouting();
+
+  try {
+    // Get target user info for chown (if running with sudo)
+    const targetUser = getTargetUserIds();
+
+    // Create ~/.claude/commands/ if not exists
+    fs.mkdirSync(CLAUDE_COMMANDS_DIR, { recursive: true });
+
+    // Create ~/.claude/plugins/plexor/commands/ for JS executors
+    fs.mkdirSync(PLEXOR_PLUGINS_DIR, { recursive: true });
+
+    // Create ~/.claude/plugins/plexor/lib/ for shared modules
+    fs.mkdirSync(PLEXOR_LIB_DIR, { recursive: true });
+
+    // Create ~/.plexor/ with secure permissions (owner only)
+    fs.mkdirSync(PLEXOR_CONFIG_DIR, { recursive: true, mode: 0o700 });
+
+    // Create default config.json if it doesn't exist
+    let configCreated = false;
+    if (!fs.existsSync(PLEXOR_CONFIG_FILE)) {
+      fs.writeFileSync(
+        PLEXOR_CONFIG_FILE,
+        JSON.stringify(DEFAULT_CONFIG, null, 2),
+        { mode: 0o600 }
+      );
+      configCreated = true;
+    }
+
+    // Get list of command files (.md for Claude, .js for executors)
+    const mdFiles = fs.readdirSync(COMMANDS_SOURCE)
+      .filter(f => f.endsWith('.md'));
+    const jsFiles = fs.readdirSync(COMMANDS_SOURCE)
+      .filter(f => f.endsWith('.js'));
+
+    if (mdFiles.length === 0) {
+      console.error('No command files found in package. Installation may be corrupt.');
+      process.exit(1);
+    }
+
+    const installed = [];
+    const backed_up = [];
+
+    // Copy .md command files to ~/.claude/commands/
+    for (const file of mdFiles) {
+      const src = path.join(COMMANDS_SOURCE, file);
+      const dest = path.join(CLAUDE_COMMANDS_DIR, file);
+
+      // Backup existing file if present and different
+      if (fs.existsSync(dest)) {
+        const existingContent = fs.readFileSync(dest, 'utf8');
+        const newContent = fs.readFileSync(src, 'utf8');
+
+        if (existingContent !== newContent) {
+          const backupPath = dest + '.backup';
+          fs.copyFileSync(dest, backupPath);
+          backed_up.push(file);
+        }
+      }
+
+      fs.copyFileSync(src, dest);
+      installed.push(file.replace('.md', ''));
+    }
+
+    // Copy .js executor files to ~/.claude/plugins/plexor/commands/
+    const jsInstalled = [];
+    for (const file of jsFiles) {
+      const src = path.join(COMMANDS_SOURCE, file);
+      const dest = path.join(PLEXOR_PLUGINS_DIR, file);
+      fs.copyFileSync(src, dest);
+      // Make executable
+      fs.chmodSync(dest, 0o755);
+      jsInstalled.push(file);
+    }
+
+    // Copy lib files to ~/.claude/plugins/plexor/lib/
+    // CRITICAL: These are required for commands to work
+    const libInstalled = [];
+    if (fs.existsSync(LIB_SOURCE)) {
+      const libFiles = fs.readdirSync(LIB_SOURCE).filter(f => f.endsWith('.js'));
+      if (libFiles.length === 0) {
+        console.warn('  ⚠ Warning: No lib files found in package. Commands may not work.');
+      }
+      for (const file of libFiles) {
+        try {
+          const src = path.join(LIB_SOURCE, file);
+          const dest = path.join(PLEXOR_LIB_DIR, file);
+          fs.copyFileSync(src, dest);
+          libInstalled.push(file);
+        } catch (err) {
+          console.error(`  ✗ Failed to copy lib/${file}: ${err.message}`);
+        }
+      }
+    } else {
+      console.error('  ✗ CRITICAL: lib/ directory not found in package.');
+      console.error('    Commands will fail. Please reinstall the package.');
+      console.error(`    Expected location: ${LIB_SOURCE}`);
+    }
+
+    // Verify critical lib file exists
+    const criticalLibFile = path.join(PLEXOR_LIB_DIR, 'settings-manager.js');
+    if (!fs.existsSync(criticalLibFile)) {
+      console.error('');
+      console.error('  ✗ CRITICAL: settings-manager.js was not installed.');
+      console.error('    This file is required for commands to work.');
+      console.error('    Try reinstalling: npm install @plexor-dev/claude-code-plugin-localhost');
+      console.error('');
+    }
+
+    // Fix file ownership when running with sudo
+    // Files are created as root but should be owned by the original user
+    if (targetUser) {
+      const { uid, gid } = targetUser;
+      // Chown the .claude directory and all contents we created
+      chownRecursive(path.join(HOME_DIR, '.claude'), uid, gid);
+      // Chown the .plexor directory and all contents
+      chownRecursive(PLEXOR_CONFIG_DIR, uid, gid);
+    }
+
+    // Detect shell type
+    const shell = process.env.SHELL || '';
+    const isZsh = shell.includes('zsh');
+    const shellRc = isZsh ? '~/.zshrc' : '~/.bashrc';
+
+    // Print success message with clear onboarding steps
+    console.log('');
+    console.log('  ╔═══════════════════════════════════════════════════════════════════╗');
+    console.log('  ║                                                                   ║');
+    console.log('  ║   Plexor Claude Code Plugin installed successfully!              ║');
+    console.log('  ║                                                                   ║');
+    console.log('  ╚═══════════════════════════════════════════════════════════════════╝');
+    console.log('');
+
+    if (configCreated) {
+      console.log('  ✓ Created ~/.plexor/config.json');
+    }
+    console.log(`  ✓ Installed ${installed.length} slash commands to ~/.claude/commands/`);
+    if (jsInstalled.length > 0) {
+      console.log(`  ✓ Installed ${jsInstalled.length} executors to ~/.claude/plugins/plexor/commands/`);
+    }
+    if (libInstalled.length > 0) {
+      console.log(`  ✓ Installed ${libInstalled.length} lib modules to ~/.claude/plugins/plexor/lib/`);
+    }
+    if (targetUser) {
+      console.log(`  ✓ Set file ownership to ${targetUser.user}`);
+    }
+    console.log('');
+
+    // CRITICAL: Make the required step VERY obvious
+    console.log('  ┌─────────────────────────────────────────────────────────────────┐');
+    console.log('  │  REQUIRED: Run this command to enable Plexor routing:          │');
+    console.log('  └─────────────────────────────────────────────────────────────────┘');
+    console.log('');
+    console.log('  For Claude MAX users (OAuth):');
+    console.log('');
+    console.log(`    echo 'export ANTHROPIC_BASE_URL="http://localhost:8000/gateway/anthropic"' >> ${shellRc}`);
+    console.log(`    source ${shellRc}`);
+    console.log('');
+    console.log('  For API key users (get key at https://plexor.dev/dashboard):');
+    console.log('');
+    console.log(`    echo 'export ANTHROPIC_BASE_URL="http://localhost:8000/gateway/anthropic"' >> ${shellRc}`);
+    console.log(`    echo 'export ANTHROPIC_API_KEY="plx_your_key_here"' >> ${shellRc}`);
+    console.log(`    source ${shellRc}`);
+    console.log('');
+    console.log('  ┌─────────────────────────────────────────────────────────────────┐');
+    console.log('  │  Then start Claude Code and run: /plexor-status                │');
+    console.log('  └─────────────────────────────────────────────────────────────────┘');
+    console.log('');
+    console.log('  Available commands:');
+    console.log('    /plexor-setup    - First-time setup wizard');
+    console.log('    /plexor-login    - Authenticate with API key');
+    console.log('    /plexor-status   - Check connection and see savings');
+    console.log('    /plexor-enabled  - Enable/disable Plexor routing');
+    console.log('');
+    console.log('  Documentation: https://plexor.dev/docs');
+    console.log('');
+
+    if (backed_up.length > 0) {
+      console.log('  Note: Existing files backed up (.backup):');
+      backed_up.forEach(f => console.log(`    ${f}`));
+      console.log('');
+    }
+
+  } catch (error) {
+    console.error('');
+    console.error('  Plexor plugin installation failed');
+    console.error('');
+    console.error(`  Error: ${error.message}`);
+    console.error('');
+    console.error('  Troubleshooting:');
+    console.error('    - Ensure you have write access to ~/.claude/commands/');
+    console.error('    - Try running with sudo if permission denied');
+    console.error('');
+    console.error('  Report issues: https://github.com/plexor-ai/claude-code-plugin/issues');
+    console.error('');
+    process.exit(1);
+  }
+}
+
+main();

package/scripts/uninstall.js

@@ -0,0 +1,154 @@
+#!/usr/bin/env node
+
+/**
+ * Plexor Claude Code Plugin (Staging) - Comprehensive Uninstall Script
+ *
+ * Runs on npm uninstall (when npm actually calls it).
+ * Also callable directly: node scripts/uninstall.js
+ *
+ * Performs complete cleanup:
+ * 1. Removes Plexor routing from ~/.claude/settings.json
+ * 2. Removes slash command files from ~/.claude/commands/
+ * 3. Removes plugin directory from ~/.claude/plugins/plexor/
+ * 4. Restores any backups if they exist
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+// Get home directory - support both Unix and Windows
+const home = process.env.HOME || process.env.USERPROFILE;
+if (!home) {
+  console.log('Warning: HOME not set, skipping cleanup');
+  process.exit(0);
+}
+
+console.log('');
+console.log('  Plexor plugin cleanup...');
+console.log('');
+
+const results = {
+  routing: false,
+  commands: [],
+  restored: [],
+  pluginDir: false
+};
+
+// 1. Remove routing from settings.json
+// This is CRITICAL - do NOT depend on settings-manager module since it may not load during uninstall
+try {
+  const settingsPath = path.join(home, '.claude', 'settings.json');
+  if (fs.existsSync(settingsPath)) {
+    const data = fs.readFileSync(settingsPath, 'utf8');
+    if (data && data.trim()) {
+      const settings = JSON.parse(data);
+      if (settings.env) {
+        const hadBaseUrl = !!settings.env.ANTHROPIC_BASE_URL;
+        const hadAuthToken = !!settings.env.ANTHROPIC_AUTH_TOKEN;
+
+        delete settings.env.ANTHROPIC_BASE_URL;
+        delete settings.env.ANTHROPIC_AUTH_TOKEN;
+
+        // Clean up empty env block
+        if (Object.keys(settings.env).length === 0) {
+          delete settings.env;
+        }
+
+        if (hadBaseUrl || hadAuthToken) {
+          fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2), { mode: 0o600 });
+          results.routing = true;
+        }
+      }
+    }
+  }
+} catch (e) {
+  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'
+];
+
+try {
+  const commandsDir = path.join(home, '.claude', 'commands');
+  if (fs.existsSync(commandsDir)) {
+    for (const cmd of plexorCommands) {
+      const cmdPath = path.join(commandsDir, cmd);
+      const backupPath = cmdPath + '.backup';
+
+      if (fs.existsSync(cmdPath)) {
+        fs.unlinkSync(cmdPath);
+        results.commands.push(cmd.replace('.md', ''));
+
+        // Restore backup if it exists
+        if (fs.existsSync(backupPath)) {
+          fs.renameSync(backupPath, cmdPath);
+          results.restored.push(cmd);
+        }
+      }
+    }
+  }
+} catch (e) {
+  console.log(`  Warning: Could not clean commands: ${e.message}`);
+}
+
+// 3. Remove plugin directory
+try {
+  const pluginDir = path.join(home, '.claude', 'plugins', 'plexor');
+  if (fs.existsSync(pluginDir)) {
+    fs.rmSync(pluginDir, { recursive: true, force: true });
+    results.pluginDir = true;
+  }
+} catch (e) {
+  console.log(`  Warning: Could not remove plugin directory: ${e.message}`);
+}
+
+// Output results
+if (results.routing || results.commands.length > 0 || results.pluginDir) {
+  console.log('  Plexor plugin uninstalled');
+  console.log('');
+
+  if (results.routing) {
+    console.log('  Removed Plexor routing from Claude settings');
+    console.log('    (Claude Code now connects directly to Anthropic)');
+    console.log('');
+  }
+
+  if (results.commands.length > 0) {
+    console.log('  Removed commands:');
+    results.commands.forEach(cmd => console.log(`    /${cmd}`));
+    console.log('');
+  }
+
+  if (results.restored.length > 0) {
+    console.log('  Restored from backup:');
+    results.restored.forEach(f => console.log(`    ${f}`));
+    console.log('');
+  }
+
+  if (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('');
+} else {
+  console.log('  No Plexor components found to clean up.');
+  console.log('');
+}
+
+console.log('  Cleanup complete');
+console.log('');