@kaitranntt/ccs 2.5.1 → 3.0.1

package/bin/auth-commands.js

@@ -0,0 +1,405 @@
+'use strict';
+
+const { spawn } = require('child_process');
+const ProfileRegistry = require('./profile-registry');
+const InstanceManager = require('./instance-manager');
+const { colored } = require('./helpers');
+const { detectClaudeCli } = require('./claude-detector');
+
+/**
+ * Auth Commands (Simplified)
+ *
+ * CLI interface for CCS multi-account management.
+ * Commands: create, list, show, remove, default
+ *
+ * Login-per-profile model: Each profile is an isolated Claude instance.
+ * Users login directly in each instance (no credential copying).
+ */
+class AuthCommands {
+  constructor() {
+    this.registry = new ProfileRegistry();
+    this.instanceMgr = new InstanceManager();
+  }
+
+  /**
+   * Show help for auth commands
+   */
+  showHelp() {
+    console.log(colored('CCS Account Management', 'bold'));
+    console.log('');
+    console.log(colored('Usage:', 'cyan'));
+    console.log(`  ${colored('ccs auth', 'yellow')} <command> [options]`);
+    console.log('');
+    console.log(colored('Commands:', 'cyan'));
+    console.log(`  ${colored('create <profile>', 'yellow')}        Create new profile and login`);
+    console.log(`  ${colored('list', 'yellow')}                   List all saved profiles`);
+    console.log(`  ${colored('show <profile>', 'yellow')}         Show profile details`);
+    console.log(`  ${colored('remove <profile>', 'yellow')}       Remove saved profile`);
+    console.log(`  ${colored('default <profile>', 'yellow')}      Set default profile`);
+    console.log('');
+    console.log(colored('Examples:', 'cyan'));
+    console.log(`  ${colored('ccs auth create work', 'yellow')}                     # Create & login to work profile`);
+    console.log(`  ${colored('ccs auth list', 'yellow')}                            # List all profiles`);
+    console.log(`  ${colored('ccs work "review code"', 'yellow')}                   # Use work profile`);
+    console.log('');
+    console.log(colored('Options:', 'cyan'));
+    console.log(`  ${colored('--force', 'yellow')}                   Allow overwriting existing profile`);
+    console.log('');
+  }
+
+  /**
+   * Create new profile and prompt for login
+   * @param {Array} args - Command arguments
+   */
+  async handleCreate(args) {
+    const profileName = args.find(arg => !arg.startsWith('--'));
+    const force = args.includes('--force');
+
+    if (!profileName) {
+      console.error('[X] Profile name is required');
+      console.log('');
+      console.log(`Usage: ${colored('ccs auth create <profile> [--force]', 'yellow')}`);
+      console.log('');
+      console.log('Example:');
+      console.log(`  ${colored('ccs auth create work', 'yellow')}`);
+      process.exit(1);
+    }
+
+    // Check if profile already exists
+    if (!force && this.registry.hasProfile(profileName)) {
+      console.error(`[X] Profile already exists: ${profileName}`);
+      console.log(`    Use ${colored('--force', 'yellow')} to overwrite`);
+      process.exit(1);
+    }
+
+    try {
+      // Create instance directory
+      console.log(`[i] Creating profile: ${profileName}`);
+      const instancePath = this.instanceMgr.ensureInstance(profileName);
+
+      // Create/update profile entry
+      if (this.registry.hasProfile(profileName)) {
+        this.registry.updateProfile(profileName, {
+          type: 'account'
+        });
+      } else {
+        this.registry.createProfile(profileName, {
+          type: 'account'
+        });
+      }
+
+      console.log(`[i] Instance directory: ${instancePath}`);
+      console.log('');
+      console.log(colored('[i] Starting Claude in isolated instance...', 'yellow'));
+      console.log(colored('[i] You will be prompted to login with your account.', 'yellow'));
+      console.log('');
+
+      // Detect Claude CLI
+      const claudeCli = detectClaudeCli();
+      if (!claudeCli) {
+        console.error('[X] Claude CLI not found');
+        console.log('');
+        console.log('Please install Claude CLI first:');
+        console.log('  https://claude.ai/download');
+        process.exit(1);
+      }
+
+      // Execute Claude in isolated instance (will auto-prompt for login if no credentials)
+      const child = spawn(claudeCli, [], {
+        stdio: 'inherit',
+        env: { ...process.env, CLAUDE_CONFIG_DIR: instancePath }
+      });
+
+      child.on('exit', (code) => {
+        if (code === 0) {
+          console.log('');
+          console.log(colored('[OK] Profile created successfully', 'green'));
+          console.log('');
+          console.log(`  Profile: ${profileName}`);
+          console.log(`  Instance: ${instancePath}`);
+          console.log('');
+          console.log('Usage:');
+          console.log(`  ${colored(`ccs ${profileName} "your prompt here"`, 'yellow')}`);
+          console.log('');
+          process.exit(0);
+        } else {
+          console.log('');
+          console.error('[X] Login failed or cancelled');
+          console.log('');
+          console.log('To retry:');
+          console.log(`  ${colored(`ccs auth create ${profileName} --force`, 'yellow')}`);
+          console.log('');
+          process.exit(1);
+        }
+      });
+
+      child.on('error', (err) => {
+        console.error(`[X] Failed to execute Claude CLI: ${err.message}`);
+        process.exit(1);
+      });
+
+    } catch (error) {
+      console.error(`[X] Failed to create profile: ${error.message}`);
+      process.exit(1);
+    }
+  }
+
+  /**
+   * List all saved profiles
+   * @param {Array} args - Command arguments
+   */
+  async handleList(args) {
+    const verbose = args.includes('--verbose');
+
+    try {
+      const profiles = this.registry.getAllProfiles();
+      const defaultProfile = this.registry.getDefaultProfile();
+      const profileNames = Object.keys(profiles);
+
+      if (profileNames.length === 0) {
+        console.log(colored('No account profiles found', 'yellow'));
+        console.log('');
+        console.log('To create your first profile:');
+        console.log(`  ${colored('ccs auth create <profile>', 'yellow')}  # Create and login to profile`);
+        console.log('');
+        console.log('Example:');
+        console.log(`  ${colored('ccs auth create work', 'yellow')}`);
+        console.log('');
+        return;
+      }
+
+      console.log(colored('Saved Account Profiles:', 'bold'));
+      console.log('');
+
+      // Sort by last_used (descending), then alphabetically
+      const sorted = profileNames.sort((a, b) => {
+        const aProfile = profiles[a];
+        const bProfile = profiles[b];
+
+        // Default first
+        if (a === defaultProfile) return -1;
+        if (b === defaultProfile) return 1;
+
+        // Then by last_used
+        if (aProfile.last_used && bProfile.last_used) {
+          return new Date(bProfile.last_used) - new Date(aProfile.last_used);
+        }
+        if (aProfile.last_used) return -1;
+        if (bProfile.last_used) return 1;
+
+        // Then alphabetically
+        return a.localeCompare(b);
+      });
+
+      sorted.forEach(name => {
+        const profile = profiles[name];
+        const isDefault = name === defaultProfile;
+        const indicator = isDefault ? colored('[*]', 'green') : '[ ]';
+
+        console.log(`${indicator} ${colored(name, 'cyan')}${isDefault ? colored(' (default)', 'green') : ''}`);
+
+        console.log(`    Type: ${profile.type || 'account'}`);
+
+        if (verbose) {
+          console.log(`    Created: ${new Date(profile.created).toLocaleString()}`);
+          if (profile.last_used) {
+            console.log(`    Last used: ${new Date(profile.last_used).toLocaleString()}`);
+          }
+        }
+
+        console.log('');
+      });
+
+      console.log(`Total profiles: ${profileNames.length}`);
+      console.log('');
+
+    } catch (error) {
+      console.error(`[X] Failed to list profiles: ${error.message}`);
+      process.exit(1);
+    }
+  }
+
+  /**
+   * Show details for a specific profile
+   * @param {Array} args - Command arguments
+   */
+  async handleShow(args) {
+    const profileName = args.find(arg => !arg.startsWith('--'));
+
+    if (!profileName) {
+      console.error('[X] Profile name is required');
+      console.log('');
+      console.log(`Usage: ${colored('ccs auth show <profile>', 'yellow')}`);
+      process.exit(1);
+    }
+
+    try {
+      const profile = this.registry.getProfile(profileName);
+      const defaultProfile = this.registry.getDefaultProfile();
+      const isDefault = profileName === defaultProfile;
+
+      console.log(colored(`Profile: ${profileName}`, 'bold'));
+      console.log('');
+      console.log(`  Type: ${profile.type || 'account'}`);
+      console.log(`  Default: ${isDefault ? 'Yes' : 'No'}`);
+      console.log(`  Instance: ${this.instanceMgr.getInstancePath(profileName)}`);
+      console.log(`  Created: ${new Date(profile.created).toLocaleString()}`);
+
+      if (profile.last_used) {
+        console.log(`  Last used: ${new Date(profile.last_used).toLocaleString()}`);
+      } else {
+        console.log(`  Last used: Never`);
+      }
+
+      console.log('');
+
+    } catch (error) {
+      console.error(`[X] ${error.message}`);
+      process.exit(1);
+    }
+  }
+
+  /**
+   * Remove a saved profile
+   * @param {Array} args - Command arguments
+   */
+  async handleRemove(args) {
+    const profileName = args.find(arg => !arg.startsWith('--'));
+    const force = args.includes('--force');
+
+    if (!profileName) {
+      console.error('[X] Profile name is required');
+      console.log('');
+      console.log(`Usage: ${colored('ccs auth remove <profile> [--force]', 'yellow')}`);
+      process.exit(1);
+    }
+
+    if (!this.registry.hasProfile(profileName)) {
+      console.error(`[X] Profile not found: ${profileName}`);
+      process.exit(1);
+    }
+
+    // Require --force for safety
+    if (!force) {
+      console.error('[X] Removal requires --force flag for safety');
+      console.log('');
+      console.log(`Run: ${colored(`ccs auth remove ${profileName} --force`, 'yellow')}`);
+      process.exit(1);
+    }
+
+    try {
+      // Delete instance
+      this.instanceMgr.deleteInstance(profileName);
+
+      // Delete profile
+      this.registry.deleteProfile(profileName);
+
+      console.log(colored('[OK] Profile removed successfully', 'green'));
+      console.log(`    Profile: ${profileName}`);
+      console.log('');
+
+    } catch (error) {
+      console.error(`[X] Failed to remove profile: ${error.message}`);
+      process.exit(1);
+    }
+  }
+
+  /**
+   * Set default profile
+   * @param {Array} args - Command arguments
+   */
+  async handleDefault(args) {
+    const profileName = args.find(arg => !arg.startsWith('--'));
+
+    if (!profileName) {
+      console.error('[X] Profile name is required');
+      console.log('');
+      console.log(`Usage: ${colored('ccs auth default <profile>', 'yellow')}`);
+      process.exit(1);
+    }
+
+    try {
+      this.registry.setDefaultProfile(profileName);
+
+      console.log(colored('[OK] Default profile set', 'green'));
+      console.log(`    Profile: ${profileName}`);
+      console.log('');
+      console.log('Now you can use:');
+      console.log(`  ${colored('ccs "your prompt"', 'yellow')}  # Uses ${profileName} profile`);
+      console.log('');
+
+    } catch (error) {
+      console.error(`[X] ${error.message}`);
+      process.exit(1);
+    }
+  }
+
+  /**
+   * Route auth command to appropriate handler
+   * @param {Array} args - Command arguments
+   */
+  async route(args) {
+    if (args.length === 0 || args[0] === '--help' || args[0] === '-h' || args[0] === 'help') {
+      this.showHelp();
+      return;
+    }
+
+    const command = args[0];
+    const commandArgs = args.slice(1);
+
+    switch (command) {
+      case 'create':
+        await this.handleCreate(commandArgs);
+        break;
+
+      case 'save':
+        // Deprecated - redirect to create
+        console.log(colored('[!] Command "save" is deprecated', 'yellow'));
+        console.log(`    Use: ${colored('ccs auth create <profile>', 'yellow')} instead`);
+        console.log('');
+        await this.handleCreate(commandArgs);
+        break;
+
+      case 'list':
+        await this.handleList(commandArgs);
+        break;
+
+      case 'show':
+        await this.handleShow(commandArgs);
+        break;
+
+      case 'remove':
+        await this.handleRemove(commandArgs);
+        break;
+
+      case 'default':
+        await this.handleDefault(commandArgs);
+        break;
+
+      case 'current':
+        console.log(colored('[!] Command "current" has been removed', 'yellow'));
+        console.log('');
+        console.log('Each profile has its own login in an isolated instance.');
+        console.log('Use "ccs auth list" to see all profiles.');
+        console.log('');
+        break;
+
+      case 'cleanup':
+        console.log(colored('[!] Command "cleanup" has been removed', 'yellow'));
+        console.log('');
+        console.log('No cleanup needed - no separate vault files.');
+        console.log('Use "ccs auth list" to see all profiles.');
+        console.log('');
+        break;
+
+      default:
+        console.error(`[X] Unknown command: ${command}`);
+        console.log('');
+        console.log('Run for help:');
+        console.log(`  ${colored('ccs auth --help', 'yellow')}`);
+        process.exit(1);
+    }
+  }
+}
+
+module.exports = AuthCommands;

package/bin/ccs.js

@@ -4,9 +4,12 @@
 const { spawn } = require('child_process');
 const path = require('path');
 const fs = require('fs');
+const os = require('os');
 const { error, colored } = require('./helpers');
 const { detectClaudeCli, showClaudeNotFoundError } = require('./claude-detector');
 const { getSettingsPath, getConfigPath } = require('./config-manager');
+const { ErrorManager } = require('./error-manager');
+const RecoveryManager = require('./recovery-manager');
 
 // Version (sync with package.json)
 const CCS_VERSION = require('../package.json').version;
@@ -18,10 +21,13 @@ function escapeShellArg(arg) {
 }
 
 // Execute Claude CLI with unified spawn logic
-function execClaude(claudeCli, args) {
+function execClaude(claudeCli, args, envVars = null) {
   const isWindows = process.platform === 'win32';
   const needsShell = isWindows && /\.(cmd|bat|ps1)$/i.test(claudeCli);
 
+  // Prepare environment (merge with process.env if envVars provided)
+  const env = envVars ? { ...process.env, ...envVars } : process.env;
+
   let child;
   if (needsShell) {
     // When shell needed: concatenate into string to avoid DEP0190 warning
@@ -29,13 +35,15 @@ function execClaude(claudeCli, args) {
     child = spawn(cmdString, {
       stdio: 'inherit',
       windowsHide: true,
-      shell: true
+      shell: true,
+      env
     });
   } else {
     // When no shell needed: use array form (faster, no shell overhead)
     child = spawn(claudeCli, args, {
       stdio: 'inherit',
-      windowsHide: true
+      windowsHide: true,
+      env
     });
   }
 
@@ -91,19 +99,34 @@ function handleHelpCommand() {
 
   // Description
   console.log(colored('Description:', 'cyan'));
-  console.log('  Switch between Claude models instantly. Stop hitting rate limits.');
-  console.log('  Maps profile names to Claude settings files via ~/.ccs/config.json');
+  console.log('  Switch between multiple Claude accounts (work, personal, team) and');
+  console.log('  alternative models (GLM, Kimi) instantly. Concurrent sessions with');
+  console.log('  auto-recovery. Zero downtime.');
+  console.log('');
+
+  // Model Switching
+  console.log(colored('Model Switching:', 'cyan'));
+  console.log(`  ${colored('ccs', 'yellow')}                         Use default Claude account`);
+  console.log(`  ${colored('ccs glm', 'yellow')}                     Switch to GLM 4.6 model`);
+  console.log(`  ${colored('ccs kimi', 'yellow')}                    Switch to Kimi for Coding`);
+  console.log(`  ${colored('ccs glm', 'yellow')} "debug this code"   Use GLM and run command`);
   console.log('');
 
-  // Profile Switching
-  console.log(colored('Profile Switching:', 'cyan'));
-  console.log(`  ${colored('ccs', 'yellow')}                         Use default profile`);
-  console.log(`  ${colored('ccs glm', 'yellow')}                     Switch to GLM profile`);
-  console.log(`  ${colored('ccs kimi', 'yellow')}                    Switch to Kimi profile`);
-  console.log(`  ${colored('ccs glm', 'yellow')} "debug this code"   Switch to GLM and run command`);
-  console.log(`  ${colored('ccs kimi', 'yellow')} "write tests"      Switch to Kimi and run command`);
-  console.log(`  ${colored('ccs glm', 'yellow')} --verbose           Switch to GLM with Claude flags`);
-  console.log(`  ${colored('ccs kimi', 'yellow')} --verbose           Switch to Kimi with Claude flags`);
+  // Account Management
+  console.log(colored('Account Management:', 'cyan'));
+  console.log(`  ${colored('ccs auth create <profile>', 'yellow')}   Create new profile and login`);
+  console.log(`  ${colored('ccs auth list', 'yellow')}               List all saved profiles`);
+  console.log(`  ${colored('ccs auth show <profile>', 'yellow')}     Show profile details`);
+  console.log(`  ${colored('ccs auth remove <profile>', 'yellow')}   Remove profile (requires --force)`);
+  console.log(`  ${colored('ccs auth default <profile>', 'yellow')}  Set default profile`);
+  console.log(`  ${colored('ccs work', 'yellow')}                    Switch to work account`);
+  console.log(`  ${colored('ccs personal', 'yellow')}                Switch to personal account`);
+  console.log(`  ${colored('ccs work', 'yellow')} "review code"      Run command with work account`);
+  console.log('');
+
+  // Diagnostics
+  console.log(colored('Diagnostics:', 'cyan'));
+  console.log(`  ${colored('ccs doctor', 'yellow')}                  Run health check and diagnostics`);
   console.log('');
 
   // Flags
@@ -183,6 +206,16 @@ function handleUninstallCommand() {
   process.exit(0);
 }
 
+async function handleDoctorCommand() {
+  const Doctor = require('./doctor');
+  const doctor = new Doctor();
+
+  await doctor.runAllChecks();
+
+  // Exit with error code if unhealthy
+  process.exit(doctor.results.isHealthy() ? 0 : 1);
+}
+
 // Smart profile detection
 function detectProfile(args) {
   if (args.length === 0 || args[0].startsWith('-')) {
@@ -195,7 +228,7 @@ function detectProfile(args) {
 }
 
 // Main execution
-function main() {
+async function main() {
   const args = process.argv.slice(2);
 
   // Special case: version command (check BEFORE profile detection)
@@ -222,36 +255,81 @@ function main() {
     return;
   }
 
-  // Detect profile
-  const { profile, remainingArgs } = detectProfile(args);
-
-  // Special case: "default" profile just runs claude directly
-  if (profile === 'default') {
-    const claudeCli = detectClaudeCli();
-    if (!claudeCli) {
-      showClaudeNotFoundError();
-      process.exit(1);
-    }
+  // Special case: doctor command
+  if (firstArg === 'doctor' || firstArg === '--doctor') {
+    await handleDoctorCommand();
+    return;
+  }
 
-    execClaude(claudeCli, remainingArgs);
+  // Special case: auth command (multi-account management)
+  if (firstArg === 'auth') {
+    const AuthCommands = require('./auth-commands');
+    const authCommands = new AuthCommands();
+    await authCommands.route(args.slice(1));
     return;
   }
 
-  // Get settings path for profile
-  const settingsPath = getSettingsPath(profile);
+  // Auto-recovery for missing configuration
+  const recovery = new RecoveryManager();
+  const recovered = recovery.recoverAll();
 
-  // Detect Claude CLI
-  const claudeCli = detectClaudeCli();
+  if (recovered) {
+    recovery.showRecoveryHints();
+  }
 
-  // Check if claude was found
+  // Detect profile
+  const { profile, remainingArgs } = detectProfile(args);
+
+  // Detect Claude CLI first (needed for all paths)
+  const claudeCli = detectClaudeCli();
   if (!claudeCli) {
-    showClaudeNotFoundError();
+    ErrorManager.showClaudeNotFound();
     process.exit(1);
   }
 
-  // Execute claude with --settings
-  execClaude(claudeCli, ['--settings', settingsPath, ...remainingArgs]);
+  // Use ProfileDetector to determine profile type
+  const ProfileDetector = require('./profile-detector');
+  const InstanceManager = require('./instance-manager');
+  const ProfileRegistry = require('./profile-registry');
+  const { getSettingsPath } = require('./config-manager');
+
+  const detector = new ProfileDetector();
+
+  try {
+    const profileInfo = detector.detectProfileType(profile);
+
+    if (profileInfo.type === 'settings') {
+      // EXISTING FLOW: Settings-based profile (glm, kimi)
+      // Use --settings flag (backward compatible)
+      const expandedSettingsPath = getSettingsPath(profileInfo.name);
+      execClaude(claudeCli, ['--settings', expandedSettingsPath, ...remainingArgs]);
+    } else if (profileInfo.type === 'account') {
+      // NEW FLOW: Account-based profile (work, personal)
+      // All platforms: Use instance isolation with CLAUDE_CONFIG_DIR
+      const registry = new ProfileRegistry();
+      const instanceMgr = new InstanceManager();
+
+      // Ensure instance exists (lazy init if needed)
+      const instancePath = instanceMgr.ensureInstance(profileInfo.name);
+
+      // Update last_used timestamp
+      registry.touchProfile(profileInfo.name);
+
+      // Execute Claude with instance isolation
+      const envVars = { CLAUDE_CONFIG_DIR: instancePath };
+      execClaude(claudeCli, remainingArgs, envVars);
+    } else {
+      // DEFAULT: No profile configured, use Claude's own defaults
+      execClaude(claudeCli, remainingArgs);
+    }
+  } catch (error) {
+    console.error(`[X] ${error.message}`);
+    process.exit(1);
+  }
 }
 
 // Run main
-main();
+main().catch(error => {
+  console.error('Fatal error:', error.message);
+  process.exit(1);
+});