@kaitranntt/ccs 2.5.1 → 3.0.1

package/bin/config-manager.js

@@ -4,6 +4,7 @@ const fs = require('fs');
 const path = require('path');
 const os = require('os');
 const { error, expandPath } = require('./helpers');
+const { ErrorManager } = require('./error-manager');
 
 // Get config file path
 function getConfigPath() {
@@ -16,7 +17,15 @@ function readConfig() {
 
   // Check config exists
   if (!fs.existsSync(configPath)) {
-    error(`Config file not found: ${configPath}`);
+    // Attempt recovery
+    const RecoveryManager = require('./recovery-manager');
+    const recovery = new RecoveryManager();
+    recovery.ensureConfigJson();
+
+    if (!fs.existsSync(configPath)) {
+      ErrorManager.showInvalidConfig(configPath, 'File not found');
+      process.exit(1);
+    }
   }
 
   // Read and parse JSON
@@ -25,12 +34,14 @@ function readConfig() {
     const configContent = fs.readFileSync(configPath, 'utf8');
     config = JSON.parse(configContent);
   } catch (e) {
-    error(`Invalid JSON in ${configPath}: ${e.message}`);
+    ErrorManager.showInvalidConfig(configPath, `Invalid JSON: ${e.message}`);
+    process.exit(1);
   }
 
   // Validate config has profiles object
   if (!config.profiles || typeof config.profiles !== 'object') {
-    error(`Config must have 'profiles' object in ${configPath}`);
+    ErrorManager.showInvalidConfig(configPath, "Missing 'profiles' object");
+    process.exit(1);
   }
 
   return config;
@@ -44,8 +55,10 @@ function getSettingsPath(profile) {
   const settingsPath = config.profiles[profile];
 
   if (!settingsPath) {
-    const availableProfiles = Object.keys(config.profiles).join(', ');
-    error(`Profile '${profile}' not found. Available: ${availableProfiles}`);
+    const availableProfiles = Object.keys(config.profiles);
+    const profileList = availableProfiles.map(p => `  - ${p}`);
+    ErrorManager.showProfileNotFound(profile, profileList);
+    process.exit(1);
   }
 
   // Expand path
@@ -53,7 +66,22 @@ function getSettingsPath(profile) {
 
   // Validate settings file exists
   if (!fs.existsSync(expandedPath)) {
-    error(`Settings file not found: ${expandedPath}`);
+    // Auto-create if it's ~/.claude/settings.json
+    if (expandedPath.includes('.claude') && expandedPath.endsWith('settings.json')) {
+      const RecoveryManager = require('./recovery-manager');
+      const recovery = new RecoveryManager();
+      recovery.ensureClaudeSettings();
+
+      if (!fs.existsSync(expandedPath)) {
+        ErrorManager.showSettingsNotFound(expandedPath);
+        process.exit(1);
+      }
+
+      console.log('[i] Auto-created missing settings file');
+    } else {
+      ErrorManager.showSettingsNotFound(expandedPath);
+      process.exit(1);
+    }
   }
 
   // Validate settings file is valid JSON
@@ -61,7 +89,8 @@ function getSettingsPath(profile) {
     const settingsContent = fs.readFileSync(expandedPath, 'utf8');
     JSON.parse(settingsContent);
   } catch (e) {
-    error(`Invalid JSON in ${expandedPath}: ${e.message}`);
+    ErrorManager.showInvalidConfig(expandedPath, `Invalid JSON: ${e.message}`);
+    process.exit(1);
   }
 
   return expandedPath;

package/bin/doctor.js

@@ -0,0 +1,365 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { spawn } = require('child_process');
+const { colored } = require('./helpers');
+const { detectClaudeCli } = require('./claude-detector');
+
+/**
+ * Health check results
+ */
+class HealthCheck {
+  constructor() {
+    this.checks = [];
+    this.warnings = [];
+    this.errors = [];
+  }
+
+  addCheck(name, status, message = '', fix = null) {
+    this.checks.push({ name, status, message, fix });
+
+    if (status === 'error') this.errors.push({ name, message, fix });
+    if (status === 'warning') this.warnings.push({ name, message, fix });
+  }
+
+  hasErrors() {
+    return this.errors.length > 0;
+  }
+
+  hasWarnings() {
+    return this.warnings.length > 0;
+  }
+
+  isHealthy() {
+    return !this.hasErrors();
+  }
+}
+
+/**
+ * CCS Health Check and Diagnostics
+ */
+class Doctor {
+  constructor() {
+    this.homedir = os.homedir();
+    this.ccsDir = path.join(this.homedir, '.ccs');
+    this.claudeDir = path.join(this.homedir, '.claude');
+    this.results = new HealthCheck();
+  }
+
+  /**
+   * Run all health checks
+   */
+  async runAllChecks() {
+    console.log(colored('Running CCS Health Check...', 'cyan'));
+    console.log('');
+
+    await this.checkClaudeCli();
+    this.checkCcsDirectory();
+    this.checkConfigFiles();
+    this.checkClaudeSettings();
+    this.checkProfiles();
+    this.checkInstances();
+    this.checkPermissions();
+
+    this.showReport();
+    return this.results;
+  }
+
+  /**
+   * Check 1: Claude CLI availability
+   */
+  async checkClaudeCli() {
+    process.stdout.write('[?] Checking Claude CLI... ');
+
+    const claudeCli = detectClaudeCli();
+
+    // Try to execute claude --version
+    try {
+      const result = await new Promise((resolve, reject) => {
+        const child = spawn(claudeCli, ['--version'], {
+          stdio: 'pipe',
+          timeout: 5000
+        });
+
+        let output = '';
+        child.stdout.on('data', data => output += data);
+        child.stderr.on('data', data => output += data);
+
+        child.on('close', code => {
+          if (code === 0) resolve(output);
+          else reject(new Error('Exit code ' + code));
+        });
+
+        child.on('error', reject);
+      });
+
+      console.log(colored('[OK]', 'green'));
+      this.results.addCheck('Claude CLI', 'success', `Found: ${claudeCli}`);
+    } catch (err) {
+      console.log(colored('[X]', 'red'));
+      this.results.addCheck(
+        'Claude CLI',
+        'error',
+        'Claude CLI not found or not working',
+        'Install from: https://docs.claude.com/en/docs/claude-code/installation'
+      );
+    }
+  }
+
+  /**
+   * Check 2: ~/.ccs/ directory
+   */
+  checkCcsDirectory() {
+    process.stdout.write('[?] Checking ~/.ccs/ directory... ');
+
+    if (fs.existsSync(this.ccsDir)) {
+      console.log(colored('[OK]', 'green'));
+      this.results.addCheck('CCS Directory', 'success');
+    } else {
+      console.log(colored('[X]', 'red'));
+      this.results.addCheck(
+        'CCS Directory',
+        'error',
+        '~/.ccs/ directory not found',
+        'Run: npm install -g @kaitranntt/ccs --force'
+      );
+    }
+  }
+
+  /**
+   * Check 3: Config files
+   */
+  checkConfigFiles() {
+    const files = [
+      { path: path.join(this.ccsDir, 'config.json'), name: 'config.json' },
+      { path: path.join(this.ccsDir, 'glm.settings.json'), name: 'glm.settings.json' },
+      { path: path.join(this.ccsDir, 'kimi.settings.json'), name: 'kimi.settings.json' }
+    ];
+
+    for (const file of files) {
+      process.stdout.write(`[?] Checking ${file.name}... `);
+
+      if (!fs.existsSync(file.path)) {
+        console.log(colored('[X]', 'red'));
+        this.results.addCheck(
+          file.name,
+          'error',
+          `${file.name} not found`,
+          'Run: npm install -g @kaitranntt/ccs --force'
+        );
+        continue;
+      }
+
+      // Validate JSON
+      try {
+        const content = fs.readFileSync(file.path, 'utf8');
+        JSON.parse(content);
+        console.log(colored('[OK]', 'green'));
+        this.results.addCheck(file.name, 'success');
+      } catch (e) {
+        console.log(colored('[X]', 'red'));
+        this.results.addCheck(
+          file.name,
+          'error',
+          `Invalid JSON: ${e.message}`,
+          `Backup and recreate: mv ${file.path} ${file.path}.backup && npm install -g @kaitranntt/ccs --force`
+        );
+      }
+    }
+  }
+
+  /**
+   * Check 4: Claude settings
+   */
+  checkClaudeSettings() {
+    process.stdout.write('[?] Checking ~/.claude/settings.json... ');
+
+    const settingsPath = path.join(this.claudeDir, 'settings.json');
+
+    if (!fs.existsSync(settingsPath)) {
+      console.log(colored('[!]', 'yellow'));
+      this.results.addCheck(
+        'Claude Settings',
+        'warning',
+        '~/.claude/settings.json not found',
+        'Run: claude /login'
+      );
+      return;
+    }
+
+    // Validate JSON
+    try {
+      const content = fs.readFileSync(settingsPath, 'utf8');
+      JSON.parse(content);
+      console.log(colored('[OK]', 'green'));
+      this.results.addCheck('Claude Settings', 'success');
+    } catch (e) {
+      console.log(colored('[!]', 'yellow'));
+      this.results.addCheck(
+        'Claude Settings',
+        'warning',
+        `Invalid JSON: ${e.message}`,
+        'Run: claude /login'
+      );
+    }
+  }
+
+  /**
+   * Check 5: Profile configurations
+   */
+  checkProfiles() {
+    process.stdout.write('[?] Checking profiles... ');
+
+    const configPath = path.join(this.ccsDir, 'config.json');
+    if (!fs.existsSync(configPath)) {
+      console.log(colored('[SKIP]', 'yellow'));
+      return;
+    }
+
+    try {
+      const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+
+      if (!config.profiles || typeof config.profiles !== 'object') {
+        console.log(colored('[X]', 'red'));
+        this.results.addCheck(
+          'Profiles',
+          'error',
+          'config.json missing profiles object',
+          'Run: npm install -g @kaitranntt/ccs --force'
+        );
+        return;
+      }
+
+      const profileCount = Object.keys(config.profiles).length;
+      console.log(colored('[OK]', 'green'), `(${profileCount} profiles)`);
+      this.results.addCheck('Profiles', 'success', `${profileCount} profiles configured`);
+    } catch (e) {
+      console.log(colored('[X]', 'red'));
+      this.results.addCheck('Profiles', 'error', e.message);
+    }
+  }
+
+  /**
+   * Check 6: Instance directories (account-based profiles)
+   */
+  checkInstances() {
+    process.stdout.write('[?] Checking instances... ');
+
+    const instancesDir = path.join(this.ccsDir, 'instances');
+    if (!fs.existsSync(instancesDir)) {
+      console.log(colored('[i]', 'cyan'), '(no account profiles)');
+      this.results.addCheck('Instances', 'success', 'No account profiles configured');
+      return;
+    }
+
+    const instances = fs.readdirSync(instancesDir).filter(name => {
+      return fs.statSync(path.join(instancesDir, name)).isDirectory();
+    });
+
+    if (instances.length === 0) {
+      console.log(colored('[i]', 'cyan'), '(no account profiles)');
+      this.results.addCheck('Instances', 'success', 'No account profiles');
+      return;
+    }
+
+    console.log(colored('[OK]', 'green'), `(${instances.length} instances)`);
+    this.results.addCheck('Instances', 'success', `${instances.length} account profiles`);
+  }
+
+  /**
+   * Check 7: File permissions
+   */
+  checkPermissions() {
+    process.stdout.write('[?] Checking permissions... ');
+
+    const testFile = path.join(this.ccsDir, '.permission-test');
+
+    try {
+      fs.writeFileSync(testFile, 'test', 'utf8');
+      fs.unlinkSync(testFile);
+      console.log(colored('[OK]', 'green'));
+      this.results.addCheck('Permissions', 'success');
+    } catch (e) {
+      console.log(colored('[X]', 'red'));
+      this.results.addCheck(
+        'Permissions',
+        'error',
+        'Cannot write to ~/.ccs/',
+        'Fix: sudo chown -R $USER ~/.ccs ~/.claude && chmod 755 ~/.ccs ~/.claude'
+      );
+    }
+  }
+
+  /**
+   * Show health check report
+   */
+  showReport() {
+    console.log('');
+    console.log(colored('═══════════════════════════════════════════', 'cyan'));
+    console.log(colored('Health Check Report', 'bold'));
+    console.log(colored('═══════════════════════════════════════════', 'cyan'));
+    console.log('');
+
+    if (this.results.isHealthy() && !this.results.hasWarnings()) {
+      console.log(colored('✓ All checks passed!', 'green'));
+      console.log('');
+      console.log('Your CCS installation is healthy.');
+      console.log('');
+      return;
+    }
+
+    // Show errors
+    if (this.results.hasErrors()) {
+      console.log(colored('Errors:', 'red'));
+      this.results.errors.forEach(err => {
+        console.log(`  [X] ${err.name}: ${err.message}`);
+        if (err.fix) {
+          console.log(`      Fix: ${err.fix}`);
+        }
+      });
+      console.log('');
+    }
+
+    // Show warnings
+    if (this.results.hasWarnings()) {
+      console.log(colored('Warnings:', 'yellow'));
+      this.results.warnings.forEach(warn => {
+        console.log(`  [!] ${warn.name}: ${warn.message}`);
+        if (warn.fix) {
+          console.log(`      Fix: ${warn.fix}`);
+        }
+      });
+      console.log('');
+    }
+
+    // Summary
+    if (this.results.hasErrors()) {
+      console.log(colored('Status: Installation has errors', 'red'));
+      console.log('Run suggested fixes above to resolve issues.');
+    } else {
+      console.log(colored('Status: Installation healthy (warnings only)', 'green'));
+    }
+
+    console.log('');
+  }
+
+  /**
+   * Generate JSON report
+   */
+  generateJsonReport() {
+    return JSON.stringify({
+      timestamp: new Date().toISOString(),
+      platform: process.platform,
+      nodeVersion: process.version,
+      ccsVersion: require('../package.json').version,
+      checks: this.results.checks,
+      errors: this.results.errors,
+      warnings: this.results.warnings,
+      healthy: this.results.isHealthy()
+    }, null, 2);
+  }
+}
+
+module.exports = Doctor;

package/bin/error-manager.js

@@ -0,0 +1,159 @@
+'use strict';
+
+const { colored } = require('./helpers');
+
+/**
+ * Error types with structured messages
+ */
+const ErrorTypes = {
+  NO_CLAUDE_CLI: 'NO_CLAUDE_CLI',
+  MISSING_SETTINGS: 'MISSING_SETTINGS',
+  INVALID_CONFIG: 'INVALID_CONFIG',
+  UNKNOWN_PROFILE: 'UNKNOWN_PROFILE',
+  PERMISSION_DENIED: 'PERMISSION_DENIED',
+  GENERIC: 'GENERIC'
+};
+
+/**
+ * Enhanced error manager with context-aware messages
+ */
+class ErrorManager {
+  /**
+   * Show Claude CLI not found error
+   */
+  static showClaudeNotFound() {
+    console.error('');
+    console.error(colored('╔══════════════════════════════════════════════════════════╗', 'red'));
+    console.error(colored('║  ERROR: Claude CLI not found                             ║', 'red'));
+    console.error(colored('╚══════════════════════════════════════════════════════════╝', 'red'));
+    console.error('');
+    console.error('CCS requires Claude CLI to be installed.');
+    console.error('');
+    console.error(colored('Fix:', 'yellow'));
+    console.error('  1. Install Claude CLI:');
+    console.error('     https://docs.claude.com/en/docs/claude-code/installation');
+    console.error('');
+    console.error('  2. Verify installation:');
+    console.error('     command -v claude   (Unix)');
+    console.error('     Get-Command claude  (Windows)');
+    console.error('');
+    console.error('  3. Custom path (if installed elsewhere):');
+    console.error('     export CCS_CLAUDE_PATH="/path/to/claude"');
+    console.error('');
+    console.error('Restart terminal after installation.');
+    console.error('');
+  }
+
+  /**
+   * Show settings file not found error
+   * @param {string} settingsPath - Path to missing settings file
+   */
+  static showSettingsNotFound(settingsPath) {
+    const isClaudeSettings = settingsPath.includes('.claude') && settingsPath.endsWith('settings.json');
+
+    console.error('');
+    console.error(colored('╔══════════════════════════════════════════════════════════╗', 'red'));
+    console.error(colored('║  ERROR: Settings file not found                          ║', 'red'));
+    console.error(colored('╚══════════════════════════════════════════════════════════╝', 'red'));
+    console.error('');
+    console.error(`File: ${settingsPath}`);
+    console.error('');
+
+    if (isClaudeSettings) {
+      console.error('This file is auto-created when you login to Claude CLI.');
+      console.error('');
+      console.error(colored('Fix (copy-paste):', 'yellow'));
+      console.error(`  echo '{}' > ${settingsPath}`);
+      console.error('  claude /login');
+      console.error('');
+      console.error('Why: Newer Claude CLI versions require explicit login.');
+    } else {
+      console.error(colored('Fix (copy-paste):', 'yellow'));
+      console.error('  npm install -g @kaitranntt/ccs --force');
+      console.error('');
+      console.error('This will recreate missing profile settings.');
+    }
+
+    console.error('');
+  }
+
+  /**
+   * Show invalid configuration error
+   * @param {string} configPath - Path to invalid config
+   * @param {string} errorDetail - JSON parse error detail
+   */
+  static showInvalidConfig(configPath, errorDetail) {
+    console.error('');
+    console.error(colored('╔══════════════════════════════════════════════════════════╗', 'red'));
+    console.error(colored('║  ERROR: Configuration invalid                            ║', 'red'));
+    console.error(colored('╚══════════════════════════════════════════════════════════╝', 'red'));
+    console.error('');
+    console.error(`File: ${configPath}`);
+    console.error(`Issue: ${errorDetail}`);
+    console.error('');
+    console.error(colored('Fix (copy-paste):', 'yellow'));
+    console.error('  # Backup corrupted file');
+    console.error(`  mv ${configPath} ${configPath}.backup`);
+    console.error('');
+    console.error('  # Reinstall CCS');
+    console.error('  npm install -g @kaitranntt/ccs --force');
+    console.error('');
+    console.error('Your profile settings will be preserved.');
+    console.error('');
+  }
+
+  /**
+   * Show profile not found error
+   * @param {string} profileName - Requested profile name
+   * @param {string[]} availableProfiles - List of available profiles
+   * @param {string} suggestion - Suggested profile name (fuzzy match)
+   */
+  static showProfileNotFound(profileName, availableProfiles, suggestion = null) {
+    console.error('');
+    console.error(colored('╔══════════════════════════════════════════════════════════╗', 'red'));
+    console.error(colored(`║  ERROR: Profile '${profileName}' not found${' '.repeat(Math.max(0, 35 - profileName.length))}║`, 'red'));
+    console.error(colored('╚══════════════════════════════════════════════════════════╝', 'red'));
+    console.error('');
+    console.error(colored('Available profiles:', 'cyan'));
+    availableProfiles.forEach(line => console.error(`  ${line}`));
+    console.error('');
+    console.error(colored('Fix:', 'yellow'));
+    console.error('  # Use existing profile');
+    console.error('  ccs <profile> "your prompt"');
+    console.error('');
+    console.error('  # Create new account profile');
+    console.error('  ccs auth create <name>');
+    console.error('');
+
+    if (suggestion) {
+      console.error(colored(`Did you mean: ${suggestion}`, 'yellow'));
+      console.error('');
+    }
+  }
+
+  /**
+   * Show permission denied error
+   * @param {string} path - Path with permission issue
+   */
+  static showPermissionDenied(path) {
+    console.error('');
+    console.error(colored('╔══════════════════════════════════════════════════════════╗', 'red'));
+    console.error(colored('║  ERROR: Permission denied                                ║', 'red'));
+    console.error(colored('╚══════════════════════════════════════════════════════════╝', 'red'));
+    console.error('');
+    console.error(`Cannot write to: ${path}`);
+    console.error('');
+    console.error(colored('Fix (copy-paste):', 'yellow'));
+    console.error('  # Fix ownership');
+    console.error('  sudo chown -R $USER ~/.ccs ~/.claude');
+    console.error('');
+    console.error('  # Fix permissions');
+    console.error('  chmod 755 ~/.ccs ~/.claude');
+    console.error('');
+    console.error('  # Retry installation');
+    console.error('  npm install -g @kaitranntt/ccs --force');
+    console.error('');
+  }
+}
+
+module.exports = { ErrorManager, ErrorTypes };