@kaitranntt/ccs 3.5.0 → 4.1.1

package/bin/delegation/settings-parser.js

@@ -0,0 +1,109 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Parses Claude Code settings for tool restrictions
+ */
+class SettingsParser {
+  /**
+   * Parse default permission mode from project settings
+   * @param {string} projectDir - Project directory (usually cwd)
+   * @returns {string} Default permission mode (e.g., 'acceptEdits', 'bypassPermissions', 'plan', 'default')
+   */
+  static parseDefaultPermissionMode(projectDir) {
+    const settings = this._loadSettings(projectDir);
+    const permissions = settings.permissions || {};
+
+    // Priority: local > shared > fallback to 'acceptEdits'
+    const defaultMode = permissions.defaultMode || 'acceptEdits';
+
+    if (process.env.CCS_DEBUG) {
+      console.error(`[i] Permission mode from settings: ${defaultMode}`);
+    }
+
+    return defaultMode;
+  }
+
+  /**
+   * Parse project settings for tool restrictions
+   * @param {string} projectDir - Project directory (usually cwd)
+   * @returns {Object} { allowedTools: string[], disallowedTools: string[] }
+   */
+  static parseToolRestrictions(projectDir) {
+    const settings = this._loadSettings(projectDir);
+    const permissions = settings.permissions || {};
+
+    const allowed = permissions.allow || [];
+    const denied = permissions.deny || [];
+
+    if (process.env.CCS_DEBUG) {
+      console.error(`[i] Tool restrictions: ${allowed.length} allowed, ${denied.length} denied`);
+    }
+
+    return {
+      allowedTools: allowed,
+      disallowedTools: denied
+    };
+  }
+
+  /**
+   * Load and merge settings files (local overrides shared)
+   * @param {string} projectDir - Project directory
+   * @returns {Object} Merged settings
+   * @private
+   */
+  static _loadSettings(projectDir) {
+    const claudeDir = path.join(projectDir, '.claude');
+    const sharedPath = path.join(claudeDir, 'settings.json');
+    const localPath = path.join(claudeDir, 'settings.local.json');
+
+    // Load shared settings
+    const shared = this._readJsonSafe(sharedPath) || {};
+
+    // Load local settings (overrides shared)
+    const local = this._readJsonSafe(localPath) || {};
+
+    // Merge permissions (local overrides shared)
+    return {
+      permissions: {
+        allow: [
+          ...(shared.permissions?.allow || []),
+          ...(local.permissions?.allow || [])
+        ],
+        deny: [
+          ...(shared.permissions?.deny || []),
+          ...(local.permissions?.deny || [])
+        ],
+        // Local defaultMode takes priority over shared
+        defaultMode: local.permissions?.defaultMode || shared.permissions?.defaultMode || null
+      }
+    };
+  }
+
+  /**
+   * Read JSON file safely (no throw)
+   * @param {string} filePath - Path to JSON file
+   * @returns {Object|null} Parsed JSON or null
+   * @private
+   */
+  static _readJsonSafe(filePath) {
+    try {
+      if (!fs.existsSync(filePath)) {
+        return null;
+      }
+
+      const content = fs.readFileSync(filePath, 'utf8');
+      return JSON.parse(content);
+    } catch (error) {
+      if (process.env.CCS_DEBUG) {
+        console.warn(`[!] Failed to read settings: ${filePath}: ${error.message}`);
+      }
+      return null;
+    }
+  }
+}
+
+module.exports = { SettingsParser };

package/bin/management/doctor.js

@@ -61,7 +61,9 @@ class Doctor {
     this.checkClaudeSettings();
     this.checkProfiles();
     this.checkInstances();
+    this.checkDelegation();
     this.checkPermissions();
+    this.checkCcsSymlinks();
 
     this.showReport();
     return this.results;
@@ -269,7 +271,64 @@ class Doctor {
   }
 
   /**
-   * Check 7: File permissions
+   * Check 7: Delegation system
+   */
+  checkDelegation() {
+    process.stdout.write('[?] Checking delegation... ');
+
+    // Check if delegation-rules.json exists
+    const delegationRulesPath = path.join(this.ccsDir, 'delegation-rules.json');
+    const hasDelegationRules = fs.existsSync(delegationRulesPath);
+
+    // Check if delegation commands exist
+    const sharedCommandsDir = path.join(this.ccsDir, 'shared', 'commands', 'ccs');
+    const hasGlmCommand = fs.existsSync(path.join(sharedCommandsDir, 'glm.md'));
+    const hasKimiCommand = fs.existsSync(path.join(sharedCommandsDir, 'kimi.md'));
+    const hasCreateCommand = fs.existsSync(path.join(sharedCommandsDir, 'create.md'));
+
+    if (!hasGlmCommand || !hasKimiCommand || !hasCreateCommand) {
+      console.log(colored('[!]', 'yellow'), '(not installed)');
+      this.results.addCheck(
+        'Delegation',
+        'warning',
+        'Delegation commands not found',
+        'Install with: npm install -g @kaitranntt/ccs --force'
+      );
+      return;
+    }
+
+    // Check profile validity using DelegationValidator
+    const { DelegationValidator } = require('../utils/delegation-validator');
+    const readyProfiles = [];
+
+    for (const profile of ['glm', 'kimi']) {
+      const validation = DelegationValidator.validate(profile);
+      if (validation.valid) {
+        readyProfiles.push(profile);
+      }
+    }
+
+    if (readyProfiles.length === 0) {
+      console.log(colored('[!]', 'yellow'), '(no profiles ready)');
+      this.results.addCheck(
+        'Delegation',
+        'warning',
+        'Delegation installed but no profiles configured',
+        'Configure profiles with valid API keys (not placeholders)'
+      );
+      return;
+    }
+
+    console.log(colored('[OK]', 'green'), `(${readyProfiles.join(', ')} ready)`);
+    this.results.addCheck(
+      'Delegation',
+      'success',
+      `${readyProfiles.length} profile(s) ready: ${readyProfiles.join(', ')}`
+    );
+  }
+
+  /**
+   * Check 8: File permissions
    */
   checkPermissions() {
     process.stdout.write('[?] Checking permissions... ');
@@ -292,6 +351,40 @@ class Doctor {
     }
   }
 
+  /**
+   * Check 9: CCS symlinks to ~/.claude/
+   */
+  checkCcsSymlinks() {
+    process.stdout.write('[?] Checking CCS symlinks... ');
+
+    try {
+      const ClaudeSymlinkManager = require('../utils/claude-symlink-manager');
+      const manager = new ClaudeSymlinkManager();
+      const health = manager.checkHealth();
+
+      if (health.healthy) {
+        console.log(colored('[OK]', 'green'));
+        this.results.addCheck('CCS Symlinks', 'success', 'All CCS items properly symlinked');
+      } else {
+        console.log(colored('[!]', 'yellow'));
+        this.results.addCheck(
+          'CCS Symlinks',
+          'warning',
+          health.issues.join(', '),
+          'Run: ccs update'
+        );
+      }
+    } catch (e) {
+      console.log(colored('[!]', 'yellow'));
+      this.results.addCheck(
+        'CCS Symlinks',
+        'warning',
+        'Could not check CCS symlinks: ' + e.message,
+        'Run: ccs update'
+      );
+    }
+  }
+
   /**
    * Show health check report
    */

package/bin/utils/claude-dir-installer.js

@@ -0,0 +1,102 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+/**
+ * ClaudeDirInstaller - Manages copying .claude/ directory from package to ~/.ccs/.claude/
+ * v4.1.1: Fix for npm install not copying .claude/ directory
+ */
+class ClaudeDirInstaller {
+  constructor() {
+    this.homeDir = os.homedir();
+    this.ccsClaudeDir = path.join(this.homeDir, '.ccs', '.claude');
+  }
+
+  /**
+   * Copy .claude/ directory from package to ~/.ccs/.claude/
+   * @param {string} packageDir - Package installation directory (default: auto-detect)
+   */
+  install(packageDir) {
+    try {
+      // Auto-detect package directory if not provided
+      if (!packageDir) {
+        // Try to find package root by going up from this file
+        packageDir = path.join(__dirname, '..', '..');
+      }
+
+      const packageClaudeDir = path.join(packageDir, '.claude');
+
+      if (!fs.existsSync(packageClaudeDir)) {
+        console.log('[!] Package .claude/ directory not found');
+        console.log(`    Searched in: ${packageClaudeDir}`);
+        console.log('    This may be a development installation');
+        return false;
+      }
+
+      console.log('[i] Installing CCS .claude/ items...');
+
+      // Remove old version before copying new one
+      if (fs.existsSync(this.ccsClaudeDir)) {
+        fs.rmSync(this.ccsClaudeDir, { recursive: true, force: true });
+      }
+
+      // Use fs.cpSync for recursive copy (Node.js 16.7.0+)
+      // Fallback to manual copy for older Node.js versions
+      if (fs.cpSync) {
+        fs.cpSync(packageClaudeDir, this.ccsClaudeDir, { recursive: true });
+      } else {
+        // Fallback for Node.js < 16.7.0
+        this._copyDirRecursive(packageClaudeDir, this.ccsClaudeDir);
+      }
+
+      console.log('[OK] Copied .claude/ items to ~/.ccs/.claude/');
+      return true;
+    } catch (err) {
+      console.warn('[!] Failed to copy .claude/ directory:', err.message);
+      console.warn('    CCS items may not be available');
+      return false;
+    }
+  }
+
+  /**
+   * Recursively copy directory (fallback for Node.js < 16.7.0)
+   * @param {string} src - Source directory
+   * @param {string} dest - Destination directory
+   * @private
+   */
+  _copyDirRecursive(src, dest) {
+    // Create destination directory
+    if (!fs.existsSync(dest)) {
+      fs.mkdirSync(dest, { recursive: true });
+    }
+
+    // Read source directory
+    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()) {
+        // Recursively copy subdirectory
+        this._copyDirRecursive(srcPath, destPath);
+      } else {
+        // Copy file
+        fs.copyFileSync(srcPath, destPath);
+      }
+    }
+  }
+
+  /**
+   * Check if ~/.ccs/.claude/ exists and is valid
+   * @returns {boolean} True if directory exists
+   */
+  isInstalled() {
+    return fs.existsSync(this.ccsClaudeDir);
+  }
+}
+
+module.exports = ClaudeDirInstaller;

package/bin/utils/claude-symlink-manager.js

@@ -0,0 +1,238 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+/**
+ * ClaudeSymlinkManager - Manages selective symlinks from ~/.ccs/.claude/ to ~/.claude/
+ * v4.1.0: Selective symlinking for CCS items
+ *
+ * Purpose: Ship CCS items (.claude/) with package and symlink them to user's ~/.claude/
+ * Architecture:
+ *   - ~/.ccs/.claude/* (source, ships with CCS)
+ *   - ~/.claude/* (target, gets selective symlinks)
+ *   - ~/.ccs/shared/ (UNTOUCHED, existing profile mechanism)
+ *
+ * Symlink Chain:
+ *   profile -> ~/.ccs/shared/ -> ~/.claude/ (which has symlinks to ~/.ccs/.claude/)
+ */
+class ClaudeSymlinkManager {
+  constructor() {
+    this.homeDir = os.homedir();
+    this.ccsClaudeDir = path.join(this.homeDir, '.ccs', '.claude');
+    this.userClaudeDir = path.join(this.homeDir, '.claude');
+
+    // CCS items to symlink (selective, item-level)
+    this.ccsItems = [
+      { source: 'commands/ccs', target: 'commands/ccs', type: 'directory' },
+      { source: 'skills/ccs-delegation', target: 'skills/ccs-delegation', type: 'directory' },
+      { source: 'agents/ccs-delegator.md', target: 'agents/ccs-delegator.md', type: 'file' }
+    ];
+  }
+
+  /**
+   * Install CCS items to user's ~/.claude/ via selective symlinks
+   * Safe: backs up existing files before creating symlinks
+   */
+  install() {
+    // Ensure ~/.ccs/.claude/ exists (should be shipped with package)
+    if (!fs.existsSync(this.ccsClaudeDir)) {
+      console.log('[!] CCS .claude/ directory not found, skipping symlink installation');
+      return;
+    }
+
+    // Create ~/.claude/ if missing
+    if (!fs.existsSync(this.userClaudeDir)) {
+      console.log('[i] Creating ~/.claude/ directory');
+      fs.mkdirSync(this.userClaudeDir, { recursive: true, mode: 0o700 });
+    }
+
+    // Install each CCS item
+    for (const item of this.ccsItems) {
+      this._installItem(item);
+    }
+
+    console.log('[OK] CCS items installed to ~/.claude/');
+  }
+
+  /**
+   * Install a single CCS item with conflict handling
+   * @param {Object} item - Item descriptor {source, target, type}
+   * @private
+   */
+  _installItem(item) {
+    const sourcePath = path.join(this.ccsClaudeDir, item.source);
+    const targetPath = path.join(this.userClaudeDir, item.target);
+    const targetDir = path.dirname(targetPath);
+
+    // Ensure source exists
+    if (!fs.existsSync(sourcePath)) {
+      console.log(`[!] Source not found: ${item.source}, skipping`);
+      return;
+    }
+
+    // Create target parent directory if needed
+    if (!fs.existsSync(targetDir)) {
+      fs.mkdirSync(targetDir, { recursive: true, mode: 0o700 });
+    }
+
+    // Check if target already exists
+    if (fs.existsSync(targetPath)) {
+      // Check if it's already the correct symlink
+      if (this._isOurSymlink(targetPath, sourcePath)) {
+        return; // Already correct, skip
+      }
+
+      // Backup existing file/directory
+      this._backupItem(targetPath);
+    }
+
+    // Create symlink
+    try {
+      const symlinkType = item.type === 'directory' ? 'dir' : 'file';
+      fs.symlinkSync(sourcePath, targetPath, symlinkType);
+      console.log(`[OK] Symlinked ${item.target}`);
+    } catch (err) {
+      // Windows fallback: stub for now, full implementation in v4.2
+      if (process.platform === 'win32') {
+        console.log(`[!] Symlink failed for ${item.target} (Windows fallback deferred to v4.2)`);
+        console.log(`[i] Enable Developer Mode or wait for next update`);
+      } else {
+        console.log(`[!] Failed to symlink ${item.target}: ${err.message}`);
+      }
+    }
+  }
+
+  /**
+   * Check if target is already the correct symlink pointing to source
+   * @param {string} targetPath - Target path to check
+   * @param {string} expectedSource - Expected source path
+   * @returns {boolean} True if target is correct symlink
+   * @private
+   */
+  _isOurSymlink(targetPath, expectedSource) {
+    try {
+      const stats = fs.lstatSync(targetPath);
+
+      if (!stats.isSymbolicLink()) {
+        return false;
+      }
+
+      const actualTarget = fs.readlinkSync(targetPath);
+      const resolvedTarget = path.resolve(path.dirname(targetPath), actualTarget);
+
+      return resolvedTarget === expectedSource;
+    } catch (err) {
+      return false;
+    }
+  }
+
+  /**
+   * Backup existing item before replacing with symlink
+   * @param {string} itemPath - Path to item to backup
+   * @private
+   */
+  _backupItem(itemPath) {
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-').split('T')[0];
+    const backupPath = `${itemPath}.backup-${timestamp}`;
+
+    try {
+      // If backup already exists, use counter
+      let finalBackupPath = backupPath;
+      let counter = 1;
+      while (fs.existsSync(finalBackupPath)) {
+        finalBackupPath = `${backupPath}-${counter}`;
+        counter++;
+      }
+
+      fs.renameSync(itemPath, finalBackupPath);
+      console.log(`[i] Backed up existing item to ${path.basename(finalBackupPath)}`);
+    } catch (err) {
+      console.log(`[!] Failed to backup ${itemPath}: ${err.message}`);
+      throw err; // Don't proceed if backup fails
+    }
+  }
+
+  /**
+   * Uninstall CCS items from ~/.claude/ (remove symlinks only)
+   * Safe: only removes items that are CCS symlinks
+   */
+  uninstall() {
+    let removed = 0;
+
+    for (const item of this.ccsItems) {
+      const targetPath = path.join(this.userClaudeDir, item.target);
+      const sourcePath = path.join(this.ccsClaudeDir, item.source);
+
+      // Only remove if it's our symlink
+      if (fs.existsSync(targetPath) && this._isOurSymlink(targetPath, sourcePath)) {
+        try {
+          fs.unlinkSync(targetPath);
+          console.log(`[OK] Removed ${item.target}`);
+          removed++;
+        } catch (err) {
+          console.log(`[!] Failed to remove ${item.target}: ${err.message}`);
+        }
+      }
+    }
+
+    if (removed > 0) {
+      console.log(`[OK] Removed ${removed} CCS items from ~/.claude/`);
+    } else {
+      console.log('[i] No CCS items to remove');
+    }
+  }
+
+  /**
+   * Check symlink health and report issues
+   * Used by 'ccs doctor' command
+   * @returns {Object} Health check results {healthy: boolean, issues: string[]}
+   */
+  checkHealth() {
+    const issues = [];
+    let healthy = true;
+
+    // Check if ~/.ccs/.claude/ exists
+    if (!fs.existsSync(this.ccsClaudeDir)) {
+      issues.push('CCS .claude/ directory missing (reinstall CCS)');
+      healthy = false;
+      return { healthy, issues };
+    }
+
+    // Check each item
+    for (const item of this.ccsItems) {
+      const sourcePath = path.join(this.ccsClaudeDir, item.source);
+      const targetPath = path.join(this.userClaudeDir, item.target);
+
+      // Check source exists
+      if (!fs.existsSync(sourcePath)) {
+        issues.push(`Source missing: ${item.source}`);
+        healthy = false;
+        continue;
+      }
+
+      // Check target
+      if (!fs.existsSync(targetPath)) {
+        issues.push(`Not installed: ${item.target} (run 'ccs update' to install)`);
+        healthy = false;
+      } else if (!this._isOurSymlink(targetPath, sourcePath)) {
+        issues.push(`Not a CCS symlink: ${item.target} (run 'ccs update' to fix)`);
+        healthy = false;
+      }
+    }
+
+    return { healthy, issues };
+  }
+
+  /**
+   * Re-install symlinks (used by 'ccs update' command)
+   * Same as install() but with explicit re-installation message
+   */
+  update() {
+    console.log('[i] Updating CCS items in ~/.claude/...');
+    this.install();
+  }
+}
+
+module.exports = ClaudeSymlinkManager;