ccconfig 1.0.0 → 1.2.0

package/README.md

@@ -9,6 +9,9 @@ ccconfig use company
 
 # Switch back to personal configuration after work
 ccconfig use personal
+
+# Permanently write to shell config (no need to eval or source each time)
+ccconfig use personal --permanent  # or use -p for short
 ```
 
 ## Quick Start
@@ -37,19 +40,39 @@ ccconfig add
 # 3. Switch configuration
 ccconfig use work
 
-# 4. Restart Shell or apply immediately
+# 4. Apply immediately (choose one method):
+# Method A: Temporary (only in current shell)
 eval $(ccconfig env bash)  # or use the detected command from output
+
+# Method B: Permanent (write to shell config file)
+ccconfig use work --permanent  # or -p for short
+# Automatically detects and modifies ~/.bashrc, ~/.zshrc, or config.fish
 ```
 
 ### Settings Mode
 
+Settings Mode directly modifies `~/.claude/settings.json` file, which is Claude Code's native configuration file. This mode is suitable when you don't want to configure shell scripts.
+
+**How it works:**
+- Writes environment variables directly into `~/.claude/settings.json` under the `env` field
+- Claude Code reads these settings on startup
+- No shell configuration required
+- Requires Claude Code restart after each switch
+
+**Setup:**
+
 ```bash
 # 1. Switch to settings mode
 ccconfig mode settings
 
 # 2. Add configuration (interactive mode)
 ccconfig add
-# Follow the prompts to configure
+# Follow the prompts to enter:
+# - Name
+# - ANTHROPIC_BASE_URL
+# - ANTHROPIC_AUTH_TOKEN
+# - ANTHROPIC_API_KEY
+# - Description
 
 # 3. Switch configuration
 ccconfig use work
@@ -58,18 +81,63 @@ ccconfig use work
 # Configuration is now active!
 ```
 
+**Verification:**
+```bash
+# Check current configuration
+ccconfig current
+
+# View the settings file directly
+cat ~/.claude/settings.json
+```
+
 #### ENV Mode Shell Configuration
 
-Configure once by adding to your Shell startup files:
+You have two options to configure shell environment:
+
+**Option 1: Automatic (Recommended)**
+
+Use the `-p/--permanent` flag to automatically write to your shell config:
+
+```bash
+# Automatically detects your shell and writes to the appropriate config file
+ccconfig use <profile> --permanent
+
+# You will be prompted with:
+# - Warning about modifying shell config
+# - Target file path
+# - Content preview
+# - Confirmation prompt (yes/no)
+
+# This will modify:
+# - Fish: ~/.config/fish/config.fish
+# - Bash: ~/.bashrc
+# - Zsh: ~/.zshrc
+# - PowerShell: ~/.config/powershell/profile.ps1
+```
+
+The tool will add a marked block between `# >>> ccconfig >>>` and `# <<< ccconfig <<<` markers, making it easy to identify and update later.
+
+**Safety Features:**
+- **User confirmation required**: You will be prompted before any file is modified
+- **Content preview**: Shows exactly what will be written
+- **Clear explanation**: Explains what changes will be made
+- **Non-destructive**: Existing content is preserved, only the ccconfig block is updated
+- **Interactive only**: Requires interactive terminal to prevent accidental modifications
+
+**Option 2: Manual Configuration**
+
+If you prefer to manually configure, add the following to your shell startup files:
 
 **Fish** (`~/.config/fish/config.fish`):
 ```fish
 # Load Claude Code environment variables
-set -l claude_env ~/.config/claude-code/current.env
-if test -f $claude_env
-    for line in (cat $claude_env)
-        set -l parts (string split '=' $line)
-        set -gx $parts[1] $parts[2]
+set -l ccconfig_env ~/.config/ccconfig/current.env
+if test -f $ccconfig_env
+    for line in (cat $ccconfig_env)
+        set -l parts (string split -m1 '=' $line)
+        if test (count $parts) -eq 2
+            set -gx $parts[1] $parts[2]
+        end
     end
 end
 ```
@@ -77,25 +145,29 @@ end
 **Bash** (`~/.bashrc`):
 ```bash
 # Load Claude Code environment variables
-if [ -f ~/.config/claude-code/current.env ]; then
-    export $(grep -v '^#' ~/.config/claude-code/current.env | xargs)
+if [ -f ~/.config/ccconfig/current.env ]; then
+    set -a
+    . ~/.config/ccconfig/current.env
+    set +a
 fi
 ```
 
 **Zsh** (`~/.zshrc`):
 ```zsh
 # Load Claude Code environment variables
-if [ -f ~/.config/claude-code/current.env ]; then
-    export $(grep -v '^#' ~/.config/claude-code/current.env | xargs)
+if [ -f ~/.config/ccconfig/current.env ]; then
+    set -a
+    . ~/.config/ccconfig/current.env
+    set +a
 fi
 ```
 
 **PowerShell** (`$PROFILE`):
 ```powershell
 # Load Claude Code environment variables
-$claudeEnv = "$env:USERPROFILE\.config\claude-code\current.env"
-if (Test-Path $claudeEnv) {
-    Get-Content $claudeEnv | ForEach-Object {
+$cconfigEnv = "$env:USERPROFILE\.config\ccconfig\current.env"
+if (Test-Path $cconfigEnv) {
+    Get-Content $cconfigEnv | ForEach-Object {
         if ($_ -match '^([^=]+)=(.*)$') {
             [Environment]::SetEnvironmentVariable($matches[1], $matches[2], 'Process')
         }
@@ -103,95 +175,7 @@ if (Test-Path $claudeEnv) {
 }
 ```
 
-## Command Reference
-
-### Basic Commands
-
-```bash
-# Run without command (defaults to list)
-ccconfig
-
-# List all configurations
-ccconfig list
-
-# Add new configuration (interactive mode only, auto-creates config file on first use)
-ccconfig add
-
-# Switch configuration
-ccconfig use <name>
-
-# Remove configuration
-ccconfig remove <name>
-
-# View current status (shows all configuration sources)
-ccconfig current
-ccconfig current --show-secret  # Show full token
-
-# Show configuration file path
-ccconfig edit
-
-# View version
-ccconfig --version  # or -V
-```
-
-### Mode Management
-
-```bash
-# View current mode
-ccconfig mode
-
-# Switch to settings mode
-ccconfig mode settings
-
-# Switch to env mode
-ccconfig mode env
-```
-
-### ENV Mode Specific
-
-```bash
-# Apply immediately in current Shell (env mode)
-eval $(ccconfig env bash)      # Bash/Zsh
-ccconfig env fish | source     # Fish
-ccconfig env pwsh | iex        # PowerShell
-
-# Output .env format
-ccconfig env dotenv > .env
-```
-
-## Configuration File Locations
-
-- **Configuration List**: `~/.config/claude-code/profiles.json`
-- **Claude Settings**: `~/.claude/settings.json`
-- **Environment Variables File**: `~/.config/claude-code/current.env`
-- **Mode Settings**: `~/.config/claude-code/mode`
-
-## Configuration Example
-
-`~/.config/claude-code/profiles.json`:
-
-```json
-{
-  "profiles": {
-    "work": {
-      "env": {
-        "ANTHROPIC_BASE_URL": "https://api-proxy.company.com",
-        "ANTHROPIC_AUTH_TOKEN": "sk-auth-work-xxxxx",
-        "ANTHROPIC_API_KEY": "sk-key-work-xxxxx"
-      },
-      "description": "Work account"
-    },
-    "personal": {
-      "env": {
-        "ANTHROPIC_BASE_URL": "https://api.anthropic.com",
-        "ANTHROPIC_AUTH_TOKEN": "sk-ant-personal-xxxxx",
-        "ANTHROPIC_API_KEY": "sk-ant-personal-xxxxx"
-      },
-      "description": "Personal account"
-    }
-  }
-}
-```
+**Note**: Manual configuration allows you to switch profiles dynamically by changing `current.env`, while `-p/--permanent` writes the values directly into the shell config.
 
 ## Advanced Usage
 
@@ -228,17 +212,17 @@ source .env
 
 ```bash
 # Backup configuration
-cp ~/.config/claude-code/profiles.json ~/backup/claude-profiles.json
+cp ~/.config/ccconfig/profiles.json ~/backup/ccconfig-profiles.json
 
 # Sync to new machine
-scp ~/backup/claude-profiles.json new-machine:~/.config/claude-code/
+scp ~/backup/ccconfig-profiles.json new-machine:~/.config/ccconfig/
 
 # Or use version control (be careful with security!)
-cd ~/.config/claude-code
+cd ~/.config/ccconfig
 git init
 echo "*.env" >> .gitignore
 git add profiles.json
-git commit -m "Claude Code profiles"
+git commit -m "ccconfig profiles"
 ```
 
 ## Troubleshooting
@@ -246,15 +230,56 @@ git commit -m "Claude Code profiles"
 ### Configuration Not Taking Effect
 
 **Settings Mode**:
-1. Check if configuration is written correctly: `ccconfig current`
-2. Confirm Claude Code has been restarted
-3. Check the `env` field in `~/.claude/settings.json`
+1. **Check configuration is written correctly**: 
+   ```bash
+   ccconfig current
+   # Look at section 【1】~/.claude/settings.json
+   ```
+2. **Verify settings.json directly**:
+   ```bash
+   cat ~/.claude/settings.json | grep -A 5 '"env"'
+   ```
+3. **Confirm Claude Code has been restarted**:
+   - Completely quit Claude Code (not just close window)
+   - Restart the application
+4. **Check the `env` field** in `~/.claude/settings.json`:
+   ```json
+   {
+     "env": {
+       "ANTHROPIC_BASE_URL": "https://api.anthropic.com",
+       "ANTHROPIC_AUTH_TOKEN": "sk-...",
+       "ANTHROPIC_API_KEY": "sk-..."
+     }
+   }
+   ```
 
 **ENV Mode**:
-1. Check environment variables file: `cat ~/.config/claude-code/current.env`
-2. Confirm Shell configuration is correct: `cat ~/.bashrc | grep claude`
-3. Restart Shell or use `eval $(ccconfig env bash)`
-4. Check process environment variables: `ccconfig current`
+1. **Check environment variables file**: 
+   ```bash
+   cat ~/.config/ccconfig/current.env
+   ```
+2. **If using --permanent flag**:
+   - The tool will show a warning and ask for confirmation before modifying files
+   - Check your shell config file has ccconfig block:
+     ```bash
+     # For bash/zsh
+     cat ~/.bashrc | grep -A 5 "ccconfig"
+     # For fish
+     cat ~/.config/fish/config.fish | grep -A 5 "ccconfig"
+     ```
+   - Restart shell or run: `source ~/.bashrc` (or equivalent for your shell)
+   - Note: You can also use `-p` as a short form of `--permanent`
+   - To cancel the operation, type "no" when prompted
+   
+3. **If using manual configuration or eval command**:
+   - Confirm Shell configuration is correct: `cat ~/.bashrc | grep ccconfig`
+   - Restart Shell or use `eval $(ccconfig env bash)`
+   
+4. **Check process environment variables**: 
+   ```bash
+   ccconfig current
+   # Look at section 【3】Current Process Environment Variables
+   ```
 
 ### Configuration Lost After Mode Switch
 
@@ -269,9 +294,9 @@ ccconfig use work          # Reapply configuration
 
 ```bash
 # Fix configuration file permissions
-chmod 600 ~/.config/claude-code/profiles.json
+chmod 600 ~/.config/ccconfig/profiles.json
 chmod 600 ~/.claude/settings.json
-chmod 600 ~/.config/claude-code/current.env
+chmod 600 ~/.config/ccconfig/current.env
 ```
 
 ## Security Considerations
@@ -287,82 +312,6 @@ chmod 600 ~/.config/claude-code/current.env
 
 4. **Version Control**: If version controlling configurations, use encryption or private repositories
 
-## Frequently Asked Questions
-
-**Q: Which is better, Settings mode or ENV mode?**
-
-A:
-- **ENV mode** is recommended (default, better cross-shell support, instant apply)
-- If you prefer not to configure shell startup files, **Settings mode** can be simpler (only needs Claude Code restart)
-
-**Q: Can I use both modes simultaneously?**
-
-A: Not recommended. Claude Code reads configuration based on priority:
-- Settings mode: Reads directly from `settings.json`
-- ENV mode: Reads from environment variables
-
-Using both simultaneously may cause confusion.
-
-**Q: How to use on Windows?**
-
-A: Fully supported on Windows:
-- Configuration file location: `%USERPROFILE%\.config\claude-code\`
-- Settings mode requires no additional configuration
-- ENV mode uses PowerShell configuration
-
-**Q: Do I need to restart after switching configurations?**
-
-A:
-- **Settings mode**: Need to restart Claude Code
-- **ENV mode**: Need to restart Shell (or use `env` command for immediate effect)
-
-**Q: Can I export configurations for team use?**
-
-A: Yes, but be careful:
-```bash
-# Export configuration structure (excluding API keys)
-cat ~/.config/claude-code/profiles.json | \
-  jq '.profiles | map_values({baseUrl, description})' > team-config.json
-
-# Team members manually add their own API keys after importing
-```
-
-## Development
-
-### Project Structure
-
-```
-.
-├── ccconfig.js         # Core script
-├── package.json             # npm configuration
-├── README.md                # This document
-└── .gitignore               # Git ignore file
-```
-
-### Testing
-
-```bash
-# Test version output
-node ccconfig.js --version
-
-# Test adding configuration (interactive only)
-node ccconfig.js add
-
-# Test listing
-node ccconfig.js list
-
-# Test switching
-node ccconfig.js use test
-
-# Test status viewing
-node ccconfig.js current
-node ccconfig.js current --show-secret
-
-# Test mode switching
-node ccconfig.js mode
-node ccconfig.js mode env
-```
-
 ## License
 
 MIT

package/ccconfig.js

@@ -6,7 +6,7 @@ const os = require('os');
 const readline = require('readline');
 
 // Configuration file paths
-const CONFIG_DIR = path.join(os.homedir(), '.config', 'claude-code');
+const CONFIG_DIR = path.join(os.homedir(), '.config', 'ccconfig');
 const PROFILES_FILE = path.join(CONFIG_DIR, 'profiles.json');
 const CLAUDE_SETTINGS = path.join(os.homedir(), '.claude', 'settings.json');
 const ENV_FILE = path.join(CONFIG_DIR, 'current.env');
@@ -511,10 +511,239 @@ function detectShellCommand() {
   return {shell: null, command: null};
 }
 
+function escapePosix(value) {
+  const str = value == null ? '' : String(value);
+  return `'${str.replace(/'/g, `'"'"'`)}'`;
+}
+
+function escapeFish(value) {
+  const str = value == null ? '' : String(value);
+  return str.replace(/\\/g, '\\\\').replace(/"/g, '\\"').replace(/\$/g, '\\$');
+}
+
+function escapePwsh(value) {
+  const str = value == null ? '' : String(value);
+  return `'${str.replace(/'/g, `''`)}'`;
+}
+
+/**
+ * Detect shell type and config file path
+ */
+function detectShellConfig() {
+  const shellPath = (process.env.SHELL || '').toLowerCase();
+  const homeDir = os.homedir();
+
+  if (process.env.FISH_VERSION || shellPath.includes('fish')) {
+    const configPath = path.join(homeDir, '.config', 'fish', 'config.fish');
+    return {shell: 'fish', configPath, detected: true};
+  }
+
+  if (process.env.ZSH_NAME || process.env.ZSH_VERSION ||
+      shellPath.includes('zsh')) {
+    const configPath = path.join(homeDir, '.zshrc');
+    return {shell: 'zsh', configPath, detected: true};
+  }
+
+  if (shellPath.includes('bash')) {
+    if (process.platform === 'darwin') {
+      const bashProfile = path.join(homeDir, '.bash_profile');
+      const bashrc = path.join(homeDir, '.bashrc');
+      const configPath = fs.existsSync(bashProfile) || !fs.existsSync(bashrc) ?
+          bashProfile :
+          bashrc;
+      return {shell: 'bash', configPath, detected: true};
+    }
+    const configPath = path.join(homeDir, '.bashrc');
+    return {shell: 'bash', configPath, detected: true};
+  }
+
+  if (process.env.POWERSHELL_DISTRIBUTION_CHANNEL ||
+      shellPath.includes('pwsh') || shellPath.includes('powershell')) {
+    // PowerShell profile path varies by OS
+    const configPath = process.platform === 'win32' ?
+        path.join(
+            process.env.USERPROFILE || homeDir, 'Documents', 'PowerShell',
+            'Microsoft.PowerShell_profile.ps1') :
+        path.join(homeDir, '.config', 'powershell', 'profile.ps1');
+    return {shell: 'powershell', configPath, detected: true};
+  }
+
+  return {shell: null, configPath: null, detected: false};
+}
+
+/**
+ * Write environment variables permanently to shell config file
+ */
+async function writePermanentEnv(envVars) {
+  const shellConfig = detectShellConfig();
+
+  if (!shellConfig.detected) {
+    console.error('Error: Unable to detect shell type');
+    console.error('Supported shells: bash, zsh, fish, powershell');
+    console.error(`Current SHELL: ${process.env.SHELL || '(not set)'}`);
+    process.exit(1);
+  }
+
+  const {shell, configPath} = shellConfig;
+  const marker = '# >>> ccconfig >>>';
+  const markerEnd = '# <<< ccconfig <<<';
+
+  // Generate environment variable lines
+  let envBlock = '';
+  switch (shell) {
+    case 'fish':
+      envBlock = `${marker}\n`;
+      for (const [key, value] of Object.entries(envVars)) {
+        envBlock += `set -gx ${key} "${escapeFish(value)}"\n`;
+      }
+      envBlock += `${markerEnd}\n`;
+      break;
+
+    case 'bash':
+    case 'zsh':
+      envBlock = `${marker}\n`;
+      for (const [key, value] of Object.entries(envVars)) {
+        envBlock += `export ${key}=${escapePosix(value)}\n`;
+      }
+      envBlock += `${markerEnd}\n`;
+      break;
+
+    case 'powershell':
+      envBlock = `${marker}\n`;
+      for (const [key, value] of Object.entries(envVars)) {
+        envBlock += `$env:${key}=${escapePwsh(value)}\n`;
+      }
+      envBlock += `${markerEnd}\n`;
+      break;
+  }
+
+  // Display warning and confirmation
+  console.log('');
+  console.log('⚠️  WARNING: This will modify your shell configuration file');
+  console.log('═══════════════════════════════════════════════════════════');
+  console.log('');
+  console.log(`Target file: ${configPath}`);
+  console.log('');
+  console.log('The following block will be added/updated:');
+  console.log('───────────────────────────────────────────');
+  console.log(envBlock.trim());
+  console.log('───────────────────────────────────────────');
+  console.log('');
+  console.log('What this does:');
+  console.log('  • Adds environment variables to your shell startup file');
+  console.log('  • Uses markers to identify ccconfig-managed block');
+  console.log('  • Existing ccconfig block will be replaced if present');
+  console.log('  • Other content in the file will NOT be modified');
+  console.log('');
+  console.log('After this change:');
+  console.log(
+      '  • These environment variables will load automatically on shell startup');
+  console.log('  • You can switch profiles by running this command again');
+  console.log('  • To remove, manually delete the block between the markers');
+  console.log('');
+
+  // Ask for confirmation
+  const isInteractive = process.stdin.isTTY && process.stdout.isTTY;
+
+  if (!isInteractive) {
+    console.error('Error: Cannot run in non-interactive mode');
+    console.error('The --permanent flag requires user confirmation');
+    console.error('Please run this command in an interactive terminal');
+    process.exit(1);
+  }
+
+  const rl =
+      readline.createInterface({input: process.stdin, output: process.stdout});
+
+  const confirmed = await new Promise(resolve => {
+    rl.question('Do you want to proceed? (yes/no): ', answer => {
+      rl.close();
+      const normalized = answer.trim().toLowerCase();
+      resolve(normalized === 'yes' || normalized === 'y');
+    });
+  });
+
+  if (!confirmed) {
+    console.log('');
+    console.log('Operation cancelled.');
+    console.log('');
+    console.log('Alternative: Use temporary mode without --permanent flag:');
+    console.log('  1. Run: ccconfig use <profile>');
+    console.log(
+        '  2. Apply: eval $(ccconfig env bash)  # or equivalent for your shell');
+    return;
+  }
+
+  console.log('');
+
+  try {
+    // Ensure config directory exists
+    ensureDir(path.dirname(configPath));
+
+    // Read existing config file
+    let content = '';
+    if (fs.existsSync(configPath)) {
+      content = fs.readFileSync(configPath, 'utf-8');
+    }
+
+    // Check if ccconfig block already exists
+    const hasBlock = content.includes(marker);
+
+    // Update content
+    if (hasBlock) {
+      // Replace existing block
+      const regex = new RegExp(
+          `${marker.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}[\\s\\S]*?${
+              markerEnd.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\n?`,
+          'g');
+      content = content.replace(regex, envBlock);
+    } else {
+      // Append new block
+      if (content && !content.endsWith('\n')) {
+        content += '\n';
+      }
+      content += '\n' + envBlock;
+    }
+
+    // Write back to config file
+    fs.writeFileSync(configPath, content, 'utf-8');
+
+    console.log(`✓ Environment variables written to ${shell} config file`);
+    console.log(`  Config file: ${configPath}`);
+    console.log('');
+    console.log('To apply immediately, run:');
+    let applyCommand = '';
+    switch (shell) {
+      case 'fish':
+        applyCommand = `source "${escapeFish(configPath)}"`;
+        break;
+      case 'bash':
+      case 'zsh':
+        applyCommand = `source ${escapePosix(configPath)}`;
+        break;
+      case 'powershell':
+        applyCommand = `. ${escapePwsh(configPath)}`;
+        break;
+      default:
+        applyCommand = `source ${configPath}`;
+        break;
+    }
+    console.log(`  ${applyCommand}`);
+    console.log('');
+    console.log('Or restart your shell');
+
+  } catch (error) {
+    console.error('');
+    console.error(
+        `Error: Unable to write to shell config file: ${error.message}`);
+    process.exit(1);
+  }
+}
+
 /**
  * Switch configuration
  */
-function use(name) {
+async function use(name, options = {}) {
   const profiles = loadProfiles();
 
   if (!profiles || !profiles.profiles ||
@@ -540,6 +769,7 @@ function use(name) {
   }
 
   const mode = getMode();
+  const permanent = options.permanent || false;
 
   if (mode === MODE_SETTINGS) {
     // Settings mode: directly modify ~/.claude/settings.json
@@ -555,6 +785,12 @@ function use(name) {
     console.log('');
     console.log('Configuration written to ~/.claude/settings.json');
     console.log('Restart Claude Code to make configuration take effect');
+
+    if (permanent) {
+      console.log('');
+      console.log(
+          'Note: --permanent flag is ignored in settings mode (settings.json is already permanent)');
+    }
   } else {
     // Env mode: write to environment variable file
     writeEnvFile(profile.env);
@@ -568,36 +804,49 @@ function use(name) {
     }
     console.log('');
     console.log(`Environment variable file updated: ${ENV_FILE}`);
-    console.log('');
-    const shellSuggestion = detectShellCommand();
-    const applyCommands = [
-      {command: 'eval $(ccconfig env bash)', note: '# Bash/Zsh'},
-      {command: 'ccconfig env fish | source', note: '# Fish'},
-      {command: 'ccconfig env pwsh | iex', note: '# PowerShell'}
-    ];
-
-    console.log('Apply immediately in current Shell (optional):');
 
-    if (shellSuggestion.command) {
+    if (permanent) {
+      console.log('');
       console.log(
-          `  ${shellSuggestion.command}  # Detected ${shellSuggestion.shell}`);
-
-      const normalizedSuggestion =
-          shellSuggestion.command.replace(/\s+/g, ' ').trim();
-      for (const item of applyCommands) {
-        const normalizedCommand = item.command.replace(/\s+/g, ' ').trim();
-        if (normalizedCommand === normalizedSuggestion) {
-          item.skip = true;
+          'Writing environment variables permanently to shell config...');
+      console.log('');
+      await writePermanentEnv(profile.env);
+    } else {
+      console.log('');
+      const shellSuggestion = detectShellCommand();
+      const applyCommands = [
+        {command: 'eval $(ccconfig env bash)', note: '# Bash/Zsh'},
+        {command: 'ccconfig env fish | source', note: '# Fish'},
+        {command: 'ccconfig env pwsh | iex', note: '# PowerShell'}
+      ];
+
+      console.log('Apply immediately in current Shell (optional):');
+
+      if (shellSuggestion.command) {
+        console.log(`  ${shellSuggestion.command}  # Detected ${
+            shellSuggestion.shell}`);
+
+        const normalizedSuggestion =
+            shellSuggestion.command.replace(/\s+/g, ' ').trim();
+        for (const item of applyCommands) {
+          const normalizedCommand = item.command.replace(/\s+/g, ' ').trim();
+          if (normalizedCommand === normalizedSuggestion) {
+            item.skip = true;
+          }
         }
       }
-    }
 
-    for (const item of applyCommands) {
-      if (item.skip) continue;
-      console.log(`  ${item.command} ${item.note}`);
+      for (const item of applyCommands) {
+        if (item.skip) continue;
+        console.log(`  ${item.command} ${item.note}`);
+      }
+      console.log('');
+      console.log('Or restart Shell to auto-load');
+      console.log('');
+      console.log(
+          'Tip: Use -p/--permanent flag to write directly to shell config:');
+      console.log(`  ccconfig use ${name} --permanent`);
     }
-    console.log('');
-    console.log('Or restart Shell to auto-load');
   }
 }
 
@@ -690,7 +939,7 @@ function current(showSecret = false) {
   console.log('  • ENV mode: Claude Code reads from 【3】(loaded from 【2】)');
   if (!showSecret) {
     console.log('');
-    console.log('Use --show-secret to display full token');
+    console.log('Use -s/--show-secret to display full token');
   }
   console.log('═══════════════════════════════════════════');
 }
@@ -726,13 +975,26 @@ function mode(newMode) {
     if (currentMode === MODE_SETTINGS) {
       console.log('SETTINGS mode:');
       console.log('  - Directly modify ~/.claude/settings.json');
+      console.log(
+          '  - Writes environment variables into settings.json env field');
       console.log('  - No Shell configuration needed');
       console.log('  - Restart Claude Code to take effect');
+      console.log('');
+      console.log('  How it works:');
+      console.log('    1. Run: ccconfig use <profile>');
+      console.log('    2. Settings written to ~/.claude/settings.json');
+      console.log('    3. Restart Claude Code to apply changes');
     } else {
-      console.log('ENV mode:');
+      console.log('ENV mode (default):');
       console.log('  - Use environment variable files');
       console.log('  - Need to configure Shell loading script');
       console.log('  - Cross-Shell configuration sharing');
+      console.log('  - No restart needed (instant apply)');
+      console.log('');
+      console.log('  How it works:');
+      console.log('    1. Run: ccconfig use <profile>');
+      console.log('    2. Writes to ~/.config/ccconfig/current.env');
+      console.log('    3. Shell loads on startup or eval command');
     }
     console.log('');
     console.log('Switch modes:');
@@ -782,23 +1044,20 @@ function env(format = 'bash') {
   switch (format) {
     case 'fish':
       for (const [key, value] of Object.entries(envVars)) {
-        const renderedValue = value == null ? '' : String(value);
-        console.log(`set -gx ${key} "${renderedValue}"`);
+        console.log(`set -gx ${key} "${escapeFish(value)}"`);
       }
       break;
     case 'bash':
     case 'zsh':
     case 'sh':
       for (const [key, value] of Object.entries(envVars)) {
-        const renderedValue = value == null ? '' : String(value);
-        console.log(`export ${key}="${renderedValue}"`);
+        console.log(`export ${key}=${escapePosix(value)}`);
       }
       break;
     case 'powershell':
     case 'pwsh':
       for (const [key, value] of Object.entries(envVars)) {
-        const renderedValue = value == null ? '' : String(value);
-        console.log(`$env:${key}="${renderedValue}"`);
+        console.log(`$env:${key}=${escapePwsh(value)}`);
       }
       break;
     case 'dotenv':
@@ -834,9 +1093,9 @@ function help() {
   console.log('');
   console.log('Global Options:');
   console.log(
-      '  --help, -h                                Display this help information');
+      '  -h, --help                                Display this help information');
   console.log(
-      '  --version, -V                             Display version information');
+      '  -V, --version                             Display version information');
   console.log('');
   console.log('Commands:');
   console.log(
@@ -844,11 +1103,11 @@ function help() {
   console.log(
       '  add [name]                                Add new configuration (interactive)');
   console.log(
-      '  use <name>                                Switch to specified configuration');
+      '  use <name> [-p|--permanent]               Switch to specified configuration');
   console.log(
       '  remove|rm <name>                          Remove configuration');
   console.log(
-      '  current [--show-secret]                   Display current configuration');
+      '  current [-s|--show-secret]                Display current configuration');
   console.log(
       '  mode [settings|env]                       View or switch mode');
   console.log(
@@ -856,6 +1115,14 @@ function help() {
   console.log(
       '  edit                                      Show configuration file location');
   console.log('');
+  console.log('Flags:');
+  console.log(
+      '  -p, --permanent                           Write environment variables permanently to shell config');
+  console.log(
+      '                                            (only effective in env mode with use command)');
+  console.log(
+      '  -s, --show-secret                         Show full token in current command');
+  console.log('');
   console.log('Configuration file locations:');
   console.log(`  Configuration list: ${PROFILES_FILE}`);
   console.log(`  Claude settings: ${CLAUDE_SETTINGS}`);
@@ -878,9 +1145,11 @@ async function main() {
   }
 
   // Extract flags
-  const showSecret = args.includes('--show-secret');
+  const showSecret = args.includes('--show-secret') || args.includes('-s');
+  const permanent = args.includes('--permanent') || args.includes('-p');
   const filteredArgs = args.filter(
-      arg => arg !== '--show-secret' && arg !== '--version' && arg !== '-V' &&
+      arg => arg !== '--show-secret' && arg !== '-s' && arg !== '--permanent' &&
+          arg !== '-p' && arg !== '--version' && arg !== '-V' &&
           arg !== '--help' && arg !== '-h');
 
   const command = filteredArgs[0];
@@ -893,10 +1162,10 @@ async function main() {
     case 'use':
       if (!filteredArgs[1]) {
         console.error('Error: Missing configuration name');
-        console.error('Usage: ccconfig use <name>');
+        console.error('Usage: ccconfig use <name> [-p|--permanent]');
         process.exit(1);
       }
-      use(filteredArgs[1]);
+      await use(filteredArgs[1], {permanent});
       break;
     case 'add':
       await add(filteredArgs[1]);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ccconfig",
-  "version": "1.0.0",
+  "version": "1.2.0",
   "description": "Cross-platform Claude Code configuration switching tool",
   "main": "ccconfig.js",
   "bin": {
@@ -20,4 +20,4 @@
   "engines": {
     "node": ">=18.0.0"
   }
-}
+}