@haiyangj/ccs 1.0.1

package/src/commands/set.js

@@ -0,0 +1,90 @@
+import inquirer from 'inquirer';
+import { getProfile, updateProfile, getCurrentProfileName } from '../core/profiles.js';
+import { updateApiConfig } from '../core/config.js';
+import { validateProfile } from '../core/validator.js';
+import { success, error, warning, maskApiKey, info } from '../utils/logger.js';
+
+/**
+ * Update an existing profile
+ */
+export async function setCommand(name, url, key) {
+  try {
+    // Interactive mode if arguments not provided
+    if (!name || !url || !key) {
+      const answers = await inquirer.prompt([
+        {
+          type: 'input',
+          name: 'name',
+          message: 'Profile name to update:',
+          default: name,
+          validate: (input) => input ? true : 'Profile name is required'
+        },
+        {
+          type: 'input',
+          name: 'url',
+          message: 'New API URL:',
+          default: url,
+          validate: (input) => {
+            const result = validateProfile('default', input, 'sk-ant-12345678901234567890');
+            if (!result.valid && result.error.includes('URL')) {
+              return result.error;
+            }
+            return true;
+          }
+        },
+        {
+          type: 'password',
+          name: 'key',
+          message: 'New API Key:',
+          mask: '*',
+          default: key,
+          validate: (input) => {
+            const result = validateProfile('default', 'https://api.anthropic.com', input);
+            if (!result.valid && result.error.includes('key')) {
+              return result.error;
+            }
+            return true;
+          }
+        }
+      ]);
+
+      name = answers.name;
+      url = answers.url;
+      key = answers.key;
+    }
+
+    // Check if profile exists
+    const existing = getProfile(name);
+    if (!existing) {
+      error(`Profile '${name}' does not exist`);
+      info('Use "ccm add" to create a new profile');
+      process.exit(1);
+    }
+
+    // Validate inputs
+    const validation = validateProfile(name, url, key);
+    if (!validation.valid) {
+      error(validation.error);
+      process.exit(1);
+    }
+
+    // Update profile
+    updateProfile(name, url, key);
+
+    success(`Profile '${name}' updated successfully`);
+    console.log(`  API URL: ${url}`);
+    console.log(`  API Key: ${maskApiKey(key)}`);
+    console.log();
+
+    // If this is the current profile, update settings.json
+    const currentProfile = getCurrentProfileName();
+    if (currentProfile === name) {
+      updateApiConfig(url, key);
+      warning('This profile is currently active. Changes applied to settings.json');
+    }
+
+  } catch (err) {
+    error(`Failed to update profile: ${err.message}`);
+    process.exit(1);
+  }
+}

package/src/commands/show.js

@@ -0,0 +1,33 @@
+import { getCurrentProfile, getCurrentProfileName } from '../core/profiles.js';
+import { section, error, info, maskApiKey } from '../utils/logger.js';
+
+/**
+ * Show current active profile
+ */
+export async function showCommand() {
+  try {
+    const currentName = getCurrentProfileName();
+    const currentProfile = getCurrentProfile();
+
+    if (!currentProfile) {
+      info('No active profile. Use "ccm use <name>" to activate a profile.');
+      return;
+    }
+
+    section(`Current profile: ${currentName}`);
+
+    console.log(`  API URL:    ${currentProfile.apiUrl}`);
+    console.log(`  API Key:    ${maskApiKey(currentProfile.apiKey)}`);
+    console.log(`  Created:    ${new Date(currentProfile.createdAt).toLocaleString()}`);
+
+    if (currentProfile.lastUsed) {
+      console.log(`  Last used:  ${new Date(currentProfile.lastUsed).toLocaleString()}`);
+    }
+
+    console.log();
+
+  } catch (err) {
+    error(`Failed to show profile: ${err.message}`);
+    process.exit(1);
+  }
+}

package/src/commands/use.js

@@ -0,0 +1,61 @@
+import { getProfile, setCurrentProfile, getAllProfiles } from '../core/profiles.js';
+import { updateApiConfig } from '../core/config.js';
+import { success, error, maskApiKey, info } from '../utils/logger.js';
+
+/**
+ * Find similar profile names for suggestions
+ */
+function findSimilarProfiles(name, profiles) {
+  const profileNames = Object.keys(profiles);
+  return profileNames.filter(p =>
+    p.toLowerCase().includes(name.toLowerCase()) ||
+    name.toLowerCase().includes(p.toLowerCase())
+  );
+}
+
+/**
+ * Switch to a different profile
+ */
+export async function useCommand(name) {
+  try {
+    if (!name) {
+      error('Profile name is required');
+      info('Usage: ccm use <name>');
+      process.exit(1);
+    }
+
+    // Get profile
+    const profile = getProfile(name);
+
+    if (!profile) {
+      error(`Profile '${name}' does not exist`);
+
+      // Suggest similar profiles
+      const allProfiles = getAllProfiles();
+      const similar = findSimilarProfiles(name, allProfiles);
+
+      if (similar.length > 0) {
+        info(`Did you mean: ${similar.join(', ')}?`);
+      } else {
+        info('Use "ccm list" to see available profiles');
+      }
+
+      process.exit(1);
+    }
+
+    // Update settings.json
+    updateApiConfig(profile.apiUrl, profile.apiKey);
+
+    // Update current profile in profiles.json
+    setCurrentProfile(name);
+
+    success(`Switched to profile '${name}'`);
+    console.log(`  API URL: ${profile.apiUrl}`);
+    console.log(`  API Key: ${maskApiKey(profile.apiKey)}`);
+    console.log();
+
+  } catch (err) {
+    error(`Failed to switch profile: ${err.message}`);
+    process.exit(1);
+  }
+}

package/src/core/config.js

@@ -0,0 +1,123 @@
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'fs';
+import { dirname } from 'path';
+import { getSettingsPath, resolveClaudeDir } from '../utils/paths.js';
+
+/**
+ * Config file (settings.json) operations
+ */
+
+/**
+ * Read settings.json
+ */
+export function readSettings() {
+  const settingsPath = getSettingsPath();
+
+  if (!existsSync(settingsPath)) {
+    return null;
+  }
+
+  try {
+    const data = readFileSync(settingsPath, 'utf-8');
+    return JSON.parse(data);
+  } catch (error) {
+    throw new Error(`Failed to read settings: ${error.message}`);
+  }
+}
+
+/**
+ * Write settings.json atomically
+ */
+export function writeSettings(settings) {
+  const settingsPath = getSettingsPath();
+  const claudeDir = dirname(settingsPath);
+
+  // Ensure .claude directory exists
+  if (!existsSync(claudeDir)) {
+    mkdirSync(claudeDir, { recursive: true, mode: 0o700 });
+  }
+
+  try {
+    // Write to temp file first
+    const tempPath = settingsPath + '.tmp';
+    writeFileSync(tempPath, JSON.stringify(settings, null, 2), 'utf-8');
+
+    // Backup existing file
+    if (existsSync(settingsPath)) {
+      const backupPath = settingsPath + '.bak';
+      writeFileSync(backupPath, readFileSync(settingsPath));
+    }
+
+    // Rename temp to actual
+    writeFileSync(settingsPath, readFileSync(tempPath), 'utf-8');
+  } catch (error) {
+    throw new Error(`Failed to write settings: ${error.message}`);
+  }
+}
+
+/**
+ * Update specific fields in settings.json
+ */
+export function updateSettings(updates) {
+  const settings = readSettings() || {};
+  const merged = { ...settings, ...updates };
+  writeSettings(merged);
+  return merged;
+}
+
+/**
+ * Get API configuration from settings
+ */
+export function getApiConfig() {
+  const settings = readSettings();
+  if (!settings) {
+    return null;
+  }
+
+  return {
+    apiUrl: settings.env?.ANTHROPIC_BASE_URL || '',
+    apiKey: settings.env?.ANTHROPIC_AUTH_TOKEN || ''
+  };
+}
+
+/**
+ * Update API configuration in settings
+ */
+export function updateApiConfig(apiUrl, apiKey) {
+  const settings = readSettings() || {};
+
+  // Ensure env object exists
+  if (!settings.env) {
+    settings.env = {};
+  }
+
+  // Update env fields
+  settings.env.ANTHROPIC_BASE_URL = apiUrl;
+  settings.env.ANTHROPIC_AUTH_TOKEN = apiKey;
+
+  writeSettings(settings);
+  return settings;
+}
+
+/**
+ * Check if settings.json exists
+ */
+export function settingsFileExists() {
+  return existsSync(getSettingsPath());
+}
+
+/**
+ * Create initial settings.json with profile data
+ */
+export function createSettings(apiUrl, apiKey) {
+  const settings = {
+    env: {
+      ANTHROPIC_AUTH_TOKEN: apiKey,
+      ANTHROPIC_BASE_URL: apiUrl
+    },
+    enabledPlugins: {},
+    apiUrl: "",
+    apiKey: ""
+  };
+  writeSettings(settings);
+  return settings;
+}

package/src/core/profiles.js

@@ -0,0 +1,221 @@
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'fs';
+import { dirname } from 'path';
+import { getProfilesPath, resolveClaudeDir } from '../utils/paths.js';
+
+/**
+ * Profile management operations
+ */
+
+const PROFILES_VERSION = '1.0.0';
+
+/**
+ * Initialize empty profiles structure
+ */
+function createEmptyProfiles() {
+  return {
+    version: PROFILES_VERSION,
+    currentProfile: null,
+    profiles: {}
+  };
+}
+
+/**
+ * Read profiles.json
+ */
+export function readProfiles() {
+  const profilesPath = getProfilesPath();
+
+  if (!existsSync(profilesPath)) {
+    return createEmptyProfiles();
+  }
+
+  try {
+    const data = readFileSync(profilesPath, 'utf-8');
+    return JSON.parse(data);
+  } catch (error) {
+    throw new Error(`Failed to read profiles: ${error.message}`);
+  }
+}
+
+/**
+ * Write profiles.json atomically
+ */
+export function writeProfiles(profiles) {
+  const profilesPath = getProfilesPath();
+  const claudeDir = dirname(profilesPath);
+
+  // Ensure .claude directory exists
+  if (!existsSync(claudeDir)) {
+    mkdirSync(claudeDir, { recursive: true, mode: 0o700 });
+  }
+
+  try {
+    // Write to temp file first
+    const tempPath = profilesPath + '.tmp';
+    writeFileSync(tempPath, JSON.stringify(profiles, null, 2), { mode: 0o600 });
+
+    // Backup existing file
+    if (existsSync(profilesPath)) {
+      const backupPath = profilesPath + '.bak';
+      writeFileSync(backupPath, readFileSync(profilesPath));
+    }
+
+    // Rename temp to actual
+    writeFileSync(profilesPath, readFileSync(tempPath), { mode: 0o600 });
+  } catch (error) {
+    throw new Error(`Failed to write profiles: ${error.message}`);
+  }
+}
+
+/**
+ * Get a specific profile by name
+ */
+export function getProfile(name) {
+  const profiles = readProfiles();
+  return profiles.profiles[name] || null;
+}
+
+/**
+ * Get all profiles
+ */
+export function getAllProfiles() {
+  const profiles = readProfiles();
+  return profiles.profiles;
+}
+
+/**
+ * Get current active profile name
+ */
+export function getCurrentProfileName() {
+  const profiles = readProfiles();
+  return profiles.currentProfile;
+}
+
+/**
+ * Get current active profile
+ */
+export function getCurrentProfile() {
+  const profiles = readProfiles();
+  const currentName = profiles.currentProfile;
+  return currentName ? profiles.profiles[currentName] : null;
+}
+
+/**
+ * Add a new profile
+ */
+export function addProfile(name, apiUrl, apiKey) {
+  const profiles = readProfiles();
+
+  if (profiles.profiles[name]) {
+    throw new Error(`Profile '${name}' already exists`);
+  }
+
+  profiles.profiles[name] = {
+    name,
+    apiUrl,
+    apiKey,
+    createdAt: new Date().toISOString(),
+    lastUsed: null
+  };
+
+  // Set as current if it's the first profile
+  if (Object.keys(profiles.profiles).length === 1) {
+    profiles.currentProfile = name;
+    profiles.profiles[name].lastUsed = new Date().toISOString();
+  }
+
+  writeProfiles(profiles);
+  return profiles.profiles[name];
+}
+
+/**
+ * Update an existing profile
+ */
+export function updateProfile(name, apiUrl, apiKey) {
+  const profiles = readProfiles();
+
+  if (!profiles.profiles[name]) {
+    throw new Error(`Profile '${name}' does not exist`);
+  }
+
+  const existing = profiles.profiles[name];
+  profiles.profiles[name] = {
+    ...existing,
+    apiUrl,
+    apiKey
+  };
+
+  writeProfiles(profiles);
+  return profiles.profiles[name];
+}
+
+/**
+ * Delete a profile
+ */
+export function deleteProfile(name) {
+  const profiles = readProfiles();
+
+  if (!profiles.profiles[name]) {
+    throw new Error(`Profile '${name}' does not exist`);
+  }
+
+  if (profiles.currentProfile === name) {
+    throw new Error(`Cannot delete active profile '${name}'. Switch to another profile first.`);
+  }
+
+  delete profiles.profiles[name];
+  writeProfiles(profiles);
+}
+
+/**
+ * Rename a profile
+ */
+export function renameProfile(oldName, newName) {
+  const profiles = readProfiles();
+
+  if (!profiles.profiles[oldName]) {
+    throw new Error(`Profile '${oldName}' does not exist`);
+  }
+
+  if (profiles.profiles[newName]) {
+    throw new Error(`Profile '${newName}' already exists`);
+  }
+
+  profiles.profiles[newName] = {
+    ...profiles.profiles[oldName],
+    name: newName
+  };
+
+  delete profiles.profiles[oldName];
+
+  // Update current profile reference if needed
+  if (profiles.currentProfile === oldName) {
+    profiles.currentProfile = newName;
+  }
+
+  writeProfiles(profiles);
+}
+
+/**
+ * Set current active profile
+ */
+export function setCurrentProfile(name) {
+  const profiles = readProfiles();
+
+  if (!profiles.profiles[name]) {
+    throw new Error(`Profile '${name}' does not exist`);
+  }
+
+  profiles.currentProfile = name;
+  profiles.profiles[name].lastUsed = new Date().toISOString();
+
+  writeProfiles(profiles);
+}
+
+/**
+ * Check if profiles.json exists and has profiles
+ */
+export function hasProfiles() {
+  const profiles = readProfiles();
+  return Object.keys(profiles.profiles).length > 0;
+}

package/src/core/validator.js

@@ -0,0 +1,96 @@
+/**
+ * Input validation utilities
+ */
+
+/**
+ * Validate profile name
+ * Rules: 1-50 chars, alphanumeric, dash, underscore only
+ */
+export function validateProfileName(name) {
+  if (!name) {
+    return { valid: false, error: 'Profile name is required' };
+  }
+
+  if (typeof name !== 'string') {
+    return { valid: false, error: 'Profile name must be a string' };
+  }
+
+  if (name.length < 1 || name.length > 50) {
+    return { valid: false, error: 'Profile name must be 1-50 characters' };
+  }
+
+  const validPattern = /^[a-zA-Z0-9_-]+$/;
+  if (!validPattern.test(name)) {
+    return { valid: false, error: 'Profile name can only contain letters, numbers, dashes, and underscores' };
+  }
+
+  return { valid: true };
+}
+
+/**
+ * Validate API URL
+ * Rules: Valid HTTPS URL format
+ */
+export function validateApiUrl(url) {
+  if (!url) {
+    return { valid: false, error: 'API URL is required' };
+  }
+
+  if (typeof url !== 'string') {
+    return { valid: false, error: 'API URL must be a string' };
+  }
+
+  try {
+    const parsed = new URL(url);
+
+    if (parsed.protocol !== 'https:' && parsed.protocol !== 'http:') {
+      return { valid: false, error: 'API URL must use HTTPS or HTTP protocol' };
+    }
+
+    return { valid: true };
+  } catch (error) {
+    return { valid: false, error: 'Invalid URL format' };
+  }
+}
+
+/**
+ * Validate API key
+ * Rules: Non-empty string, minimum 10 chars
+ */
+export function validateApiKey(key) {
+  if (!key) {
+    return { valid: false, error: 'API key is required' };
+  }
+
+  if (typeof key !== 'string') {
+    return { valid: false, error: 'API key must be a string' };
+  }
+
+  if (key.length < 10) {
+    return { valid: false, error: 'API key must be at least 10 characters' };
+  }
+
+  return { valid: true };
+}
+
+/**
+ * Validate all profile inputs at once
+ */
+export function validateProfile(name, url, key) {
+  const nameValidation = validateProfileName(name);
+  if (!nameValidation.valid) {
+    return nameValidation;
+  }
+
+  const urlValidation = validateApiUrl(url);
+  if (!urlValidation.valid) {
+    return urlValidation;
+  }
+
+  const keyValidation = validateApiKey(key);
+  if (!keyValidation.valid) {
+    return keyValidation;
+  }
+
+  return { valid: true };
+}

package/src/utils/logger.js

@@ -0,0 +1,66 @@
+import chalk from 'chalk';
+
+/**
+ * Logger utility with colored output
+ */
+
+export function success(message) {
+  console.log(chalk.green('✓'), message);
+}
+
+export function error(message) {
+  console.log(chalk.red('✗'), message);
+}
+
+export function warning(message) {
+  console.log(chalk.yellow('⚠'), message);
+}
+
+export function info(message) {
+  console.log(chalk.blue('ℹ'), message);
+}
+
+export function log(message) {
+  console.log(message);
+}
+
+export function header(message) {
+  console.log(chalk.bold.blue(message));
+}
+
+export function dim(message) {
+  return chalk.dim(message);
+}
+
+export function bold(message) {
+  return chalk.bold(message);
+}
+
+/**
+ * Mask API key to show only last 4 characters
+ */
+export function maskApiKey(key) {
+  if (!key || key.length <= 4) {
+    return '****';
+  }
+  return '****' + key.slice(-4);
+}
+
+/**
+ * Format profile name with active indicator
+ */
+export function formatProfileName(name, isActive = false) {
+  if (isActive) {
+    return chalk.green('✓ ' + name);
+  }
+  return '  ' + name;
+}
+
+/**
+ * Print a section header with padding
+ */
+export function section(title) {
+  console.log();
+  console.log(chalk.bold.blue(title));
+  console.log();
+}