@kaitranntt/ccs 2.5.1 → 3.0.0

package/README.md

@@ -156,33 +156,45 @@ One command. Zero downtime. No file editing. Right model, right task.
 
 ---
 
-## 🏗️ Architecture Overview
+## 🏗️ Architecture Overview (v3.0 Simplified)
+
+**v3.0 Login-Per-Profile Model**: Each profile is an isolated Claude instance where users login directly. No credential copying or vault encryption.
 
 ```mermaid
 graph LR
     subgraph "User Command"
-        CMD[ccs glm]
+        CMD[ccs <profile>]
+    end
+
+    subgraph "Profile Detection"
+        DETECT[ProfileDetector]
+        SETTINGS[Settings-based: glm, kimi]
+        ACCOUNT[Account-based: work, personal]
     end
 
     subgraph "CCS Processing"
-        CONFIG[Read ~/.ccs/config.json]
-        LOOKUP[Lookup profile → settings file]
-        VALIDATE[Validate file exists]
+        CONFIG[Read config.json/profiles.json]
+        INSTANCE[InstanceManager: lazy directory init]
     end
 
-    subgraph "Claude CLI"
-        EXEC[claude --settings file_path]
+    subgraph "Claude CLI Execution"
+        SETTINGS_EXEC[claude --settings <path>]
+        INSTANCE_EXEC[CLAUDE_CONFIG_DIR=<instance> claude]
     end
 
     subgraph "API Response"
-        API[Claude Sub or GLM API]
+        API[Claude/GLM/Kimi API]
     end
 
-    CMD --> CONFIG
-    CONFIG --> LOOKUP
-    LOOKUP --> VALIDATE
-    VALIDATE --> EXEC
-    EXEC --> API
+    CMD --> DETECT
+    DETECT --> SETTINGS
+    DETECT --> ACCOUNT
+    SETTINGS --> CONFIG
+    ACCOUNT --> INSTANCE
+    SETTINGS --> SETTINGS_EXEC
+    ACCOUNT --> INSTANCE_EXEC
+    SETTINGS_EXEC --> API
+    INSTANCE_EXEC --> API
 ```
 
 ---
@@ -194,6 +206,13 @@ graph LR
 - **Smart Detection**: Automatically uses right model for each task
 - **Persistent**: Switch stays active until changed again
 
+### Concurrent Sessions (All Platforms)
+- **Multiple Profiles Simultaneously**: Run `ccs work` and `ccs personal` in different terminals concurrently
+- **Isolated Instances**: Each profile gets own config directory (`~/.ccs/instances/<profile>/`)
+- **Independent Sessions**: Separate login, chat sessions, todos, logs per profile
+- **Platform Parity**: Works identically on macOS, Linux, and Windows via `CLAUDE_CONFIG_DIR`
+- **Backward Compatible**: Existing settings profiles (glm, kimi) work unchanged
+
 ### Zero Workflow Interruption
 - **No Downtime**: Switching happens instantly between commands
 - **Context Preservation**: Your workflow remains uninterrupted
@@ -204,6 +223,7 @@ graph LR
 
 ## 💻 Usage Examples
 
+### Basic Profile Switching
 ```bash
 ccs              # Use Claude subscription (default)
 ccs glm          # Use GLM fallback
@@ -211,6 +231,22 @@ ccs kimi         # Use Kimi for Coding
 ccs --version    # Show CCS version and install location
 ```
 
+### Concurrent Sessions (Multi-Account)
+```bash
+# First time: Create profile and login
+ccs auth create work        # Opens Claude, prompts for login
+ccs auth create personal    # Opens Claude, prompts for login
+
+# Terminal 1 - Work account
+ccs work "implement feature"
+
+# Terminal 2 - Personal account (concurrent)
+ccs personal "review code"
+
+# Both run simultaneously with isolated logins/sessions
+# Works on all platforms: macOS, Linux, Windows
+```
+
 ---
 
 ### 🗑️ Official Uninstall

package/VERSION

@@ -1 +1 @@
-2.5.1
+3.0.0

package/bin/auth-commands.js

@@ -0,0 +1,405 @@
+'use strict';
+
+const { spawn } = require('child_process');
+const ProfileRegistry = require('./profile-registry');
+const InstanceManager = require('./instance-manager');
+const { colored } = require('./helpers');
+const { detectClaudeCli } = require('./claude-detector');
+
+/**
+ * Auth Commands (Simplified)
+ *
+ * CLI interface for CCS multi-account management.
+ * Commands: create, list, show, remove, default
+ *
+ * Login-per-profile model: Each profile is an isolated Claude instance.
+ * Users login directly in each instance (no credential copying).
+ */
+class AuthCommands {
+  constructor() {
+    this.registry = new ProfileRegistry();
+    this.instanceMgr = new InstanceManager();
+  }
+
+  /**
+   * Show help for auth commands
+   */
+  showHelp() {
+    console.log(colored('CCS Account Management', 'bold'));
+    console.log('');
+    console.log(colored('Usage:', 'cyan'));
+    console.log(`  ${colored('ccs auth', 'yellow')} <command> [options]`);
+    console.log('');
+    console.log(colored('Commands:', 'cyan'));
+    console.log(`  ${colored('create <profile>', 'yellow')}        Create new profile and login`);
+    console.log(`  ${colored('list', 'yellow')}                   List all saved profiles`);
+    console.log(`  ${colored('show <profile>', 'yellow')}         Show profile details`);
+    console.log(`  ${colored('remove <profile>', 'yellow')}       Remove saved profile`);
+    console.log(`  ${colored('default <profile>', 'yellow')}      Set default profile`);
+    console.log('');
+    console.log(colored('Examples:', 'cyan'));
+    console.log(`  ${colored('ccs auth create work', 'yellow')}                     # Create & login to work profile`);
+    console.log(`  ${colored('ccs auth list', 'yellow')}                            # List all profiles`);
+    console.log(`  ${colored('ccs work "review code"', 'yellow')}                   # Use work profile`);
+    console.log('');
+    console.log(colored('Options:', 'cyan'));
+    console.log(`  ${colored('--force', 'yellow')}                   Allow overwriting existing profile`);
+    console.log('');
+  }
+
+  /**
+   * Create new profile and prompt for login
+   * @param {Array} args - Command arguments
+   */
+  async handleCreate(args) {
+    const profileName = args.find(arg => !arg.startsWith('--'));
+    const force = args.includes('--force');
+
+    if (!profileName) {
+      console.error('[X] Profile name is required');
+      console.log('');
+      console.log(`Usage: ${colored('ccs auth create <profile> [--force]', 'yellow')}`);
+      console.log('');
+      console.log('Example:');
+      console.log(`  ${colored('ccs auth create work', 'yellow')}`);
+      process.exit(1);
+    }
+
+    // Check if profile already exists
+    if (!force && this.registry.hasProfile(profileName)) {
+      console.error(`[X] Profile already exists: ${profileName}`);
+      console.log(`    Use ${colored('--force', 'yellow')} to overwrite`);
+      process.exit(1);
+    }
+
+    try {
+      // Create instance directory
+      console.log(`[i] Creating profile: ${profileName}`);
+      const instancePath = this.instanceMgr.ensureInstance(profileName);
+
+      // Create/update profile entry
+      if (this.registry.hasProfile(profileName)) {
+        this.registry.updateProfile(profileName, {
+          type: 'account'
+        });
+      } else {
+        this.registry.createProfile(profileName, {
+          type: 'account'
+        });
+      }
+
+      console.log(`[i] Instance directory: ${instancePath}`);
+      console.log('');
+      console.log(colored('[i] Starting Claude in isolated instance...', 'yellow'));
+      console.log(colored('[i] You will be prompted to login with your account.', 'yellow'));
+      console.log('');
+
+      // Detect Claude CLI
+      const claudeCli = detectClaudeCli();
+      if (!claudeCli) {
+        console.error('[X] Claude CLI not found');
+        console.log('');
+        console.log('Please install Claude CLI first:');
+        console.log('  https://claude.ai/download');
+        process.exit(1);
+      }
+
+      // Execute Claude in isolated instance (will auto-prompt for login if no credentials)
+      const child = spawn(claudeCli, [], {
+        stdio: 'inherit',
+        env: { ...process.env, CLAUDE_CONFIG_DIR: instancePath }
+      });
+
+      child.on('exit', (code) => {
+        if (code === 0) {
+          console.log('');
+          console.log(colored('[OK] Profile created successfully', 'green'));
+          console.log('');
+          console.log(`  Profile: ${profileName}`);
+          console.log(`  Instance: ${instancePath}`);
+          console.log('');
+          console.log('Usage:');
+          console.log(`  ${colored(`ccs ${profileName} "your prompt here"`, 'yellow')}`);
+          console.log('');
+          process.exit(0);
+        } else {
+          console.log('');
+          console.error('[X] Login failed or cancelled');
+          console.log('');
+          console.log('To retry:');
+          console.log(`  ${colored(`ccs auth create ${profileName} --force`, 'yellow')}`);
+          console.log('');
+          process.exit(1);
+        }
+      });
+
+      child.on('error', (err) => {
+        console.error(`[X] Failed to execute Claude CLI: ${err.message}`);
+        process.exit(1);
+      });
+
+    } catch (error) {
+      console.error(`[X] Failed to create profile: ${error.message}`);
+      process.exit(1);
+    }
+  }
+
+  /**
+   * List all saved profiles
+   * @param {Array} args - Command arguments
+   */
+  async handleList(args) {
+    const verbose = args.includes('--verbose');
+
+    try {
+      const profiles = this.registry.getAllProfiles();
+      const defaultProfile = this.registry.getDefaultProfile();
+      const profileNames = Object.keys(profiles);
+
+      if (profileNames.length === 0) {
+        console.log(colored('No account profiles found', 'yellow'));
+        console.log('');
+        console.log('To create your first profile:');
+        console.log(`  ${colored('ccs auth create <profile>', 'yellow')}  # Create and login to profile`);
+        console.log('');
+        console.log('Example:');
+        console.log(`  ${colored('ccs auth create work', 'yellow')}`);
+        console.log('');
+        return;
+      }
+
+      console.log(colored('Saved Account Profiles:', 'bold'));
+      console.log('');
+
+      // Sort by last_used (descending), then alphabetically
+      const sorted = profileNames.sort((a, b) => {
+        const aProfile = profiles[a];
+        const bProfile = profiles[b];
+
+        // Default first
+        if (a === defaultProfile) return -1;
+        if (b === defaultProfile) return 1;
+
+        // Then by last_used
+        if (aProfile.last_used && bProfile.last_used) {
+          return new Date(bProfile.last_used) - new Date(aProfile.last_used);
+        }
+        if (aProfile.last_used) return -1;
+        if (bProfile.last_used) return 1;
+
+        // Then alphabetically
+        return a.localeCompare(b);
+      });
+
+      sorted.forEach(name => {
+        const profile = profiles[name];
+        const isDefault = name === defaultProfile;
+        const indicator = isDefault ? colored('[*]', 'green') : '[ ]';
+
+        console.log(`${indicator} ${colored(name, 'cyan')}${isDefault ? colored(' (default)', 'green') : ''}`);
+
+        console.log(`    Type: ${profile.type || 'account'}`);
+
+        if (verbose) {
+          console.log(`    Created: ${new Date(profile.created).toLocaleString()}`);
+          if (profile.last_used) {
+            console.log(`    Last used: ${new Date(profile.last_used).toLocaleString()}`);
+          }
+        }
+
+        console.log('');
+      });
+
+      console.log(`Total profiles: ${profileNames.length}`);
+      console.log('');
+
+    } catch (error) {
+      console.error(`[X] Failed to list profiles: ${error.message}`);
+      process.exit(1);
+    }
+  }
+
+  /**
+   * Show details for a specific profile
+   * @param {Array} args - Command arguments
+   */
+  async handleShow(args) {
+    const profileName = args.find(arg => !arg.startsWith('--'));
+
+    if (!profileName) {
+      console.error('[X] Profile name is required');
+      console.log('');
+      console.log(`Usage: ${colored('ccs auth show <profile>', 'yellow')}`);
+      process.exit(1);
+    }
+
+    try {
+      const profile = this.registry.getProfile(profileName);
+      const defaultProfile = this.registry.getDefaultProfile();
+      const isDefault = profileName === defaultProfile;
+
+      console.log(colored(`Profile: ${profileName}`, 'bold'));
+      console.log('');
+      console.log(`  Type: ${profile.type || 'account'}`);
+      console.log(`  Default: ${isDefault ? 'Yes' : 'No'}`);
+      console.log(`  Instance: ${this.instanceMgr.getInstancePath(profileName)}`);
+      console.log(`  Created: ${new Date(profile.created).toLocaleString()}`);
+
+      if (profile.last_used) {
+        console.log(`  Last used: ${new Date(profile.last_used).toLocaleString()}`);
+      } else {
+        console.log(`  Last used: Never`);
+      }
+
+      console.log('');
+
+    } catch (error) {
+      console.error(`[X] ${error.message}`);
+      process.exit(1);
+    }
+  }
+
+  /**
+   * Remove a saved profile
+   * @param {Array} args - Command arguments
+   */
+  async handleRemove(args) {
+    const profileName = args.find(arg => !arg.startsWith('--'));
+    const force = args.includes('--force');
+
+    if (!profileName) {
+      console.error('[X] Profile name is required');
+      console.log('');
+      console.log(`Usage: ${colored('ccs auth remove <profile> [--force]', 'yellow')}`);
+      process.exit(1);
+    }
+
+    if (!this.registry.hasProfile(profileName)) {
+      console.error(`[X] Profile not found: ${profileName}`);
+      process.exit(1);
+    }
+
+    // Require --force for safety
+    if (!force) {
+      console.error('[X] Removal requires --force flag for safety');
+      console.log('');
+      console.log(`Run: ${colored(`ccs auth remove ${profileName} --force`, 'yellow')}`);
+      process.exit(1);
+    }
+
+    try {
+      // Delete instance
+      this.instanceMgr.deleteInstance(profileName);
+
+      // Delete profile
+      this.registry.deleteProfile(profileName);
+
+      console.log(colored('[OK] Profile removed successfully', 'green'));
+      console.log(`    Profile: ${profileName}`);
+      console.log('');
+
+    } catch (error) {
+      console.error(`[X] Failed to remove profile: ${error.message}`);
+      process.exit(1);
+    }
+  }
+
+  /**
+   * Set default profile
+   * @param {Array} args - Command arguments
+   */
+  async handleDefault(args) {
+    const profileName = args.find(arg => !arg.startsWith('--'));
+
+    if (!profileName) {
+      console.error('[X] Profile name is required');
+      console.log('');
+      console.log(`Usage: ${colored('ccs auth default <profile>', 'yellow')}`);
+      process.exit(1);
+    }
+
+    try {
+      this.registry.setDefaultProfile(profileName);
+
+      console.log(colored('[OK] Default profile set', 'green'));
+      console.log(`    Profile: ${profileName}`);
+      console.log('');
+      console.log('Now you can use:');
+      console.log(`  ${colored('ccs "your prompt"', 'yellow')}  # Uses ${profileName} profile`);
+      console.log('');
+
+    } catch (error) {
+      console.error(`[X] ${error.message}`);
+      process.exit(1);
+    }
+  }
+
+  /**
+   * Route auth command to appropriate handler
+   * @param {Array} args - Command arguments
+   */
+  async route(args) {
+    if (args.length === 0 || args[0] === '--help' || args[0] === '-h' || args[0] === 'help') {
+      this.showHelp();
+      return;
+    }
+
+    const command = args[0];
+    const commandArgs = args.slice(1);
+
+    switch (command) {
+      case 'create':
+        await this.handleCreate(commandArgs);
+        break;
+
+      case 'save':
+        // Deprecated - redirect to create
+        console.log(colored('[!] Command "save" is deprecated', 'yellow'));
+        console.log(`    Use: ${colored('ccs auth create <profile>', 'yellow')} instead`);
+        console.log('');
+        await this.handleCreate(commandArgs);
+        break;
+
+      case 'list':
+        await this.handleList(commandArgs);
+        break;
+
+      case 'show':
+        await this.handleShow(commandArgs);
+        break;
+
+      case 'remove':
+        await this.handleRemove(commandArgs);
+        break;
+
+      case 'default':
+        await this.handleDefault(commandArgs);
+        break;
+
+      case 'current':
+        console.log(colored('[!] Command "current" has been removed', 'yellow'));
+        console.log('');
+        console.log('Each profile has its own login in an isolated instance.');
+        console.log('Use "ccs auth list" to see all profiles.');
+        console.log('');
+        break;
+
+      case 'cleanup':
+        console.log(colored('[!] Command "cleanup" has been removed', 'yellow'));
+        console.log('');
+        console.log('No cleanup needed - no separate vault files.');
+        console.log('Use "ccs auth list" to see all profiles.');
+        console.log('');
+        break;
+
+      default:
+        console.error(`[X] Unknown command: ${command}`);
+        console.log('');
+        console.log('Run for help:');
+        console.log(`  ${colored('ccs auth --help', 'yellow')}`);
+        process.exit(1);
+    }
+  }
+}
+
+module.exports = AuthCommands;

package/bin/ccs.js

@@ -4,6 +4,7 @@
 const { spawn } = require('child_process');
 const path = require('path');
 const fs = require('fs');
+const os = require('os');
 const { error, colored } = require('./helpers');
 const { detectClaudeCli, showClaudeNotFoundError } = require('./claude-detector');
 const { getSettingsPath, getConfigPath } = require('./config-manager');
@@ -18,10 +19,13 @@ function escapeShellArg(arg) {
 }
 
 // Execute Claude CLI with unified spawn logic
-function execClaude(claudeCli, args) {
+function execClaude(claudeCli, args, envVars = null) {
   const isWindows = process.platform === 'win32';
   const needsShell = isWindows && /\.(cmd|bat|ps1)$/i.test(claudeCli);
 
+  // Prepare environment (merge with process.env if envVars provided)
+  const env = envVars ? { ...process.env, ...envVars } : process.env;
+
   let child;
   if (needsShell) {
     // When shell needed: concatenate into string to avoid DEP0190 warning
@@ -29,13 +33,15 @@ function execClaude(claudeCli, args) {
     child = spawn(cmdString, {
       stdio: 'inherit',
       windowsHide: true,
-      shell: true
+      shell: true,
+      env
     });
   } else {
     // When no shell needed: use array form (faster, no shell overhead)
     child = spawn(claudeCli, args, {
       stdio: 'inherit',
-      windowsHide: true
+      windowsHide: true,
+      env
     });
   }
 
@@ -100,10 +106,16 @@ function handleHelpCommand() {
   console.log(`  ${colored('ccs', 'yellow')}                         Use default profile`);
   console.log(`  ${colored('ccs glm', 'yellow')}                     Switch to GLM profile`);
   console.log(`  ${colored('ccs kimi', 'yellow')}                    Switch to Kimi profile`);
+  console.log(`  ${colored('ccs work', 'yellow')}                    Use work account (saved profile)`);
   console.log(`  ${colored('ccs glm', 'yellow')} "debug this code"   Switch to GLM and run command`);
-  console.log(`  ${colored('ccs kimi', 'yellow')} "write tests"      Switch to Kimi and run command`);
-  console.log(`  ${colored('ccs glm', 'yellow')} --verbose           Switch to GLM with Claude flags`);
-  console.log(`  ${colored('ccs kimi', 'yellow')} --verbose           Switch to Kimi with Claude flags`);
+  console.log(`  ${colored('ccs work', 'yellow')} "review code"      Use work account and run command`);
+  console.log('');
+
+  // Account Management
+  console.log(colored('Account Management:', 'cyan'));
+  console.log(`  ${colored('ccs auth create <profile>', 'yellow')}   Create new profile and login`);
+  console.log(`  ${colored('ccs auth list', 'yellow')}               List all saved profiles`);
+  console.log(`  ${colored('ccs auth --help', 'yellow')}             Show account management help`);
   console.log('');
 
   // Flags
@@ -195,7 +207,7 @@ function detectProfile(args) {
 }
 
 // Main execution
-function main() {
+async function main() {
   const args = process.argv.slice(2);
 
   // Special case: version command (check BEFORE profile detection)
@@ -222,36 +234,67 @@ function main() {
     return;
   }
 
-  // Detect profile
-  const { profile, remainingArgs } = detectProfile(args);
-
-  // Special case: "default" profile just runs claude directly
-  if (profile === 'default') {
-    const claudeCli = detectClaudeCli();
-    if (!claudeCli) {
-      showClaudeNotFoundError();
-      process.exit(1);
-    }
-
-    execClaude(claudeCli, remainingArgs);
+  // Special case: auth command (multi-account management)
+  if (firstArg === 'auth') {
+    const AuthCommands = require('./auth-commands');
+    const authCommands = new AuthCommands();
+    await authCommands.route(args.slice(1));
     return;
   }
 
-  // Get settings path for profile
-  const settingsPath = getSettingsPath(profile);
+  // Detect profile
+  const { profile, remainingArgs } = detectProfile(args);
 
-  // Detect Claude CLI
+  // Detect Claude CLI first (needed for all paths)
   const claudeCli = detectClaudeCli();
-
-  // Check if claude was found
   if (!claudeCli) {
     showClaudeNotFoundError();
     process.exit(1);
   }
 
-  // Execute claude with --settings
-  execClaude(claudeCli, ['--settings', settingsPath, ...remainingArgs]);
+  // Use ProfileDetector to determine profile type
+  const ProfileDetector = require('./profile-detector');
+  const InstanceManager = require('./instance-manager');
+  const ProfileRegistry = require('./profile-registry');
+  const { getSettingsPath } = require('./config-manager');
+
+  const detector = new ProfileDetector();
+
+  try {
+    const profileInfo = detector.detectProfileType(profile);
+
+    if (profileInfo.type === 'settings') {
+      // EXISTING FLOW: Settings-based profile (glm, kimi)
+      // Use --settings flag (backward compatible)
+      const expandedSettingsPath = getSettingsPath(profileInfo.name);
+      execClaude(claudeCli, ['--settings', expandedSettingsPath, ...remainingArgs]);
+    } else if (profileInfo.type === 'account') {
+      // NEW FLOW: Account-based profile (work, personal)
+      // All platforms: Use instance isolation with CLAUDE_CONFIG_DIR
+      const registry = new ProfileRegistry();
+      const instanceMgr = new InstanceManager();
+
+      // Ensure instance exists (lazy init if needed)
+      const instancePath = instanceMgr.ensureInstance(profileInfo.name);
+
+      // Update last_used timestamp
+      registry.touchProfile(profileInfo.name);
+
+      // Execute Claude with instance isolation
+      const envVars = { CLAUDE_CONFIG_DIR: instancePath };
+      execClaude(claudeCli, remainingArgs, envVars);
+    } else {
+      // DEFAULT: No profile configured, use Claude's own defaults
+      execClaude(claudeCli, remainingArgs);
+    }
+  } catch (error) {
+    console.error(`[X] ${error.message}`);
+    process.exit(1);
+  }
 }
 
 // Run main
-main();
+main().catch(error => {
+  console.error('Fatal error:', error.message);
+  process.exit(1);
+});

package/bin/instance-manager.js

@@ -0,0 +1,218 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+/**
+ * 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');
+  }
+
+  /**
+   * 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
+      const subdirs = [
+        'session-env',
+        'todos',
+        'logs',
+        'file-history',
+        'shell-snapshots',
+        'debug',
+        '.anthropic',
+        'commands',
+        'skills'
+      ];
+
+      subdirs.forEach(dir => {
+        const dirPath = path.join(instancePath, dir);
+        if (!fs.existsSync(dirPath)) {
+          fs.mkdirSync(dirPath, { recursive: true, mode: 0o700 });
+        }
+      });
+
+      // Copy global configs if exist
+      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 if exists
+    const globalSettings = path.join(globalConfigDir, 'settings.json');
+    if (fs.existsSync(globalSettings)) {
+      const instanceSettings = path.join(instancePath, 'settings.json');
+      fs.copyFileSync(globalSettings, instanceSettings);
+    }
+
+    // Copy commands directory if exists
+    const globalCommands = path.join(globalConfigDir, 'commands');
+    if (fs.existsSync(globalCommands)) {
+      const instanceCommands = path.join(instancePath, 'commands');
+      this._copyDirectory(globalCommands, instanceCommands);
+    }
+
+    // Copy skills directory if exists
+    const globalSkills = path.join(globalConfigDir, 'skills');
+    if (fs.existsSync(globalSkills)) {
+      const instanceSkills = path.join(instancePath, 'skills');
+      this._copyDirectory(globalSkills, instanceSkills);
+    }
+  }
+
+  /**
+   * 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/profile-detector.js

@@ -0,0 +1,199 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+/**
+ * Profile Detector
+ *
+ * Determines profile type (settings-based vs account-based) for routing.
+ * Priority: settings-based profiles (glm/kimi) checked FIRST for backward compatibility.
+ */
+class ProfileDetector {
+  constructor() {
+    this.configPath = path.join(os.homedir(), '.ccs', 'config.json');
+    this.profilesPath = path.join(os.homedir(), '.ccs', 'profiles.json');
+  }
+
+  /**
+   * Read settings-based config (config.json)
+   * @returns {Object} Config data
+   */
+  _readConfig() {
+    if (!fs.existsSync(this.configPath)) {
+      return { profiles: {} };
+    }
+
+    try {
+      const data = fs.readFileSync(this.configPath, 'utf8');
+      return JSON.parse(data);
+    } catch (error) {
+      console.warn(`[!] Warning: Could not read config.json: ${error.message}`);
+      return { profiles: {} };
+    }
+  }
+
+  /**
+   * Read account-based profiles (profiles.json)
+   * @returns {Object} Profiles data
+   */
+  _readProfiles() {
+    if (!fs.existsSync(this.profilesPath)) {
+      return { profiles: {}, default: null };
+    }
+
+    try {
+      const data = fs.readFileSync(this.profilesPath, 'utf8');
+      return JSON.parse(data);
+    } catch (error) {
+      console.warn(`[!] Warning: Could not read profiles.json: ${error.message}`);
+      return { profiles: {}, default: null };
+    }
+  }
+
+  /**
+   * Detect profile type and return routing information
+   * @param {string} profileName - Profile name to detect
+   * @returns {Object} {type: 'settings'|'account'|'default', ...info}
+   */
+  detectProfileType(profileName) {
+    // Special case: 'default' means use default profile
+    if (profileName === 'default' || profileName === null || profileName === undefined) {
+      return this._resolveDefaultProfile();
+    }
+
+    // Priority 1: Check settings-based profiles (glm, kimi) - BACKWARD COMPATIBILITY
+    const config = this._readConfig();
+
+    if (config.profiles && config.profiles[profileName]) {
+      return {
+        type: 'settings',
+        name: profileName,
+        settingsPath: config.profiles[profileName]
+      };
+    }
+
+    // Priority 2: Check account-based profiles (work, personal)
+    const profiles = this._readProfiles();
+
+    if (profiles.profiles && profiles.profiles[profileName]) {
+      return {
+        type: 'account',
+        name: profileName,
+        profile: profiles.profiles[profileName]
+      };
+    }
+
+    // Not found
+    throw new Error(
+      `Profile not found: ${profileName}\n` +
+      `Available profiles:\n` +
+      this._listAvailableProfiles()
+    );
+  }
+
+  /**
+   * Resolve default profile
+   * @returns {Object} Default profile info
+   */
+  _resolveDefaultProfile() {
+    // Check if account-based default exists
+    const profiles = this._readProfiles();
+
+    if (profiles.default && profiles.profiles[profiles.default]) {
+      return {
+        type: 'account',
+        name: profiles.default,
+        profile: profiles.profiles[profiles.default]
+      };
+    }
+
+    // Check if settings-based default exists
+    const config = this._readConfig();
+
+    if (config.profiles && config.profiles['default']) {
+      return {
+        type: 'settings',
+        name: 'default',
+        settingsPath: config.profiles['default']
+      };
+    }
+
+    // No default profile configured, use Claude's own defaults
+    return {
+      type: 'default',
+      name: 'default',
+      message: 'No profile configured. Using Claude CLI defaults from ~/.claude/'
+    };
+  }
+
+  /**
+   * List available profiles (for error messages)
+   * @returns {string} Formatted list
+   */
+  _listAvailableProfiles() {
+    const lines = [];
+
+    // Settings-based profiles
+    const config = this._readConfig();
+    const settingsProfiles = Object.keys(config.profiles || {});
+
+    if (settingsProfiles.length > 0) {
+      lines.push('Settings-based profiles (GLM, Kimi, etc.):');
+      settingsProfiles.forEach(name => {
+        lines.push(`  - ${name}`);
+      });
+    }
+
+    // Account-based profiles
+    const profiles = this._readProfiles();
+    const accountProfiles = Object.keys(profiles.profiles || {});
+
+    if (accountProfiles.length > 0) {
+      lines.push('Account-based profiles:');
+      accountProfiles.forEach(name => {
+        const isDefault = name === profiles.default;
+        lines.push(`  - ${name}${isDefault ? ' [DEFAULT]' : ''}`);
+      });
+    }
+
+    if (lines.length === 0) {
+      return '  (no profiles configured)\n' +
+        '  Run "ccs auth save <profile>" to create your first account profile.';
+    }
+
+    return lines.join('\n');
+  }
+
+  /**
+   * Check if profile exists (any type)
+   * @param {string} profileName - Profile name
+   * @returns {boolean} True if exists
+   */
+  hasProfile(profileName) {
+    try {
+      this.detectProfileType(profileName);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Get all available profile names
+   * @returns {Object} {settings: [...], accounts: [...]}
+   */
+  getAllProfiles() {
+    const config = this._readConfig();
+    const profiles = this._readProfiles();
+
+    return {
+      settings: Object.keys(config.profiles || {}),
+      accounts: Object.keys(profiles.profiles || {}),
+      default: profiles.default
+    };
+  }
+}
+
+module.exports = ProfileDetector;

package/bin/profile-registry.js

@@ -0,0 +1,226 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+/**
+ * Profile Registry (Simplified)
+ *
+ * Manages account profile metadata in ~/.ccs/profiles.json
+ * Each profile represents an isolated Claude instance with login credentials.
+ *
+ * Profile Schema (v3.0 - Minimal):
+ * {
+ *   type: 'account',         // Profile type
+ *   created: <ISO timestamp>, // Creation time
+ *   last_used: <ISO timestamp or null> // Last usage time
+ * }
+ *
+ * Removed fields from v2.x:
+ * - vault: No encrypted vault (credentials in instance)
+ * - subscription: No credential reading
+ * - email: No credential reading
+ */
+class ProfileRegistry {
+  constructor() {
+    this.profilesPath = path.join(os.homedir(), '.ccs', 'profiles.json');
+  }
+
+  /**
+   * Read profiles from disk
+   * @returns {Object} Profiles data
+   */
+  _read() {
+    if (!fs.existsSync(this.profilesPath)) {
+      return {
+        version: '2.0.0',
+        profiles: {},
+        default: null
+      };
+    }
+
+    try {
+      const data = fs.readFileSync(this.profilesPath, 'utf8');
+      return JSON.parse(data);
+    } catch (error) {
+      throw new Error(`Failed to read profiles: ${error.message}`);
+    }
+  }
+
+  /**
+   * Write profiles to disk atomically
+   * @param {Object} data - Profiles data
+   */
+  _write(data) {
+    const dir = path.dirname(this.profilesPath);
+
+    // Ensure directory exists
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+    }
+
+    // Atomic write: temp file + rename
+    const tempPath = `${this.profilesPath}.tmp`;
+
+    try {
+      fs.writeFileSync(tempPath, JSON.stringify(data, null, 2), { mode: 0o600 });
+      fs.renameSync(tempPath, this.profilesPath);
+    } catch (error) {
+      // Cleanup temp file on error
+      if (fs.existsSync(tempPath)) {
+        fs.unlinkSync(tempPath);
+      }
+      throw new Error(`Failed to write profiles: ${error.message}`);
+    }
+  }
+
+  /**
+   * Create a new profile
+   * @param {string} name - Profile name
+   * @param {Object} metadata - Profile metadata (type, created, last_used)
+   */
+  createProfile(name, metadata = {}) {
+    const data = this._read();
+
+    if (data.profiles[name]) {
+      throw new Error(`Profile already exists: ${name}`);
+    }
+
+    // v3.0 minimal schema: only essential fields
+    data.profiles[name] = {
+      type: metadata.type || 'account',
+      created: new Date().toISOString(),
+      last_used: null
+    };
+
+    // Set as default if no default exists
+    if (!data.default) {
+      data.default = name;
+    }
+
+    this._write(data);
+  }
+
+  /**
+   * Get profile metadata
+   * @param {string} name - Profile name
+   * @returns {Object} Profile metadata
+   */
+  getProfile(name) {
+    const data = this._read();
+
+    if (!data.profiles[name]) {
+      throw new Error(`Profile not found: ${name}`);
+    }
+
+    return data.profiles[name];
+  }
+
+  /**
+   * Update profile metadata
+   * @param {string} name - Profile name
+   * @param {Object} updates - Fields to update
+   */
+  updateProfile(name, updates) {
+    const data = this._read();
+
+    if (!data.profiles[name]) {
+      throw new Error(`Profile not found: ${name}`);
+    }
+
+    data.profiles[name] = {
+      ...data.profiles[name],
+      ...updates
+    };
+
+    this._write(data);
+  }
+
+  /**
+   * Delete a profile
+   * @param {string} name - Profile name
+   */
+  deleteProfile(name) {
+    const data = this._read();
+
+    if (!data.profiles[name]) {
+      throw new Error(`Profile not found: ${name}`);
+    }
+
+    delete data.profiles[name];
+
+    // Clear default if it was the deleted profile
+    if (data.default === name) {
+      // Set to first remaining profile or null
+      const remaining = Object.keys(data.profiles);
+      data.default = remaining.length > 0 ? remaining[0] : null;
+    }
+
+    this._write(data);
+  }
+
+  /**
+   * List all profiles
+   * @returns {Array} Array of profile names
+   */
+  listProfiles() {
+    const data = this._read();
+    return Object.keys(data.profiles);
+  }
+
+  /**
+   * Get all profiles with metadata
+   * @returns {Object} All profiles
+   */
+  getAllProfiles() {
+    const data = this._read();
+    return data.profiles;
+  }
+
+  /**
+   * Get default profile name
+   * @returns {string|null} Default profile name
+   */
+  getDefaultProfile() {
+    const data = this._read();
+    return data.default;
+  }
+
+  /**
+   * Set default profile
+   * @param {string} name - Profile name
+   */
+  setDefaultProfile(name) {
+    const data = this._read();
+
+    if (!data.profiles[name]) {
+      throw new Error(`Profile not found: ${name}`);
+    }
+
+    data.default = name;
+    this._write(data);
+  }
+
+  /**
+   * Check if profile exists
+   * @param {string} name - Profile name
+   * @returns {boolean}
+   */
+  hasProfile(name) {
+    const data = this._read();
+    return !!data.profiles[name];
+  }
+
+  /**
+   * Update last used timestamp
+   * @param {string} name - Profile name
+   */
+  touchProfile(name) {
+    this.updateProfile(name, {
+      last_used: new Date().toISOString()
+    });
+  }
+}
+
+module.exports = ProfileRegistry;

package/lib/ccs

@@ -2,7 +2,7 @@
 set -euo pipefail
 
 # Version (updated by scripts/bump-version.sh)
-CCS_VERSION="2.5.1"
+CCS_VERSION="3.0.0"
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 readonly CONFIG_FILE="${CCS_CONFIG:-$HOME/.ccs/config.json}"
 

package/lib/ccs.ps1

@@ -141,7 +141,7 @@ function Show-Help {
 }
 
 # Version (updated by scripts/bump-version.sh)
-$CcsVersion = "2.5.1"
+$CcsVersion = "3.0.0"
 $ScriptDir = Split-Path -Parent $MyInvocation.MyCommand.Path
 $ConfigFile = if ($env:CCS_CONFIG) { $env:CCS_CONFIG } else { "$env:USERPROFILE\.ccs\config.json" }
 

package/package.json

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