@kaitranntt/ccs 3.1.1 → 3.3.0

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,155 +155,130 @@ class SharedManager {
   }
 
   /**
-   * Check if migration is needed
-   * @returns {boolean}
-   * @private
+   * Migrate from v3.1.1 (copied data in ~/.ccs/shared/) to v3.2.0 (symlinks to ~/.claude/)
+   * Runs once on upgrade
    */
-  _needsMigration() {
-    // If shared dir doesn't exist, migration needed
-    if (!fs.existsSync(this.sharedDir)) {
-      return true;
-    }
-
-    // Check if ALL shared directories are empty
-    const allEmpty = this.sharedDirs.every(dir => {
-      const dirPath = path.join(this.sharedDir, dir);
-      if (!fs.existsSync(dirPath)) return true;
+  migrateFromV311() {
+    // Check if migration already done (shared dirs are symlinks)
+    const commandsPath = path.join(this.sharedDir, 'commands');
+    if (fs.existsSync(commandsPath)) {
       try {
-        const files = fs.readdirSync(dirPath);
-        return files.length === 0;
+        if (fs.lstatSync(commandsPath).isSymbolicLink()) {
+          return; // Already migrated
+        }
       } catch (err) {
-        return true; // If can't read, assume empty
+        // Continue with migration
       }
-    });
-
-    return allEmpty;
-  }
+    }
 
-  /**
-   * Perform migration from ~/.claude/ to ~/.ccs/shared/
-   * @returns {object} { commands: N, skills: N, agents: N }
-   * @private
-   */
-  _performMigration() {
-    const stats = { commands: 0, skills: 0, agents: 0 };
-    const claudeDir = path.join(this.homeDir, '.claude');
+    console.log('[i] Migrating from v3.1.1 to v3.2.0...');
 
-    if (!fs.existsSync(claudeDir)) {
-      return stats; // No content to migrate
+    // Ensure ~/.claude/ exists
+    if (!fs.existsSync(this.claudeDir)) {
+      fs.mkdirSync(this.claudeDir, { recursive: true, mode: 0o700 });
     }
 
-    // Migrate commands
-    const commandsPath = path.join(claudeDir, 'commands');
-    if (fs.existsSync(commandsPath)) {
-      const result = this._copyDirectory(commandsPath, path.join(this.sharedDir, 'commands'));
-      stats.commands = result.copied;
-    }
+    // 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);
 
-    // Migrate skills
-    const skillsPath = path.join(claudeDir, 'skills');
-    if (fs.existsSync(skillsPath)) {
-      const result = this._copyDirectory(skillsPath, path.join(this.sharedDir, 'skills'));
-      stats.skills = result.copied;
-    }
+      if (!fs.existsSync(sharedPath)) continue;
 
-    // Migrate agents
-    const agentsPath = path.join(claudeDir, 'agents');
-    if (fs.existsSync(agentsPath)) {
-      const result = this._copyDirectory(agentsPath, path.join(this.sharedDir, 'agents'));
-      stats.agents = result.copied;
-    }
+      try {
+        const stats = fs.lstatSync(sharedPath);
+        if (!stats.isDirectory()) continue;
+      } catch (err) {
+        continue;
+      }
 
-    return stats;
-  }
+      // Create claude dir if missing
+      if (!fs.existsSync(claudePath)) {
+        fs.mkdirSync(claudePath, { recursive: true, mode: 0o700 });
+      }
 
-  /**
-   * Migrate existing instances to shared structure
-   * Idempotent: Safe to run multiple times
-   */
-  migrateToSharedStructure() {
-    console.log('[i] Checking for content migration...');
+      // 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++;
+        }
 
-    // Check if migration is needed
-    if (!this._needsMigration()) {
-      console.log('[OK] Migration not needed (shared dirs have content)');
-      return;
+        if (copied > 0) {
+          console.log(`[OK] Migrated ${copied} ${dir} to ~/.claude/${dir}`);
+        }
+      } catch (err) {
+        console.log(`[!] Failed to migrate ${dir}: ${err.message}`);
+      }
     }
 
-    console.log('[i] Migrating ~/.claude/ content to ~/.ccs/shared/...');
-
-    // Create shared directories
+    // Now run ensureSharedDirectories to create symlinks
     this.ensureSharedDirectories();
 
-    // Perform migration
-    const stats = this._performMigration();
-
-    // Show results
-    const total = stats.commands + stats.skills + stats.agents;
-    if (total === 0) {
-      console.log('[OK] No content to migrate (empty ~/.claude/)');
-    } else {
-      const parts = [];
-      if (stats.commands > 0) parts.push(`${stats.commands} commands`);
-      if (stats.skills > 0) parts.push(`${stats.skills} skills`);
-      if (stats.agents > 0) parts.push(`${stats.agents} agents`);
-      console.log(`[OK] Migrated ${parts.join(', ')}`);
-    }
-
-    // Update all instances to use symlinks
+    // Update all instances to use new symlinks
     if (fs.existsSync(this.instancesDir)) {
-      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);
+      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 recursively (SAFE: preserves existing files)
+   * Copy directory as fallback (Windows without Developer Mode)
    * @param {string} src - Source directory
    * @param {string} dest - Destination directory
-   * @returns {object} { copied: N, skipped: N }
    * @private
    */
-  _copyDirectory(src, dest) {
+  _copyDirectoryFallback(src, dest) {
     if (!fs.existsSync(src)) {
-      return { copied: 0, skipped: 0 };
+      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 });
-    let copied = 0;
-    let skipped = 0;
 
     for (const entry of entries) {
       const srcPath = path.join(src, entry.name);
       const destPath = path.join(dest, entry.name);
 
-      // SAFETY: Skip if destination exists (preserve user modifications)
-      if (fs.existsSync(destPath)) {
-        skipped++;
-        continue;
-      }
-
       if (entry.isDirectory()) {
-        const stats = this._copyDirectory(srcPath, destPath);
-        copied += stats.copied;
-        skipped += stats.skipped;
+        this._copyDirectoryFallback(srcPath, destPath);
       } else {
         fs.copyFileSync(srcPath, destPath);
-        copied++;
       }
     }
-
-    return { copied, skipped };
   }
 }
 

package/config/base-glmt.settings.json

@@ -0,0 +1,17 @@
+{
+  "env": {
+    "ANTHROPIC_BASE_URL": "https://api.z.ai/api/coding/paas/v4/chat/completions",
+    "ANTHROPIC_AUTH_TOKEN": "YOUR_GLM_API_KEY_HERE",
+    "ANTHROPIC_MODEL": "glm-4.6",
+    "ANTHROPIC_DEFAULT_OPUS_MODEL": "glm-4.6",
+    "ANTHROPIC_DEFAULT_SONNET_MODEL": "glm-4.6",
+    "ANTHROPIC_DEFAULT_HAIKU_MODEL": "glm-4.6",
+    "ANTHROPIC_TEMPERATURE": "0.2",
+    "ANTHROPIC_MAX_TOKENS": "65536",
+    "MAX_THINKING_TOKENS": "32768",
+    "ENABLE_STREAMING": "true",
+    "ANTHROPIC_SAFE_MODE": "false",
+    "API_TIMEOUT_MS": "3000000"
+  },
+  "alwaysThinkingEnabled": true
+}

package/lib/ccs

@@ -2,7 +2,7 @@
 set -euo pipefail
 
 # Version (updated by scripts/bump-version.sh)
-CCS_VERSION="3.1.1"
+CCS_VERSION="3.3.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"
@@ -51,6 +51,7 @@ show_help() {
   echo -e "${CYAN}Model Switching:${RESET}"
   echo -e "  ${YELLOW}ccs${RESET}                         Use default Claude account"
   echo -e "  ${YELLOW}ccs glm${RESET}                     Switch to GLM 4.6 model"
+  echo -e "  ${YELLOW}ccs glmt${RESET}                    Switch to GLM with thinking mode"
   echo -e "  ${YELLOW}ccs kimi${RESET}                    Switch to Kimi for Coding"
   echo -e "  ${YELLOW}ccs glm${RESET} \"debug this code\"   Use GLM and run command"
   echo ""

package/lib/ccs.ps1

@@ -12,7 +12,7 @@ param(
 $ErrorActionPreference = "Stop"
 
 # Version (updated by scripts/bump-version.sh)
-$CcsVersion = "3.1.1"
+$CcsVersion = "3.3.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"
@@ -107,6 +107,7 @@ function Show-Help {
     Write-ColorLine "Model Switching:" "Cyan"
     Write-ColorLine "  ccs                         Use default Claude account" "Yellow"
     Write-ColorLine "  ccs glm                     Switch to GLM 4.6 model" "Yellow"
+    Write-ColorLine "  ccs glmt                    Switch to GLM with thinking mode" "Yellow"
     Write-ColorLine "  ccs kimi                    Switch to Kimi for Coding" "Yellow"
     Write-ColorLine "  ccs glm 'debug this code'   Use GLM and run command" "Yellow"
     Write-Host ""

package/package.json

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

package/scripts/postinstall.js

@@ -33,6 +33,7 @@ function validateConfiguration() {
   const requiredFiles = [
     { path: path.join(ccsDir, 'config.json'), name: 'config.json' },
     { path: path.join(ccsDir, 'glm.settings.json'), name: 'glm.settings.json' },
+    { path: path.join(ccsDir, 'glmt.settings.json'), name: 'glmt.settings.json' },
     { path: path.join(ccsDir, 'kimi.settings.json'), name: 'kimi.settings.json' }
   ];
 
@@ -89,15 +90,16 @@ function createConfigFiles() {
       }
     }
 
-    // Migrate from ~/.claude/ to ~/.ccs/shared/ (v3.1.1)
+    // 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.migrateToSharedStructure();
+      sharedManager.migrateFromV311();
+      sharedManager.ensureSharedDirectories();
     } catch (err) {
       console.warn('[!] Migration warning:', err.message);
-      console.warn('    You can manually copy files from ~/.claude/ to ~/.ccs/shared/');
+      console.warn('    Migration will retry on next run');
     }
     console.log('');
 
@@ -107,6 +109,7 @@ function createConfigFiles() {
       const config = {
         profiles: {
           glm: '~/.ccs/glm.settings.json',
+          glmt: '~/.ccs/glmt.settings.json',
           kimi: '~/.ccs/kimi.settings.json',
           default: '~/.claude/settings.json'
         }
@@ -119,7 +122,21 @@ function createConfigFiles() {
 
       console.log('[OK] Created config: ~/.ccs/config.json');
     } else {
-      console.log('[OK] Config exists: ~/.ccs/config.json (preserved)');
+      // Update existing config with glmt if missing (migration for v3.x users)
+      const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+      // Ensure profiles object exists
+      if (!config.profiles) {
+        config.profiles = {};
+      }
+      if (!config.profiles.glmt) {
+        config.profiles.glmt = '~/.ccs/glmt.settings.json';
+        const tmpPath = `${configPath}.tmp`;
+        fs.writeFileSync(tmpPath, JSON.stringify(config, null, 2) + '\n', 'utf8');
+        fs.renameSync(tmpPath, configPath);
+        console.log('[OK] Updated config with GLMT profile');
+      } else {
+        console.log('[OK] Config exists: ~/.ccs/config.json (preserved)');
+      }
     }
 
     // Create glm.settings.json if missing
@@ -151,6 +168,94 @@ function createConfigFiles() {
       console.log('[OK] GLM profile exists: ~/.ccs/glm.settings.json (preserved)');
     }
 
+    // Create glmt.settings.json if missing
+    const glmtSettingsPath = path.join(ccsDir, 'glmt.settings.json');
+    if (!fs.existsSync(glmtSettingsPath)) {
+      const glmtSettings = {
+        env: {
+          ANTHROPIC_BASE_URL: 'https://api.z.ai/api/coding/paas/v4/chat/completions',
+          ANTHROPIC_AUTH_TOKEN: 'YOUR_GLM_API_KEY_HERE',
+          ANTHROPIC_MODEL: 'glm-4.6',
+          ANTHROPIC_DEFAULT_OPUS_MODEL: 'glm-4.6',
+          ANTHROPIC_DEFAULT_SONNET_MODEL: 'glm-4.6',
+          ANTHROPIC_DEFAULT_HAIKU_MODEL: 'glm-4.6',
+          ANTHROPIC_TEMPERATURE: '0.2',
+          ANTHROPIC_MAX_TOKENS: '65536',
+          MAX_THINKING_TOKENS: '32768',
+          ENABLE_STREAMING: 'true',
+          ANTHROPIC_SAFE_MODE: 'false',
+          API_TIMEOUT_MS: '3000000'
+        },
+        alwaysThinkingEnabled: true
+      };
+
+      // Atomic write
+      const tmpPath = `${glmtSettingsPath}.tmp`;
+      fs.writeFileSync(tmpPath, JSON.stringify(glmtSettings, null, 2) + '\n', 'utf8');
+      fs.renameSync(tmpPath, glmtSettingsPath);
+
+      console.log('[OK] Created GLMT profile: ~/.ccs/glmt.settings.json');
+      console.log('');
+      console.log('  [!] Configure GLMT API key:');
+      console.log('      1. Get key from: https://api.z.ai');
+      console.log('      2. Edit: ~/.ccs/glmt.settings.json');
+      console.log('      3. Replace: YOUR_GLM_API_KEY_HERE');
+      console.log('      Note: GLMT enables GLM thinking mode (reasoning)');
+      console.log('      Defaults: Temperature 0.2, thinking enabled, 50min timeout');
+    } else {
+      console.log('[OK] GLMT profile exists: ~/.ccs/glmt.settings.json (preserved)');
+    }
+
+    // Migrate existing GLMT configs to include new defaults (v3.3.0)
+    if (fs.existsSync(glmtSettingsPath)) {
+      try {
+        const existing = JSON.parse(fs.readFileSync(glmtSettingsPath, 'utf8'));
+        let updated = false;
+
+        // Ensure env object exists
+        if (!existing.env) {
+          existing.env = {};
+          updated = true;
+        }
+
+        // Add missing env vars (preserve existing values)
+        const envDefaults = {
+          ANTHROPIC_TEMPERATURE: '0.2',
+          ANTHROPIC_MAX_TOKENS: '65536',
+          MAX_THINKING_TOKENS: '32768',
+          ENABLE_STREAMING: 'true',
+          ANTHROPIC_SAFE_MODE: 'false',
+          API_TIMEOUT_MS: '3000000'
+        };
+
+        for (const [key, value] of Object.entries(envDefaults)) {
+          if (existing.env[key] === undefined) {
+            existing.env[key] = value;
+            updated = true;
+          }
+        }
+
+        // Add alwaysThinkingEnabled if missing
+        if (existing.alwaysThinkingEnabled === undefined) {
+          existing.alwaysThinkingEnabled = true;
+          updated = true;
+        }
+
+        // Write back if updated
+        if (updated) {
+          const tmpPath = `${glmtSettingsPath}.tmp`;
+          fs.writeFileSync(tmpPath, JSON.stringify(existing, null, 2) + '\n', 'utf8');
+          fs.renameSync(tmpPath, glmtSettingsPath);
+          console.log('[OK] Migrated GLMT config with new defaults (v3.3.0)');
+          console.log('     Added: temperature, max_tokens, thinking settings, alwaysThinkingEnabled');
+        }
+      } catch (err) {
+        console.warn('[!] GLMT config migration failed:', err.message);
+        console.warn('    Existing config preserved, may be missing new defaults');
+        console.warn('    You can manually add fields or delete file to regenerate');
+      }
+    }
+
     // Create kimi.settings.json if missing
     const kimiSettingsPath = path.join(ccsDir, 'kimi.settings.json');
     if (!fs.existsSync(kimiSettingsPath)) {