@kaitranntt/ccs 2.5.1 → 3.0.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;