@kaitranntt/ccs 4.3.10 → 5.0.0

package/bin/management/instance-manager.js

@@ -1,207 +0,0 @@
-'use strict';
-
-const fs = require('fs');
-const path = require('path');
-const os = require('os');
-const SharedManager = require('./shared-manager');
-
-/**
- * Instance Manager (Simplified)
- *
- * Manages isolated Claude CLI instances per profile for concurrent sessions.
- * Each instance is an isolated CLAUDE_CONFIG_DIR where users login directly.
- * No credential copying/encryption - Claude manages credentials per instance.
- */
-class InstanceManager {
-  constructor() {
-    this.instancesDir = path.join(os.homedir(), '.ccs', 'instances');
-    this.sharedManager = new SharedManager();
-  }
-
-  /**
-   * Ensure instance exists for profile (lazy init only)
-   * @param {string} profileName - Profile name
-   * @returns {string} Instance path
-   */
-  ensureInstance(profileName) {
-    const instancePath = this.getInstancePath(profileName);
-
-    // Lazy initialization
-    if (!fs.existsSync(instancePath)) {
-      this.initializeInstance(profileName, instancePath);
-    }
-
-    // Validate structure (auto-fix missing dirs)
-    this.validateInstance(instancePath);
-
-    return instancePath;
-  }
-
-  /**
-   * Get instance path for profile
-   * @param {string} profileName - Profile name
-   * @returns {string} Instance directory path
-   */
-  getInstancePath(profileName) {
-    const safeName = this._sanitizeName(profileName);
-    return path.join(this.instancesDir, safeName);
-  }
-
-  /**
-   * Initialize new instance directory
-   * @param {string} profileName - Profile name
-   * @param {string} instancePath - Instance directory path
-   * @throws {Error} If initialization fails
-   */
-  initializeInstance(profileName, instancePath) {
-    try {
-      // Create base directory
-      fs.mkdirSync(instancePath, { recursive: true, mode: 0o700 });
-
-      // Create Claude-expected subdirectories (profile-specific only)
-      const subdirs = [
-        'session-env',
-        'todos',
-        'logs',
-        'file-history',
-        'shell-snapshots',
-        'debug',
-        '.anthropic'
-      ];
-
-      subdirs.forEach(dir => {
-        const dirPath = path.join(instancePath, dir);
-        if (!fs.existsSync(dirPath)) {
-          fs.mkdirSync(dirPath, { recursive: true, mode: 0o700 });
-        }
-      });
-
-      // Symlink shared directories (Phase 1: commands, skills)
-      this.sharedManager.linkSharedDirectories(instancePath);
-
-      // Copy global configs if exist (settings.json only)
-      this._copyGlobalConfigs(instancePath);
-    } catch (error) {
-      throw new Error(`Failed to initialize instance for ${profileName}: ${error.message}`);
-    }
-  }
-
-  /**
-   * Validate instance directory structure (auto-fix missing directories)
-   * @param {string} instancePath - Instance path
-   */
-  validateInstance(instancePath) {
-    // Check required directories (auto-create if missing for migration)
-    const requiredDirs = [
-      'session-env',
-      'todos',
-      'logs',
-      'file-history',
-      'shell-snapshots',
-      'debug',
-      '.anthropic'
-    ];
-
-    for (const dir of requiredDirs) {
-      const dirPath = path.join(instancePath, dir);
-      if (!fs.existsSync(dirPath)) {
-        // Auto-create missing directory (migration from older versions)
-        fs.mkdirSync(dirPath, { recursive: true, mode: 0o700 });
-      }
-    }
-
-    // Note: Credentials managed by Claude CLI in instance (no validation needed)
-  }
-
-  /**
-   * Delete instance for profile
-   * @param {string} profileName - Profile name
-   */
-  deleteInstance(profileName) {
-    const instancePath = this.getInstancePath(profileName);
-
-    if (!fs.existsSync(instancePath)) {
-      return;
-    }
-
-    // Recursive delete
-    fs.rmSync(instancePath, { recursive: true, force: true });
-  }
-
-  /**
-   * List all instance names
-   * @returns {Array<string>} Instance names
-   */
-  listInstances() {
-    if (!fs.existsSync(this.instancesDir)) {
-      return [];
-    }
-
-    return fs.readdirSync(this.instancesDir)
-      .filter(name => {
-        const instancePath = path.join(this.instancesDir, name);
-        return fs.statSync(instancePath).isDirectory();
-      });
-  }
-
-  /**
-   * Check if instance exists for profile
-   * @param {string} profileName - Profile name
-   * @returns {boolean} True if exists
-   */
-  hasInstance(profileName) {
-    const instancePath = this.getInstancePath(profileName);
-    return fs.existsSync(instancePath);
-  }
-
-  /**
-   * Copy global configs to instance (optional)
-   * @param {string} instancePath - Instance path
-   */
-  _copyGlobalConfigs(instancePath) {
-    const globalConfigDir = path.join(os.homedir(), '.claude');
-
-    // Copy settings.json only (commands/skills are now symlinked to shared/)
-    const globalSettings = path.join(globalConfigDir, 'settings.json');
-    if (fs.existsSync(globalSettings)) {
-      const instanceSettings = path.join(instancePath, 'settings.json');
-      fs.copyFileSync(globalSettings, instanceSettings);
-    }
-  }
-
-  /**
-   * Copy directory recursively
-   * @param {string} src - Source directory
-   * @param {string} dest - Destination directory
-   */
-  _copyDirectory(src, dest) {
-    if (!fs.existsSync(dest)) {
-      fs.mkdirSync(dest, { recursive: true, mode: 0o700 });
-    }
-
-    const entries = fs.readdirSync(src, { withFileTypes: true });
-
-    for (const entry of entries) {
-      const srcPath = path.join(src, entry.name);
-      const destPath = path.join(dest, entry.name);
-
-      if (entry.isDirectory()) {
-        this._copyDirectory(srcPath, destPath);
-      } else {
-        fs.copyFileSync(srcPath, destPath);
-      }
-    }
-  }
-
-  /**
-   * Sanitize profile name for filesystem
-   * @param {string} name - Profile name
-   * @returns {string} Safe name
-   */
-  _sanitizeName(name) {
-    // Replace unsafe characters with dash
-    return name.replace(/[^a-zA-Z0-9_-]/g, '-').toLowerCase();
-  }
-}
-
-module.exports = InstanceManager;

package/bin/management/recovery-manager.js

@@ -1,135 +0,0 @@
-'use strict';
-
-const fs = require('fs');
-const path = require('path');
-const os = require('os');
-
-/**
- * Auto-recovery for missing or corrupted configuration
- */
-class RecoveryManager {
-  constructor() {
-    this.homedir = os.homedir();
-    this.ccsDir = path.join(this.homedir, '.ccs');
-    this.claudeDir = path.join(this.homedir, '.claude');
-    this.recovered = [];
-  }
-
-  /**
-   * Ensure ~/.ccs/ directory exists
-   */
-  ensureCcsDirectory() {
-    if (!fs.existsSync(this.ccsDir)) {
-      fs.mkdirSync(this.ccsDir, { recursive: true, mode: 0o755 });
-      this.recovered.push('Created ~/.ccs/ directory');
-      return true;
-    }
-    return false;
-  }
-
-  /**
-   * Ensure ~/.ccs/config.json exists with defaults
-   */
-  ensureConfigJson() {
-    const configPath = path.join(this.ccsDir, 'config.json');
-
-    // Check if exists and valid
-    if (fs.existsSync(configPath)) {
-      try {
-        const content = fs.readFileSync(configPath, 'utf8');
-        JSON.parse(content); // Validate JSON
-        return false; // No recovery needed
-      } catch (e) {
-        // Corrupted - backup and recreate
-        const backupPath = `${configPath}.backup.${Date.now()}`;
-        fs.renameSync(configPath, backupPath);
-        this.recovered.push(`Backed up corrupted config.json to ${path.basename(backupPath)}`);
-      }
-    }
-
-    // Create default config
-    const defaultConfig = {
-      profiles: {
-        glm: '~/.ccs/glm.settings.json',
-        kimi: '~/.ccs/kimi.settings.json',
-        default: '~/.claude/settings.json'
-      }
-    };
-
-    const tmpPath = `${configPath}.tmp`;
-    fs.writeFileSync(tmpPath, JSON.stringify(defaultConfig, null, 2) + '\n', 'utf8');
-    fs.renameSync(tmpPath, configPath);
-
-    this.recovered.push('Created ~/.ccs/config.json');
-    return true;
-  }
-
-  /**
-   * Ensure ~/.claude/settings.json exists
-   */
-  ensureClaudeSettings() {
-    const claudeSettingsPath = path.join(this.claudeDir, 'settings.json');
-
-    // Create ~/.claude/ if missing
-    if (!fs.existsSync(this.claudeDir)) {
-      fs.mkdirSync(this.claudeDir, { recursive: true, mode: 0o755 });
-      this.recovered.push('Created ~/.claude/ directory');
-    }
-
-    // Create settings.json if missing
-    if (!fs.existsSync(claudeSettingsPath)) {
-      const tmpPath = `${claudeSettingsPath}.tmp`;
-      fs.writeFileSync(tmpPath, '{}\n', 'utf8');
-      fs.renameSync(tmpPath, claudeSettingsPath);
-
-      this.recovered.push('Created ~/.claude/settings.json');
-      return true;
-    }
-
-    return false;
-  }
-
-  /**
-   * Run all recovery operations
-   * @returns {boolean} True if any recovery performed
-   */
-  recoverAll() {
-    this.recovered = [];
-
-    this.ensureCcsDirectory();
-    this.ensureConfigJson();
-    this.ensureClaudeSettings();
-
-    return this.recovered.length > 0;
-  }
-
-  /**
-   * Get recovery summary
-   * @returns {string[]} List of recovery actions performed
-   */
-  getRecoverySummary() {
-    return this.recovered;
-  }
-
-  /**
-   * Show recovery hints
-   */
-  showRecoveryHints() {
-    if (this.recovered.length === 0) return;
-
-    console.log('');
-    console.log('[i] Auto-recovery completed:');
-    this.recovered.forEach(msg => console.log(`    - ${msg}`));
-
-    // Show login hint if created Claude settings
-    if (this.recovered.some(msg => msg.includes('settings.json'))) {
-      console.log('');
-      console.log('[i] Next step: Login to Claude CLI');
-      console.log('    Run: claude /login');
-    }
-
-    console.log('');
-  }
-}
-
-module.exports = RecoveryManager;

package/bin/management/shared-manager.js

@@ -1,285 +0,0 @@
-'use strict';
-
-const fs = require('fs');
-const path = require('path');
-const os = require('os');
-
-/**
- * SharedManager - Manages symlinked shared directories for CCS
- * v3.2.0: Symlink-based architecture
- *
- * Purpose: Eliminates duplication by symlinking:
- * ~/.claude/ ← ~/.ccs/shared/ ← instance/
- */
-class SharedManager {
-  constructor() {
-    this.homeDir = os.homedir();
-    this.sharedDir = path.join(this.homeDir, '.ccs', 'shared');
-    this.claudeDir = path.join(this.homeDir, '.claude');
-    this.instancesDir = path.join(this.homeDir, '.ccs', 'instances');
-    this.sharedDirs = ['commands', 'skills', 'agents', 'plugins'];
-  }
-
-  /**
-   * Detect circular symlink before creation
-   * @param {string} target - Target path to link to
-   * @param {string} linkPath - Path where symlink will be created
-   * @returns {boolean} True if circular
-   * @private
-   */
-  _detectCircularSymlink(target, linkPath) {
-    // Check if target exists and is symlink
-    if (!fs.existsSync(target)) {
-      return false;
-    }
-
-    try {
-      const stats = fs.lstatSync(target);
-      if (!stats.isSymbolicLink()) {
-        return false;
-      }
-
-      // Resolve target's link
-      const targetLink = fs.readlinkSync(target);
-      const resolvedTarget = path.resolve(path.dirname(target), targetLink);
-
-      // Check if target points back to our shared dir or link path
-      const sharedDir = path.join(this.homeDir, '.ccs', 'shared');
-      if (resolvedTarget.startsWith(sharedDir) || resolvedTarget === linkPath) {
-        console.log(`[!] Circular symlink detected: ${target} → ${resolvedTarget}`);
-        return true;
-      }
-    } catch (err) {
-      // If can't read, assume not circular
-      return false;
-    }
-
-    return false;
-  }
-
-  /**
-   * Ensure shared directories exist as symlinks to ~/.claude/
-   * Creates ~/.claude/ structure if missing
-   */
-  ensureSharedDirectories() {
-    // Create ~/.claude/ if missing
-    if (!fs.existsSync(this.claudeDir)) {
-      console.log('[i] Creating ~/.claude/ directory structure');
-      fs.mkdirSync(this.claudeDir, { recursive: true, mode: 0o700 });
-    }
-
-    // Create shared directory
-    if (!fs.existsSync(this.sharedDir)) {
-      fs.mkdirSync(this.sharedDir, { recursive: true, mode: 0o700 });
-    }
-
-    // Create symlinks ~/.ccs/shared/* → ~/.claude/*
-    for (const dir of this.sharedDirs) {
-      const claudePath = path.join(this.claudeDir, dir);
-      const sharedPath = path.join(this.sharedDir, dir);
-
-      // Create directory in ~/.claude/ if missing
-      if (!fs.existsSync(claudePath)) {
-        fs.mkdirSync(claudePath, { recursive: true, mode: 0o700 });
-      }
-
-      // Check for circular symlink
-      if (this._detectCircularSymlink(claudePath, sharedPath)) {
-        console.log(`[!] Skipping ${dir}: circular symlink detected`);
-        continue;
-      }
-
-      // If already a symlink pointing to correct target, skip
-      if (fs.existsSync(sharedPath)) {
-        try {
-          const stats = fs.lstatSync(sharedPath);
-          if (stats.isSymbolicLink()) {
-            const currentTarget = fs.readlinkSync(sharedPath);
-            const resolvedTarget = path.resolve(path.dirname(sharedPath), currentTarget);
-            if (resolvedTarget === claudePath) {
-              continue; // Already correct
-            }
-          }
-        } catch (err) {
-          // Continue to recreate
-        }
-
-        // Remove existing directory/link
-        fs.rmSync(sharedPath, { recursive: true, force: true });
-      }
-
-      // Create symlink
-      try {
-        fs.symlinkSync(claudePath, sharedPath, 'dir');
-      } catch (err) {
-        // Windows fallback: copy directory
-        if (process.platform === 'win32') {
-          this._copyDirectoryFallback(claudePath, sharedPath);
-          console.log(`[!] Symlink failed for ${dir}, copied instead (enable Developer Mode)`);
-        } else {
-          throw err;
-        }
-      }
-    }
-  }
-
-  /**
-   * Link shared directories to instance
-   * @param {string} instancePath - Path to instance directory
-   */
-  linkSharedDirectories(instancePath) {
-    this.ensureSharedDirectories();
-
-    for (const dir of this.sharedDirs) {
-      const linkPath = path.join(instancePath, dir);
-      const targetPath = path.join(this.sharedDir, dir);
-
-      // Remove existing directory/link
-      if (fs.existsSync(linkPath)) {
-        fs.rmSync(linkPath, { recursive: true, force: true });
-      }
-
-      // Create symlink
-      try {
-        fs.symlinkSync(targetPath, linkPath, 'dir');
-      } catch (err) {
-        // Windows fallback
-        if (process.platform === 'win32') {
-          this._copyDirectoryFallback(targetPath, linkPath);
-          console.log(`[!] Symlink failed for ${dir}, copied instead (enable Developer Mode)`);
-        } else {
-          throw err;
-        }
-      }
-    }
-  }
-
-  /**
-   * Migrate from v3.1.1 (copied data in ~/.ccs/shared/) to v3.2.0 (symlinks to ~/.claude/)
-   * Runs once on upgrade
-   */
-  migrateFromV311() {
-    // Check if migration already done (shared dirs are symlinks)
-    const commandsPath = path.join(this.sharedDir, 'commands');
-    if (fs.existsSync(commandsPath)) {
-      try {
-        if (fs.lstatSync(commandsPath).isSymbolicLink()) {
-          return; // Already migrated
-        }
-      } catch (err) {
-        // Continue with migration
-      }
-    }
-
-    console.log('[i] Migrating from v3.1.1 to v3.2.0...');
-
-    // Ensure ~/.claude/ exists
-    if (!fs.existsSync(this.claudeDir)) {
-      fs.mkdirSync(this.claudeDir, { recursive: true, mode: 0o700 });
-    }
-
-    // Copy user modifications from ~/.ccs/shared/ to ~/.claude/
-    for (const dir of this.sharedDirs) {
-      const sharedPath = path.join(this.sharedDir, dir);
-      const claudePath = path.join(this.claudeDir, dir);
-
-      if (!fs.existsSync(sharedPath)) continue;
-
-      try {
-        const stats = fs.lstatSync(sharedPath);
-        if (!stats.isDirectory()) continue;
-      } catch (err) {
-        continue;
-      }
-
-      // Create claude dir if missing
-      if (!fs.existsSync(claudePath)) {
-        fs.mkdirSync(claudePath, { recursive: true, mode: 0o700 });
-      }
-
-      // Copy files from shared to claude (preserve user modifications)
-      try {
-        const entries = fs.readdirSync(sharedPath, { withFileTypes: true });
-        let copied = 0;
-
-        for (const entry of entries) {
-          const src = path.join(sharedPath, entry.name);
-          const dest = path.join(claudePath, entry.name);
-
-          // Skip if already exists in claude
-          if (fs.existsSync(dest)) continue;
-
-          if (entry.isDirectory()) {
-            fs.cpSync(src, dest, { recursive: true });
-          } else {
-            fs.copyFileSync(src, dest);
-          }
-          copied++;
-        }
-
-        if (copied > 0) {
-          console.log(`[OK] Migrated ${copied} ${dir} to ~/.claude/${dir}`);
-        }
-      } catch (err) {
-        console.log(`[!] Failed to migrate ${dir}: ${err.message}`);
-      }
-    }
-
-    // Now run ensureSharedDirectories to create symlinks
-    this.ensureSharedDirectories();
-
-    // Update all instances to use new symlinks
-    if (fs.existsSync(this.instancesDir)) {
-      try {
-        const instances = fs.readdirSync(this.instancesDir);
-
-        for (const instance of instances) {
-          const instancePath = path.join(this.instancesDir, instance);
-          try {
-            if (fs.statSync(instancePath).isDirectory()) {
-              this.linkSharedDirectories(instancePath);
-            }
-          } catch (err) {
-            console.log(`[!] Failed to update instance ${instance}: ${err.message}`);
-          }
-        }
-      } catch (err) {
-        // No instances to update
-      }
-    }
-
-    console.log('[OK] Migration to v3.2.0 complete');
-  }
-
-  /**
-   * Copy directory as fallback (Windows without Developer Mode)
-   * @param {string} src - Source directory
-   * @param {string} dest - Destination directory
-   * @private
-   */
-  _copyDirectoryFallback(src, dest) {
-    if (!fs.existsSync(src)) {
-      fs.mkdirSync(src, { recursive: true, mode: 0o700 });
-      return;
-    }
-
-    if (!fs.existsSync(dest)) {
-      fs.mkdirSync(dest, { recursive: true, mode: 0o700 });
-    }
-
-    const entries = fs.readdirSync(src, { withFileTypes: true });
-
-    for (const entry of entries) {
-      const srcPath = path.join(src, entry.name);
-      const destPath = path.join(dest, entry.name);
-
-      if (entry.isDirectory()) {
-        this._copyDirectoryFallback(srcPath, destPath);
-      } else {
-        fs.copyFileSync(srcPath, destPath);
-      }
-    }
-  }
-}
-
-module.exports = SharedManager;

package/bin/utils/claude-detector.js

@@ -1,73 +0,0 @@
-'use strict';
-
-const fs = require('fs');
-const { execSync } = require('child_process');
-const { expandPath } = require('./helpers');
-
-// Detect Claude CLI executable
-function detectClaudeCli() {
-  // Priority 1: CCS_CLAUDE_PATH environment variable (if user wants custom path)
-  if (process.env.CCS_CLAUDE_PATH) {
-    const ccsPath = expandPath(process.env.CCS_CLAUDE_PATH);
-    // Basic validation: file exists
-    if (fs.existsSync(ccsPath)) {
-      return ccsPath;
-    }
-    // Invalid CCS_CLAUDE_PATH - show warning and fall back to PATH
-    console.warn('[!] Warning: CCS_CLAUDE_PATH is set but file not found:', ccsPath);
-    console.warn('    Falling back to system PATH lookup...');
-  }
-
-  // Priority 2: Resolve 'claude' from PATH using which/where.exe
-  // This fixes Windows npm installation where spawn() can't resolve bare command names
-  // SECURITY: Commands are hardcoded literals with no user input - safe from injection
-  const isWindows = process.platform === 'win32';
-
-  try {
-    const cmd = isWindows ? 'where.exe claude' : 'which claude';
-    const result = execSync(cmd, {
-      encoding: 'utf8',
-      stdio: ['ignore', 'pipe', 'ignore'],
-      timeout: 5000  // 5 second timeout to prevent hangs
-    }).trim();
-
-    // where.exe may return multiple lines (all matches in PATH order)
-    const matches = result.split('\n').map(p => p.trim()).filter(p => p);
-
-    if (isWindows) {
-      // On Windows, prefer executables with extensions (.exe, .cmd, .bat)
-      // where.exe often returns file without extension first, then the actual .cmd wrapper
-      const withExtension = matches.find(p => /\.(exe|cmd|bat|ps1)$/i.test(p));
-      const claudePath = withExtension || matches[0];
-
-      if (claudePath && fs.existsSync(claudePath)) {
-        return claudePath;
-      }
-    } else {
-      // On Unix, first match is fine
-      const claudePath = matches[0];
-
-      if (claudePath && fs.existsSync(claudePath)) {
-        return claudePath;
-      }
-    }
-  } catch (err) {
-    // Command failed - claude not in PATH
-    // Fall through to return null
-  }
-
-  // Priority 3: Claude not found
-  return null;
-}
-
-// Show Claude not found error
-function showClaudeNotFoundError() {
-  console.error('ERROR: Claude CLI not found in PATH');
-  console.error('Install from: https://docs.claude.com/en/docs/claude-code/installation');
-  process.exit(1);
-}
-
-module.exports = {
-  detectClaudeCli,
-  showClaudeNotFoundError
-};