@kaitranntt/ccs 2.4.0

package/bin/ccs.js

@@ -0,0 +1,196 @@
+#!/usr/bin/env node
+'use strict';
+
+const { spawn } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+const { showError, colors } = require('./helpers');
+const { detectClaudeCli, validateClaudeCli, showClaudeNotFoundError } = require('./claude-detector');
+const { getSettingsPath } = require('./config-manager');
+
+// Version (sync with package.json)
+const CCS_VERSION = require('../package.json').version;
+
+// Special command handlers
+function handleVersionCommand() {
+  console.log(`CCS (Claude Code Switch) version ${CCS_VERSION}`);
+
+  // Show install location
+  const installLocation = process.argv[1];
+  if (installLocation) {
+    console.log(`Installed at: ${installLocation}`);
+  }
+
+  console.log('https://github.com/kaitranntt/ccs');
+  process.exit(0);
+}
+
+function handleHelpCommand(remainingArgs) {
+  // Detect and validate Claude CLI
+  const claudeCli = detectClaudeCli();
+
+  if (!claudeCli) {
+    showClaudeNotFoundError();
+    process.exit(1);
+  }
+
+  try {
+    validateClaudeCli(claudeCli);
+  } catch (e) {
+    showError(e.message);
+    process.exit(1);
+  }
+
+  // Execute claude --help
+  const child = spawn(claudeCli, ['--help', ...remainingArgs], { stdio: 'inherit' });
+
+  child.on('exit', (code, signal) => {
+    if (signal) {
+      process.kill(process.pid, signal);
+    } else {
+      process.exit(code || 0);
+    }
+  });
+
+  child.on('error', (err) => {
+    console.error(`Error executing claude --help: ${err.message}`);
+    process.exit(1);
+  });
+}
+
+function handleInstallCommand() {
+  // Implementation for --install (copy commands/skills to ~/.claude)
+  console.log('[Installing CCS Commands and Skills]');
+  console.log('Feature not yet implemented in Node.js standalone');
+  console.log('Use traditional installer for now:');
+  console.log(process.platform === 'win32'
+    ? '  irm ccs.kaitran.ca/install | iex'
+    : '  curl -fsSL ccs.kaitran.ca/install | bash');
+  process.exit(0);
+}
+
+function handleUninstallCommand() {
+  // Implementation for --uninstall (remove commands/skills from ~/.claude)
+  console.log('[Uninstalling CCS Commands and Skills]');
+  console.log('Feature not yet implemented in Node.js standalone');
+  console.log('Use traditional uninstaller for now');
+  process.exit(0);
+}
+
+// Smart profile detection
+function detectProfile(args) {
+  if (args.length === 0 || args[0].startsWith('-')) {
+    // No args or first arg is a flag → use default profile
+    return { profile: 'default', remainingArgs: args };
+  } else {
+    // First arg doesn't start with '-' → treat as profile name
+    return { profile: args[0], remainingArgs: args.slice(1) };
+  }
+}
+
+// Main execution
+function main() {
+  const args = process.argv.slice(2);
+
+  // Special case: version command (check BEFORE profile detection)
+  const firstArg = args[0];
+  if (firstArg === 'version' || firstArg === '--version' || firstArg === '-v') {
+    handleVersionCommand();
+  }
+
+  // Special case: help command
+  if (firstArg === '--help' || firstArg === '-h' || firstArg === 'help') {
+    const remainingArgs = args.slice(1);
+    handleHelpCommand(remainingArgs);
+    return;
+  }
+
+  // Special case: install command
+  if (firstArg === '--install') {
+    handleInstallCommand();
+    return;
+  }
+
+  // Special case: uninstall command
+  if (firstArg === '--uninstall') {
+    handleUninstallCommand();
+    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);
+    }
+
+    try {
+      validateClaudeCli(claudeCli);
+    } catch (e) {
+      showError(e.message);
+      process.exit(1);
+    }
+
+    // Execute claude with args
+    const child = spawn(claudeCli, remainingArgs, { stdio: 'inherit' });
+
+    child.on('exit', (code, signal) => {
+      if (signal) {
+        process.kill(process.pid, signal);
+      } else {
+        process.exit(code || 0);
+      }
+    });
+
+    child.on('error', (err) => {
+      console.error(`Error executing claude: ${err.message}`);
+      process.exit(1);
+    });
+
+    return;
+  }
+
+  // Get settings path for profile
+  const settingsPath = getSettingsPath(profile);
+
+  // Detect Claude CLI
+  const claudeCli = detectClaudeCli();
+
+  if (!claudeCli) {
+    showClaudeNotFoundError();
+    process.exit(1);
+  }
+
+  // Validate Claude CLI path
+  try {
+    validateClaudeCli(claudeCli);
+  } catch (e) {
+    showError(e.message);
+    process.exit(1);
+  }
+
+  // Execute claude with --settings
+  const claudeArgs = ['--settings', settingsPath, ...remainingArgs];
+  const child = spawn(claudeCli, claudeArgs, { stdio: 'inherit' });
+
+  child.on('exit', (code, signal) => {
+    if (signal) {
+      process.kill(process.pid, signal);
+    } else {
+      process.exit(code || 0);
+    }
+  });
+
+  child.on('error', (err) => {
+    console.error(`Error executing claude: ${err.message}`);
+    process.exit(1);
+  });
+}
+
+// Run main
+main();

package/bin/claude-detector.js

@@ -0,0 +1,156 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+const { showError, expandPath, isPathSafe } = require('./helpers');
+
+// Detect Claude CLI executable
+function detectClaudeCli() {
+  // Priority 1: CCS_CLAUDE_PATH environment variable
+  if (process.env.CCS_CLAUDE_PATH) {
+    const ccsPath = expandPath(process.env.CCS_CLAUDE_PATH);
+    if (fs.existsSync(ccsPath) && isExecutable(ccsPath)) {
+      return ccsPath;
+    }
+    // Invalid CCS_CLAUDE_PATH - continue to fallbacks
+  }
+
+  // Priority 2: Check if claude in PATH
+  try {
+    const claudePath = execSync(
+      process.platform === 'win32' ? 'where claude' : 'which claude',
+      { encoding: 'utf8', stdio: ['pipe', 'pipe', 'ignore'] }
+    ).trim().split('\n')[0];
+
+    if (claudePath && fs.existsSync(claudePath)) {
+      return claudePath;
+    }
+  } catch (e) {
+    // Not in PATH, continue to common locations
+  }
+
+  // Priority 3: Check common installation locations
+  const commonLocations = getCommonLocations();
+
+  for (const location of commonLocations) {
+    const expandedPath = expandPath(location);
+    if (fs.existsSync(expandedPath) && isExecutable(expandedPath)) {
+      return expandedPath;
+    }
+  }
+
+  // Not found
+  return null;
+}
+
+// Get platform-specific common locations
+function getCommonLocations() {
+  const home = require('os').homedir();
+
+  if (process.platform === 'win32') {
+    return [
+      path.join(process.env.LOCALAPPDATA || '', 'Claude', 'claude.exe'),
+      path.join(process.env.PROGRAMFILES || '', 'Claude', 'claude.exe'),
+      'C:\\Program Files\\Claude\\claude.exe',
+      'D:\\Program Files\\Claude\\claude.exe',
+      path.join(home, '.local', 'bin', 'claude.exe')
+    ];
+  } else if (process.platform === 'darwin') {
+    return [
+      '/usr/local/bin/claude',
+      path.join(home, '.local/bin/claude'),
+      '/opt/homebrew/bin/claude'
+    ];
+  } else {
+    return [
+      '/usr/local/bin/claude',
+      path.join(home, '.local/bin/claude'),
+      '/usr/bin/claude'
+    ];
+  }
+}
+
+// Check if file is executable
+function isExecutable(filePath) {
+  try {
+    fs.accessSync(filePath, fs.constants.X_OK);
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+
+// Validate Claude CLI path
+function validateClaudeCli(claudePath) {
+  // Check 1: Empty path
+  if (!claudePath) {
+    throw new Error('No path provided');
+  }
+
+  // Check 2: File exists
+  if (!fs.existsSync(claudePath)) {
+    throw new Error(`File not found: ${claudePath}`);
+  }
+
+  // Check 3: Is regular file (not directory)
+  const stats = fs.statSync(claudePath);
+  if (!stats.isFile()) {
+    throw new Error(`Path is a directory: ${claudePath}`);
+  }
+
+  // Check 4: Is executable
+  if (!isExecutable(claudePath)) {
+    throw new Error(`File is not executable: ${claudePath}\n\nTry: chmod +x ${claudePath}`);
+  }
+
+  // Check 5: Path safety (prevent injection)
+  if (!isPathSafe(claudePath)) {
+    throw new Error(`Path contains unsafe characters: ${claudePath}\n\nAllowed: alphanumeric, path separators, spaces, hyphens, underscores, dots`);
+  }
+
+  return true;
+}
+
+// Show Claude not found error
+function showClaudeNotFoundError() {
+  const envVarStatus = process.env.CCS_CLAUDE_PATH || '(not set)';
+  const isWindows = process.platform === 'win32';
+
+  const errorMsg = `Claude CLI not found
+
+Searched:
+  - CCS_CLAUDE_PATH: ${envVarStatus}
+  - System PATH: not found
+  - Common locations: not found
+
+Solutions:
+  1. Add Claude CLI to PATH:
+
+     ${isWindows
+       ? '# Find where Claude is installed\n     Get-ChildItem -Path C:\\,D:\\ -Filter claude.exe -Recurse\n\n     # Add to PATH\n     $env:Path += \';D:\\path\\to\\claude\\directory\'\n     [Environment]::SetEnvironmentVariable(\'Path\', $env:Path, \'User\')'
+       : '# Find where Claude is installed\n     sudo find / -name claude 2>/dev/null\n\n     # Add to PATH\n     export PATH="/path/to/claude/bin:$PATH"\n     echo \'export PATH="/path/to/claude/bin:$PATH"\' >> ~/.bashrc\n     source ~/.bashrc'
+     }
+
+  2. Or set custom path:
+
+     ${isWindows
+       ? '$env:CCS_CLAUDE_PATH = \'D:\\full\\path\\to\\claude.exe\'\n     [Environment]::SetEnvironmentVariable(\'CCS_CLAUDE_PATH\', \'D:\\full\\path\\to\\claude.exe\', \'User\')'
+       : 'export CCS_CLAUDE_PATH="/full/path/to/claude"\n     echo \'export CCS_CLAUDE_PATH="/full/path/to/claude"\' >> ~/.bashrc\n     source ~/.bashrc'
+     }
+
+  3. Or install Claude CLI:
+
+     https://docs.claude.com/en/docs/claude-code/installation
+
+Verify installation:
+  ccs --version`;
+
+  showError(errorMsg);
+}
+
+module.exports = {
+  detectClaudeCli,
+  validateClaudeCli,
+  showClaudeNotFoundError
+};

package/bin/config-manager.js

@@ -0,0 +1,129 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { showError, expandPath, validateProfileName } = require('./helpers');
+
+// Get config file path
+function getConfigPath() {
+  return process.env.CCS_CONFIG || path.join(os.homedir(), '.ccs', 'config.json');
+}
+
+// Read and parse config
+function readConfig() {
+  const configPath = getConfigPath();
+
+  // Check config exists
+  if (!fs.existsSync(configPath)) {
+    const isWindows = process.platform === 'win32';
+    showError(`Config file not found: ${configPath}
+
+Solutions:
+  1. Reinstall CCS:
+     ${isWindows ? 'irm ccs.kaitran.ca/install | iex' : 'curl -fsSL ccs.kaitran.ca/install | bash'}
+
+  2. Or create config manually:
+     mkdir -p ~/.ccs
+     cat > ~/.ccs/config.json << 'EOF'
+{
+  "profiles": {
+    "glm": "~/.ccs/glm.settings.json",
+    "default": "~/.claude/settings.json"
+  }
+}
+EOF`);
+    process.exit(1);
+  }
+
+  // Read and parse JSON
+  let config;
+  try {
+    const configContent = fs.readFileSync(configPath, 'utf8');
+    config = JSON.parse(configContent);
+  } catch (e) {
+    const isWindows = process.platform === 'win32';
+    showError(`Invalid JSON in ${configPath}
+
+Fix the JSON syntax or reinstall:
+  ${isWindows ? 'irm ccs.kaitran.ca/install | iex' : 'curl -fsSL ccs.kaitran.ca/install | bash'}`);
+    process.exit(1);
+  }
+
+  // Validate config has profiles object
+  if (!config.profiles || typeof config.profiles !== 'object') {
+    const isWindows = process.platform === 'win32';
+    showError(`Config must have 'profiles' object
+
+See config.example.json for correct format
+Or reinstall:
+  ${isWindows ? 'irm ccs.kaitran.ca/install | iex' : 'curl -fsSL ccs.kaitran.ca/install | bash'}`);
+    process.exit(1);
+  }
+
+  return config;
+}
+
+// Get settings path for profile
+function getSettingsPath(profile) {
+  const config = readConfig();
+
+  // Validate profile name
+  if (!validateProfileName(profile)) {
+    showError(`Invalid profile name: ${profile}
+
+Use only alphanumeric characters, dash, or underscore.`);
+    process.exit(1);
+  }
+
+  // Get settings path
+  const settingsPath = config.profiles[profile];
+
+  if (!settingsPath) {
+    const availableProfiles = Object.keys(config.profiles).map(p => `  - ${p}`).join('\n');
+    showError(`Profile '${profile}' not found in ${getConfigPath()}
+
+Available profiles:
+${availableProfiles}`);
+    process.exit(1);
+  }
+
+  // Expand path
+  const expandedPath = expandPath(settingsPath);
+
+  // Validate settings file exists
+  if (!fs.existsSync(expandedPath)) {
+    const isWindows = process.platform === 'win32';
+    showError(`Settings file not found: ${expandedPath}
+
+Solutions:
+  1. Create the settings file for profile '${profile}'
+  2. Update the path in ${getConfigPath()}
+  3. Or reinstall: ${isWindows ? 'irm ccs.kaitran.ca/install | iex' : 'curl -fsSL ccs.kaitran.ca/install | bash'}`);
+    process.exit(1);
+  }
+
+  // Validate settings file is valid JSON
+  try {
+    const settingsContent = fs.readFileSync(expandedPath, 'utf8');
+    JSON.parse(settingsContent);
+  } catch (e) {
+    showError(`Invalid JSON in ${expandedPath}
+
+Details: ${e.message}
+
+Solutions:
+  1. Validate JSON at https://jsonlint.com
+  2. Or reset to template: echo '{"env":{}}' > ${expandedPath}
+  3. Or reinstall CCS`);
+    process.exit(1);
+  }
+
+  return expandedPath;
+}
+
+module.exports = {
+  getConfigPath,
+  readConfig,
+  getSettingsPath
+};

package/bin/helpers.js

@@ -0,0 +1,65 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+// Color formatting (TTY-aware)
+const useColors = process.stderr.isTTY && !process.env.NO_COLOR;
+const colors = useColors ? {
+  red: '\x1b[0;31m',
+  yellow: '\x1b[1;33m',
+  cyan: '\x1b[0;36m',
+  green: '\x1b[0;32m',
+  bold: '\x1b[1m',
+  reset: '\x1b[0m'
+} : { red: '', yellow: '', cyan: '', green: '', bold: '', reset: '' };
+
+// Error formatting
+function showError(message) {
+  console.error('');
+  console.error(colors.red + colors.bold + '╔═════════════════════════════════════════════╗' + colors.reset);
+  console.error(colors.red + colors.bold + '║  ERROR                                      ║' + colors.reset);
+  console.error(colors.red + colors.bold + '╚═════════════════════════════════════════════╝' + colors.reset);
+  console.error('');
+  console.error(colors.red + message + colors.reset);
+  console.error('');
+}
+
+// Path expansion (~ and env vars)
+function expandPath(pathStr) {
+  // Handle tilde expansion
+  if (pathStr.startsWith('~/') || pathStr.startsWith('~\\')) {
+    pathStr = path.join(os.homedir(), pathStr.slice(2));
+  }
+
+  // Expand environment variables (Windows and Unix)
+  pathStr = pathStr.replace(/\$\{([^}]+)\}/g, (_, name) => process.env[name] || '');
+  pathStr = pathStr.replace(/\$([A-Z_][A-Z0-9_]*)/gi, (_, name) => process.env[name] || '');
+
+  // Windows %VAR% style
+  if (process.platform === 'win32') {
+    pathStr = pathStr.replace(/%([^%]+)%/g, (_, name) => process.env[name] || '');
+  }
+
+  return path.normalize(pathStr);
+}
+
+// Validate profile name (alphanumeric, dash, underscore only)
+function validateProfileName(profile) {
+  return /^[a-zA-Z0-9_-]+$/.test(profile);
+}
+
+// Validate path safety (prevent injection)
+function isPathSafe(pathStr) {
+  // Allow: alphanumeric, path separators, space, dash, underscore, dot, colon, tilde
+  return !/[;|&<>`$*?\[\]'"()]/.test(pathStr);
+}
+
+module.exports = {
+  colors,
+  showError,
+  expandPath,
+  validateProfileName,
+  isPathSafe
+};

package/config/base-glm.settings.json

@@ -0,0 +1,10 @@
+{
+  "env": {
+    "ANTHROPIC_BASE_URL": "https://api.z.ai/api/anthropic",
+    "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"
+  }
+}

package/config/config.example.json

@@ -0,0 +1,6 @@
+{
+  "profiles": {
+    "glm": "~/.ccs/glm.settings.json",
+    "default": "~/.claude/settings.json"
+  }
+}