@adithya-13/cc-switch 1.0.0

package/README.md

@@ -0,0 +1,88 @@
+# cc-switch
+
+> Switch Claude Code between providers instantly. No manual config editing.
+
+```bash
+cc-switch use zai        # → z.ai (GLM-4.7)
+cc-switch use pro        # → Claude Pro/Max
+cc-switch use kimi       # → Kimi K2
+cc-switch use openrouter # → OpenRouter (320+ models)
+```
+
+## Install
+
+```bash
+npm install -g cc-switch
+```
+
+Or via curl:
+
+```bash
+curl -fsSL https://raw.githubusercontent.com/adithya-13/cc-switch/main/install.sh | bash
+```
+
+## Why
+
+Claude Code's usage limits hit mid-session. Switching providers manually means editing `~/.claude/settings.json`, managing API keys, and restarting. `cc-switch` makes it one command.
+
+## Supported Providers
+
+| Provider | Command | Models |
+|---|---|---|
+| Claude Pro/Max | `cc-switch use pro` | Claude Sonnet/Opus (OAuth) |
+| z.ai | `cc-switch use zai` | GLM-4.7, GLM-5 |
+| Kimi (Moonshot) | `cc-switch use kimi` | Kimi K2.5 |
+| OpenRouter | `cc-switch use openrouter` | 320+ models |
+| DeepSeek | `cc-switch use deepseek` | DeepSeek V3, R1 |
+| Qwen (Alibaba) | `cc-switch use qwen` | Qwen3.5 |
+| Ollama (local) | `cc-switch use ollama` | Any local model |
+| Custom | `cc-switch add myprofile` | Anything |
+
+## Commands
+
+```bash
+cc-switch use <provider>   # switch to provider
+cc-switch list             # list all providers + key status
+cc-switch status           # show current active provider
+cc-switch add <name>       # add a custom provider
+cc-switch doctor           # check setup and saved keys
+```
+
+## Rate Limit Detection (cclaude)
+
+Instead of `claude`, use `cclaude` — it wraps Claude Code and notifies you when a rate limit is hit, with quick-switch suggestions:
+
+```bash
+cclaude   # same as claude, but with rate limit detection
+```
+
+When a limit is hit:
+
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+  ⚠  Claude usage limit reached
+
+  Available fallbacks:
+
+  → z.ai (GLM)             cc-switch use zai
+  → Kimi K2                cc-switch use kimi
+
+  Quick switch: cc-switch use zai
+  Then restart: cclaude
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+```
+
+## Key Storage
+
+API keys are saved in `~/.cc-switch/keys.json` (chmod 600). Never hardcoded or exposed.
+
+## Add Custom Provider
+
+```bash
+cc-switch add myprovider
+# interactive wizard → asks for base URL, API key, model names
+```
+
+## License
+
+MIT

package/bin/cc-switch.js

@@ -0,0 +1,73 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+import chalk from "chalk";
+import { useCommand } from "../src/commands/use.js";
+import { listCommand } from "../src/commands/list.js";
+import { statusCommand } from "../src/commands/status.js";
+import { addCommand } from "../src/commands/add.js";
+import { doctorCommand } from "../src/commands/doctor.js";
+import { readSettings, getCurrentProvider } from "../src/settings.js";
+import { PRESETS } from "../src/presets.js";
+import { loadProfiles } from "../src/profiles.js";
+
+const program = new Command();
+
+program
+  .name("cc-switch")
+  .description("Switch Claude Code between providers")
+  .version("1.0.0");
+
+program
+  .command("use <provider>")
+  .description("Switch to a provider (pro, zai, kimi, openrouter, deepseek, qwen, ollama)")
+  .action(async (provider) => {
+    await useCommand(provider);
+  });
+
+program
+  .command("list")
+  .alias("ls")
+  .description("List all providers and their status")
+  .action(() => listCommand());
+
+program
+  .command("status")
+  .description("Show current active provider")
+  .action(() => statusCommand());
+
+program
+  .command("add <name>")
+  .description("Add a custom provider profile")
+  .action(async (name) => {
+    await addCommand(name);
+  });
+
+program
+  .command("doctor")
+  .description("Check setup and saved keys")
+  .action(async () => {
+    await doctorCommand();
+  });
+
+// default: no args → show status + hint
+program.action(() => {
+  try {
+    const settings = readSettings();
+    const current = getCurrentProvider(settings);
+    const customProfiles = loadProfiles();
+    const preset = PRESETS[current] || customProfiles[current];
+    const name = preset?.name || current;
+
+    console.log(`\n  ${chalk.bold("cc-switch")} — Claude Code provider switcher`);
+    console.log(`  Active: ${chalk.green.bold(name)}\n`);
+    console.log(`  ${chalk.gray("cc-switch list")}          list all providers`);
+    console.log(`  ${chalk.gray("cc-switch use <name>")}    switch provider`);
+    console.log(`  ${chalk.gray("cc-switch status")}        show current`);
+    console.log(`  ${chalk.gray("cc-switch add <name>")}    add custom provider`);
+    console.log(`  ${chalk.gray("cc-switch doctor")}        check setup\n`);
+  } catch {
+    program.help();
+  }
+});
+
+program.parse();

package/bin/cclaude.js

@@ -0,0 +1,77 @@
+#!/usr/bin/env node
+import { spawn } from "child_process";
+import chalk from "chalk";
+import { readSettings, getCurrentProvider } from "../src/settings.js";
+import { PRESETS } from "../src/presets.js";
+import { loadKeys, loadProfiles } from "../src/profiles.js";
+
+const RATE_LIMIT_PATTERNS = [
+  /usage limit reached/i,
+  /rate limit/i,
+  /Claude\.ai usage limit/i,
+  /exceeded.*limit/i,
+  /quota exceeded/i,
+];
+
+function getAvailableFallbacks(current) {
+  const keys = loadKeys();
+  const customProfiles = loadProfiles();
+  const allProviders = { ...PRESETS, ...customProfiles };
+
+  return Object.entries(allProviders)
+    .filter(([name, preset]) => {
+      if (name === current) return false;
+      if (preset.requiresKey === false) return true; // pro (OAuth) always "available"
+      return !!keys[name]; // only if key is saved
+    })
+    .map(([name, preset]) => ({ name, label: preset.name || name }));
+}
+
+function notifyRateLimit(current, fallbacks) {
+  console.error("\n" + chalk.yellow("━".repeat(50)));
+  console.error(chalk.yellow.bold("  ⚠  Claude usage limit reached"));
+  console.error(chalk.yellow("━".repeat(50)));
+
+  if (fallbacks.length === 0) {
+    console.error(chalk.gray("\n  No saved fallback providers."));
+    console.error(chalk.gray(`  Add one: ${chalk.cyan("cc-switch add <provider>")}\n`));
+    return;
+  }
+
+  console.error(chalk.bold("\n  Available fallbacks:\n"));
+  fallbacks.forEach(({ name, label }) => {
+    console.error(`  ${chalk.cyan("→")} ${label.padEnd(20)} ${chalk.gray(`cc-switch use ${name}`)}`);
+  });
+
+  const top = fallbacks[0];
+  console.error(
+    `\n  ${chalk.bold("Quick switch:")} ${chalk.cyan(`cc-switch use ${top.name}`)}\n` +
+    `  Then restart: ${chalk.cyan("cclaude")}\n`
+  );
+  console.error(chalk.yellow("━".repeat(50)) + "\n");
+}
+
+// run claude, intercept output for rate limit signals
+const settings = readSettings();
+const current = getCurrentProvider(settings);
+
+const child = spawn("claude", process.argv.slice(2), {
+  stdio: ["inherit", "inherit", "pipe"], // intercept stderr
+});
+
+let stderrBuffer = "";
+
+child.stderr.on("data", (data) => {
+  const text = data.toString();
+  stderrBuffer += text;
+  process.stderr.write(data); // still show to user
+
+  const isRateLimit = RATE_LIMIT_PATTERNS.some((p) => p.test(stderrBuffer));
+  if (isRateLimit) {
+    const fallbacks = getAvailableFallbacks(current);
+    notifyRateLimit(current, fallbacks);
+    stderrBuffer = ""; // reset to avoid re-triggering
+  }
+});
+
+child.on("exit", (code) => process.exit(code ?? 0));

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@adithya-13/cc-switch",
+  "version": "1.0.0",
+  "description": "Switch Claude Code between providers (Claude Pro, z.ai, Kimi, OpenRouter, DeepSeek, and more)",
+  "keywords": [
+    "claude",
+    "claude-code",
+    "anthropic",
+    "zai",
+    "openrouter",
+    "kimi",
+    "provider",
+    "switch"
+  ],
+  "author": "adithya-13",
+  "license": "MIT",
+  "homepage": "https://github.com/adithya-13/cc-switch#readme",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/adithya-13/cc-switch.git"
+  },
+  "type": "module",
+  "bin": {
+    "cc-switch": "./bin/cc-switch.js",
+    "cclaude": "./bin/cclaude.js"
+  },
+  "files": [
+    "bin",
+    "src",
+    "install.sh",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "chalk": "^5.3.0",
+    "commander": "^12.0.0",
+    "inquirer": "^9.2.0"
+  }
+}

package/src/commands/add.js

@@ -0,0 +1,68 @@
+import chalk from 'chalk'
+import inquirer from 'inquirer'
+import { saveProfile, saveKey } from '../profiles.js'
+
+export async function addCommand(name) {
+  console.log(chalk.bold(`\nAdding custom provider: ${name}\n`))
+
+  const answers = await inquirer.prompt([
+    {
+      type: 'input',
+      name: 'displayName',
+      message: 'Display name:',
+      default: name,
+    },
+    {
+      type: 'input',
+      name: 'baseUrl',
+      message: 'Base URL (e.g. https://api.example.com):',
+      validate: (v) => v.startsWith('http') || 'Must start with http',
+    },
+    {
+      type: 'password',
+      name: 'key',
+      message: 'API key (leave blank if not required):',
+    },
+    {
+      type: 'input',
+      name: 'sonnetModel',
+      message: 'Default sonnet model (blank to skip):',
+      default: '',
+    },
+    {
+      type: 'input',
+      name: 'haikusModel',
+      message: 'Default haiku model (blank to skip):',
+      default: '',
+    },
+    {
+      type: 'input',
+      name: 'opusModel',
+      message: 'Default opus model (blank to skip):',
+      default: '',
+    },
+  ])
+
+  const env = {
+    ANTHROPIC_BASE_URL: answers.baseUrl,
+    API_TIMEOUT_MS: '600000',
+  }
+  if (answers.sonnetModel) env.ANTHROPIC_DEFAULT_SONNET_MODEL = answers.sonnetModel
+  if (answers.haikusModel) env.ANTHROPIC_DEFAULT_HAIKU_MODEL = answers.haikusModel
+  if (answers.opusModel) env.ANTHROPIC_DEFAULT_OPUS_MODEL = answers.opusModel
+
+  const profile = {
+    name: answers.displayName,
+    description: `Custom: ${answers.baseUrl}`,
+    baseUrl: answers.baseUrl,
+    env,
+    requiresKey: !!answers.key,
+    keyEnv: answers.key ? 'ANTHROPIC_AUTH_TOKEN' : undefined,
+  }
+
+  saveProfile(name, profile)
+  if (answers.key) saveKey(name, answers.key)
+
+  console.log(chalk.green(`\n✓ Added ${answers.displayName}`))
+  console.log(chalk.gray(`  Switch: cc-switch use ${name}\n`))
+}

package/src/commands/doctor.js

@@ -0,0 +1,38 @@
+import chalk from 'chalk'
+import { existsSync } from 'fs'
+import { homedir } from 'os'
+import { join } from 'path'
+import { PRESETS } from '../presets.js'
+import { loadKeys, loadProfiles } from '../profiles.js'
+import { readSettings, getCurrentProvider } from '../settings.js'
+import { maskKey } from '../utils.js'
+
+export function doctorCommand() {
+  const settingsPath = join(homedir(), '.claude', 'settings.json')
+  const keysPath = join(homedir(), '.cc-switch', 'keys.json')
+
+  console.log(chalk.bold('\n  cc-switch doctor\n'))
+
+  const settingsOk = existsSync(settingsPath)
+  console.log(`  ${settingsOk ? chalk.green('✓') : chalk.red('✗')} ~/.claude/settings.json`)
+
+  const settings = readSettings()
+  const current = getCurrentProvider(settings)
+  const all = { ...PRESETS, ...loadProfiles() }
+  console.log(`  ${chalk.green('●')} Active: ${chalk.bold(all[current]?.name || current)}`)
+
+  const keys = loadKeys()
+  const keysExist = existsSync(keysPath)
+  console.log(`  ${keysExist ? chalk.green('✓') : chalk.gray('○')} ~/.cc-switch/keys.json`)
+
+  console.log(`\n  Saved keys:`)
+  const needsKey = Object.entries(all).filter(([, p]) => p.requiresKey !== false)
+  for (const [name, preset] of needsKey) {
+    const key = keys[name]
+    const status = key ? chalk.green(`saved (${maskKey(key)})`) : chalk.gray('not saved')
+    const icon = key ? chalk.green('✓') : chalk.gray('○')
+    console.log(`  ${icon} ${(preset.name || name).padEnd(22)} ${status}`)
+  }
+
+  console.log(`\n  ${chalk.green('✓')} Node.js ${process.version}\n`)
+}

package/src/commands/list.js

@@ -0,0 +1,29 @@
+import chalk from 'chalk'
+import { PRESETS } from '../presets.js'
+import { loadProfiles, loadKeys } from '../profiles.js'
+import { readSettings, getCurrentProvider } from '../settings.js'
+
+export function listCommand() {
+  const settings = readSettings()
+  const current = getCurrentProvider(settings)
+  const customProfiles = loadProfiles()
+  const keys = loadKeys()
+  const all = { ...PRESETS, ...customProfiles }
+
+  console.log()
+  for (const [name, preset] of Object.entries(all)) {
+    const isActive = name === current
+    const hasKey = preset.requiresKey === false || !!keys[name]
+    const marker = isActive ? chalk.green('●') : chalk.gray('○')
+    const label = isActive ? chalk.green.bold(preset.name) : chalk.white(preset.name)
+    const keyStatus = preset.requiresKey === false
+      ? chalk.gray('OAuth')
+      : hasKey ? chalk.green('key ✓') : chalk.yellow('no key')
+
+    console.log(`  ${marker} ${label.padEnd(isActive ? 33 : 25)} ${keyStatus}`)
+    if (preset.description) {
+      console.log(`    ${chalk.gray(preset.description)}`)
+    }
+  }
+  console.log()
+}

package/src/commands/status.js

@@ -0,0 +1,19 @@
+import chalk from 'chalk'
+import { PRESETS } from '../presets.js'
+import { loadProfiles } from '../profiles.js'
+import { readSettings, getCurrentProvider } from '../settings.js'
+
+export function statusCommand() {
+  const settings = readSettings()
+  const current = getCurrentProvider(settings)
+  const all = { ...PRESETS, ...loadProfiles() }
+  const preset = all[current]
+
+  console.log()
+  console.log(`  Active: ${chalk.green.bold(preset?.name || current)}`)
+  if (preset?.description) console.log(`  ${chalk.gray(preset.description)}`)
+  if (settings.env?.ANTHROPIC_BASE_URL) {
+    console.log(`  URL:    ${chalk.gray(settings.env.ANTHROPIC_BASE_URL)}`)
+  }
+  console.log()
+}

package/src/commands/use.js

@@ -0,0 +1,47 @@
+import chalk from 'chalk'
+import inquirer from 'inquirer'
+import { PRESETS } from '../presets.js'
+import { loadProfiles, loadKeys, saveKey } from '../profiles.js'
+import { readSettings, writeSettings } from '../settings.js'
+
+export async function useCommand(provider) {
+  const allProviders = { ...PRESETS, ...loadProfiles() }
+  const preset = allProviders[provider]
+
+  if (!preset) {
+    console.log(chalk.red(`Unknown provider: ${provider}`))
+    console.log(chalk.gray('Run: cc-switch list'))
+    process.exit(1)
+  }
+
+  let key = null
+  if (preset.requiresKey) {
+    const keys = loadKeys()
+    if (keys[provider]) {
+      key = keys[provider]
+    } else {
+      const { key: input } = await inquirer.prompt([{
+        type: 'password',
+        name: 'key',
+        message: `API key for ${preset.name}? (${preset.keyHint})`,
+        validate: (v) => v.length > 0 || 'Key required',
+      }])
+      key = input
+      saveKey(provider, key)
+    }
+  }
+
+  const settings = readSettings()
+
+  if (preset.env === null) {
+    delete settings.env
+  } else {
+    const env = { ...preset.env }
+    if (key && preset.keyEnv) env[preset.keyEnv] = key
+    settings.env = env
+  }
+
+  writeSettings(settings)
+  console.log(chalk.green(`✓ Switched to ${preset.name}`))
+  console.log(chalk.gray('Restart Claude Code to apply'))
+}

package/src/presets.js

@@ -0,0 +1,100 @@
+// Built-in provider presets
+// env: null means "no env block" (use Claude OAuth)
+
+export const PRESETS = {
+  pro: {
+    name: "Claude Pro/Max",
+    description: "Claude subscription (Pro, Max, Team)",
+    env: null, // removes env block, falls back to OAuth
+    requiresKey: false,
+  },
+  zai: {
+    name: "z.ai (GLM)",
+    description: "Z.AI GLM-4.7 / GLM-5 — 3x value vs Pro",
+    baseUrl: "https://api.z.ai/api/anthropic",
+    env: {
+      ANTHROPIC_BASE_URL: "https://api.z.ai/api/anthropic",
+      API_TIMEOUT_MS: "3000000",
+      ANTHROPIC_DEFAULT_HAIKU_MODEL: "glm-4.5-air",
+      ANTHROPIC_DEFAULT_SONNET_MODEL: "glm-4.7",
+      ANTHROPIC_DEFAULT_OPUS_MODEL: "glm-4.7",
+    },
+    requiresKey: true,
+    keyEnv: "ANTHROPIC_AUTH_TOKEN",
+    keyHint: "Get key at: z.ai/manage-apikey/apikey-list",
+  },
+  kimi: {
+    name: "Kimi K2 (Moonshot)",
+    description: "Kimi K2.5 — vision support, fast inference",
+    baseUrl: "https://api.moonshot.ai/anthropic",
+    env: {
+      ANTHROPIC_BASE_URL: "https://api.moonshot.ai/anthropic",
+      API_TIMEOUT_MS: "600000",
+      ANTHROPIC_DEFAULT_SONNET_MODEL: "kimi-k2.5",
+      ANTHROPIC_DEFAULT_HAIKU_MODEL: "kimi-k2",
+      ANTHROPIC_DEFAULT_OPUS_MODEL: "kimi-k2.5",
+    },
+    requiresKey: true,
+    keyEnv: "ANTHROPIC_AUTH_TOKEN",
+    keyHint: "Get key at: platform.moonshot.ai",
+  },
+  openrouter: {
+    name: "OpenRouter",
+    description: "320+ models via one API",
+    baseUrl: "https://openrouter.ai/api",
+    env: {
+      ANTHROPIC_BASE_URL: "https://openrouter.ai/api",
+      ANTHROPIC_API_KEY: "",
+      API_TIMEOUT_MS: "600000",
+    },
+    requiresKey: true,
+    keyEnv: "ANTHROPIC_AUTH_TOKEN",
+    keyHint: "Get key at: openrouter.ai/keys",
+  },
+  deepseek: {
+    name: "DeepSeek",
+    description: "DeepSeek V3 — cheapest reasoning model",
+    baseUrl: "https://api.deepseek.com",
+    env: {
+      ANTHROPIC_BASE_URL: "https://api.deepseek.com",
+      API_TIMEOUT_MS: "600000",
+      ANTHROPIC_DEFAULT_SONNET_MODEL: "deepseek-chat",
+      ANTHROPIC_DEFAULT_HAIKU_MODEL: "deepseek-chat",
+      ANTHROPIC_DEFAULT_OPUS_MODEL: "deepseek-reasoner",
+    },
+    requiresKey: true,
+    keyEnv: "ANTHROPIC_AUTH_TOKEN",
+    keyHint: "Get key at: platform.deepseek.com",
+  },
+  qwen: {
+    name: "Qwen (Alibaba)",
+    description: "Qwen3.5 — strong coding, 256K context",
+    baseUrl: "https://dashscope-intl.aliyuncs.com/apps/anthropic",
+    env: {
+      ANTHROPIC_BASE_URL: "https://dashscope-intl.aliyuncs.com/apps/anthropic",
+      API_TIMEOUT_MS: "600000",
+      ANTHROPIC_DEFAULT_SONNET_MODEL: "qwen3.5-plus",
+      ANTHROPIC_DEFAULT_HAIKU_MODEL: "qwen3.5-coder",
+      ANTHROPIC_DEFAULT_OPUS_MODEL: "qwen3.5-plus",
+    },
+    requiresKey: true,
+    keyEnv: "ANTHROPIC_AUTH_TOKEN",
+    keyHint: "Get key at: dashscope.aliyuncs.com",
+  },
+  ollama: {
+    name: "Ollama (Local)",
+    description: "Local models — private, free, offline",
+    baseUrl: "http://localhost:11434/api",
+    env: {
+      ANTHROPIC_BASE_URL: "http://localhost:11434/api",
+      API_TIMEOUT_MS: "600000",
+      ANTHROPIC_DEFAULT_SONNET_MODEL: "qwen2.5-coder:latest",
+      ANTHROPIC_DEFAULT_HAIKU_MODEL: "qwen2.5-coder:latest",
+      ANTHROPIC_DEFAULT_OPUS_MODEL: "qwen2.5-coder:latest",
+    },
+    requiresKey: false,
+    keyHint: "Install Ollama at: ollama.ai",
+  },
+};
+
+export const PRESET_NAMES = Object.keys(PRESETS);

package/src/profiles.js

@@ -0,0 +1,36 @@
+import { readFileSync, writeFileSync, mkdirSync, existsSync, chmodSync } from 'fs'
+import { homedir } from 'os'
+import { join } from 'path'
+
+const DIR = join(homedir(), '.cc-switch')
+const KEYS_PATH = join(DIR, 'keys.json')
+const PROFILES_PATH = join(DIR, 'profiles.json')
+
+function ensureDir() {
+  if (!existsSync(DIR)) mkdirSync(DIR, { recursive: true })
+}
+
+export function loadKeys() {
+  if (!existsSync(KEYS_PATH)) return {}
+  return JSON.parse(readFileSync(KEYS_PATH, 'utf8'))
+}
+
+export function saveKey(name, key) {
+  ensureDir()
+  const keys = loadKeys()
+  keys[name] = key
+  writeFileSync(KEYS_PATH, JSON.stringify(keys, null, 2))
+  chmodSync(KEYS_PATH, 0o600)
+}
+
+export function loadProfiles() {
+  if (!existsSync(PROFILES_PATH)) return {}
+  return JSON.parse(readFileSync(PROFILES_PATH, 'utf8'))
+}
+
+export function saveProfile(name, profile) {
+  ensureDir()
+  const profiles = loadProfiles()
+  profiles[name] = profile
+  writeFileSync(PROFILES_PATH, JSON.stringify(profiles, null, 2))
+}

package/src/settings.js

@@ -0,0 +1,31 @@
+import { readFileSync, writeFileSync, copyFileSync, existsSync, renameSync } from 'fs'
+import { homedir } from 'os'
+import { join } from 'path'
+import { PRESETS } from './presets.js'
+
+const SETTINGS_PATH = join(homedir(), '.claude', 'settings.json')
+
+export function readSettings() {
+  if (!existsSync(SETTINGS_PATH)) return {}
+  return JSON.parse(readFileSync(SETTINGS_PATH, 'utf8'))
+}
+
+export function writeSettings(settings) {
+  if (existsSync(SETTINGS_PATH)) {
+    copyFileSync(SETTINGS_PATH, SETTINGS_PATH + '.bak')
+  }
+  const tmp = SETTINGS_PATH + '.tmp'
+  writeFileSync(tmp, JSON.stringify(settings, null, 2) + '\n')
+  renameSync(tmp, SETTINGS_PATH)
+}
+
+export function getCurrentProvider(settings) {
+  const env = settings?.env
+  if (!env || Object.keys(env).length === 0) return 'pro'
+  const baseUrl = env.ANTHROPIC_BASE_URL
+  if (!baseUrl) return 'pro'
+  for (const [name, preset] of Object.entries(PRESETS)) {
+    if (preset.baseUrl && baseUrl === preset.baseUrl) return name
+  }
+  return 'unknown'
+}

package/src/utils.js

@@ -0,0 +1,15 @@
+import chalk from 'chalk'
+
+export function maskKey(key) {
+  if (!key || key.length < 8) return '***'
+  return key.slice(0, 4) + '...' + key.slice(-4)
+}
+
+export const icons = {
+  ok: chalk.green('✓'),
+  warn: chalk.yellow('⚠'),
+  error: chalk.red('✗'),
+  arrow: chalk.cyan('→'),
+  active: chalk.green('●'),
+  inactive: chalk.gray('○'),
+}