@kaitranntt/ccs 3.1.0 → 3.2.0

package/VERSION

@@ -1 +1 @@
-3.1.0
+3.2.0

package/bin/ccs.js

@@ -262,11 +262,6 @@ async function main() {
     recovery.showRecoveryHints();
   }
 
-  // Run migration to shared structure (Phase 1: idempotent)
-  const SharedManager = require('./shared-manager');
-  const sharedManager = new SharedManager();
-  sharedManager.migrateToSharedStructure();
-
   // Detect profile
   const { profile, remainingArgs } = detectProfile(args);
 

package/bin/shared-manager.js

@@ -6,33 +6,119 @@ const os = require('os');
 
 /**
  * SharedManager - Manages symlinked shared directories for CCS
- * Phase 1: Shared Global Data via Symlinks
+ * v3.2.0: Symlink-based architecture
  *
- * Purpose: Eliminates duplication of commands/skills across profile instances
- * by symlinking to a single ~/.ccs/shared/ directory.
+ * 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'];
   }
 
   /**
-   * Ensure shared directories exist
+   * 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 shared subdirectories
+    // Create symlinks ~/.ccs/shared/* → ~/.claude/*
     for (const dir of this.sharedDirs) {
-      const dirPath = path.join(this.sharedDir, dir);
-      if (!fs.existsSync(dirPath)) {
-        fs.mkdirSync(dirPath, { recursive: true, mode: 0o700 });
+      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;
+        }
       }
     }
   }
@@ -57,9 +143,9 @@ class SharedManager {
       try {
         fs.symlinkSync(targetPath, linkPath, 'dir');
       } catch (err) {
-        // Windows fallback: copy directory if symlink fails
+        // Windows fallback
         if (process.platform === 'win32') {
-          this._copyDirectory(targetPath, linkPath);
+          this._copyDirectoryFallback(targetPath, linkPath);
           console.log(`[!] Symlink failed for ${dir}, copied instead (enable Developer Mode)`);
         } else {
           throw err;
@@ -69,81 +155,116 @@ class SharedManager {
   }
 
   /**
-   * Migrate existing instances to shared structure
-   * Idempotent: Safe to run multiple times
+   * Migrate from v3.1.1 (copied data in ~/.ccs/shared/) to v3.2.0 (symlinks to ~/.claude/)
+   * Runs once on upgrade
    */
-  migrateToSharedStructure() {
-    // Check if migration is needed (shared dirs exist but are empty)
-    const needsMigration = !fs.existsSync(this.sharedDir) ||
-      this.sharedDirs.every(dir => {
-        const dirPath = path.join(this.sharedDir, dir);
-        if (!fs.existsSync(dirPath)) return true;
-        try {
-          const files = fs.readdirSync(dirPath);
-          return files.length === 0; // Empty directory needs migration
-        } catch (err) {
-          return true; // If we can't read it, assume it needs migration
+  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
+      }
+    }
 
-    if (!needsMigration) {
-      return; // Already migrated with content
+    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 });
     }
 
-    // Create shared directories
-    this.ensureSharedDirectories();
+    // 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);
 
-    // Copy from ~/.claude/ (actual Claude CLI directory)
-    const claudeDir = path.join(this.homeDir, '.claude');
+      if (!fs.existsSync(sharedPath)) continue;
 
-    if (fs.existsSync(claudeDir)) {
-      // Copy commands to shared (if exists)
-      const commandsPath = path.join(claudeDir, 'commands');
-      if (fs.existsSync(commandsPath)) {
-        this._copyDirectory(commandsPath, path.join(this.sharedDir, 'commands'));
+      try {
+        const stats = fs.lstatSync(sharedPath);
+        if (!stats.isDirectory()) continue;
+      } catch (err) {
+        continue;
       }
 
-      // Copy skills to shared (if exists)
-      const skillsPath = path.join(claudeDir, 'skills');
-      if (fs.existsSync(skillsPath)) {
-        this._copyDirectory(skillsPath, path.join(this.sharedDir, 'skills'));
+      // Create claude dir if missing
+      if (!fs.existsSync(claudePath)) {
+        fs.mkdirSync(claudePath, { recursive: true, mode: 0o700 });
       }
 
-      // Copy agents to shared (if exists)
-      const agentsPath = path.join(claudeDir, 'agents');
-      if (fs.existsSync(agentsPath)) {
-        this._copyDirectory(agentsPath, path.join(this.sharedDir, 'agents'));
+      // 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}`);
       }
     }
 
-    // Update all instances to use symlinks
+    // Now run ensureSharedDirectories to create symlinks
+    this.ensureSharedDirectories();
+
+    // Update all instances to use new symlinks
     if (fs.existsSync(this.instancesDir)) {
-      const instances = fs.readdirSync(this.instancesDir);
+      try {
+        const instances = fs.readdirSync(this.instancesDir);
 
-      for (const instance of instances) {
-        const instancePath = path.join(this.instancesDir, instance);
-        if (fs.statSync(instancePath).isDirectory()) {
-          this.linkSharedDirectories(instancePath);
+        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] Migrated to shared structure');
+    console.log('[OK] Migration to v3.2.0 complete');
   }
 
   /**
-   * Copy directory recursively (fallback for Windows)
+   * Copy directory as fallback (Windows without Developer Mode)
    * @param {string} src - Source directory
    * @param {string} dest - Destination directory
    * @private
    */
-  _copyDirectory(src, dest) {
+  _copyDirectoryFallback(src, dest) {
     if (!fs.existsSync(src)) {
+      fs.mkdirSync(src, { recursive: true, mode: 0o700 });
       return;
     }
 
     if (!fs.existsSync(dest)) {
-      fs.mkdirSync(dest, { recursive: true });
+      fs.mkdirSync(dest, { recursive: true, mode: 0o700 });
     }
 
     const entries = fs.readdirSync(src, { withFileTypes: true });
@@ -153,7 +274,7 @@ class SharedManager {
       const destPath = path.join(dest, entry.name);
 
       if (entry.isDirectory()) {
-        this._copyDirectory(srcPath, destPath);
+        this._copyDirectoryFallback(srcPath, destPath);
       } else {
         fs.copyFileSync(srcPath, destPath);
       }

package/lib/ccs

@@ -2,7 +2,7 @@
 set -euo pipefail
 
 # Version (updated by scripts/bump-version.sh)
-CCS_VERSION="3.1.0"
+CCS_VERSION="3.2.0"
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 readonly CONFIG_FILE="${CCS_CONFIG:-$HOME/.ccs/config.json}"
 readonly PROFILES_JSON="$HOME/.ccs/profiles.json"
@@ -1010,9 +1010,6 @@ auto_recover || {
   exit 1
 }
 
-# Run migration to shared structure (Phase 1: idempotent)
-migrate_to_shared_structure
-
 # Smart profile detection: if first arg starts with '-', it's a flag not a profile
 if [[ $# -eq 0 ]] || [[ "${1}" =~ ^- ]]; then
   # No args or first arg is a flag → use default profile

package/lib/ccs.ps1

@@ -12,7 +12,7 @@ param(
 $ErrorActionPreference = "Stop"
 
 # Version (updated by scripts/bump-version.sh)
-$CcsVersion = "3.1.0"
+$CcsVersion = "3.2.0"
 $ScriptDir = Split-Path -Parent $MyInvocation.MyCommand.Path
 $ConfigFile = if ($env:CCS_CONFIG) { $env:CCS_CONFIG } else { "$env:USERPROFILE\.ccs\config.json" }
 $ProfilesJson = "$env:USERPROFILE\.ccs\profiles.json"
@@ -1000,9 +1000,6 @@ if (-not (Invoke-AutoRecovery)) {
     exit 1
 }
 
-# Run migration to shared structure (Phase 1: idempotent)
-Migrate-SharedStructure
-
 # Smart profile detection: if first arg starts with '-', it's a flag not a profile
 if ($RemainingArgs.Count -eq 0 -or $RemainingArgs[0] -match '^-') {
     # No args or first arg is a flag → use default profile

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kaitranntt/ccs",
-  "version": "3.1.0",
+  "version": "3.2.0",
   "description": "Claude Code Switch - Instant profile switching between Claude Sonnet 4.5 and GLM 4.6",
   "keywords": [
     "cli",

package/scripts/postinstall.js

@@ -89,6 +89,19 @@ function createConfigFiles() {
       }
     }
 
+    // Migrate from v3.1.1 to v3.2.0 (symlink architecture)
+    console.log('');
+    try {
+      const SharedManager = require('../bin/shared-manager');
+      const sharedManager = new SharedManager();
+      sharedManager.migrateFromV311();
+      sharedManager.ensureSharedDirectories();
+    } catch (err) {
+      console.warn('[!] Migration warning:', err.message);
+      console.warn('    Migration will retry on next run');
+    }
+    console.log('');
+
     // Create config.json if missing
     const configPath = path.join(ccsDir, 'config.json');
     if (!fs.existsSync(configPath)) {