cc-hub-cli 1.0.4 → 1.0.7

package/README.md

@@ -11,9 +11,12 @@ npm install -g cc-hub-cli
 ## Quick Start
 
 ```bash
-# Add a profile
+# Add a profile with single model
 cc-hub profile add flow -m anthropic.claude-4-6-sonnet -t eyJ... -u https://example.com/api
 
+# Add a profile with multiple models
+cc-hub profile add multi -m kimi-k2.5 -m claude-sonnet-4-6 -m gpt-4 -t eyJ... -u https://api.example.com
+
 # Set as default
 cc-hub profile default flow
 
@@ -32,7 +35,10 @@ Manage multiple Claude API configurations (model, token, URL).
 
 ```bash
 cc-hub profile add <name> -m <model> -t <token> -u <url>   # Add or update
+cc-hub profile add <name> -m <m1> -m <m2> -t <token>       # Add with multiple models
 cc-hub profile update <name> -m <model>                      # Update fields
+cc-hub profile update <name> -m <m1> -m <m2>                 # Update with multiple models
+cc-hub profile remove-model <name> -m <model>                # Remove specific models
 cc-hub profile list                                          # List all (tokens masked)
 cc-hub profile view <name>                                   # View details (token visible)
 cc-hub profile view <name> -j                                # View as JSON
@@ -40,6 +46,24 @@ cc-hub profile remove <name>                                 # Remove
 cc-hub profile default <name>                                # Set default
 ```
 
+**Multi-Model Profiles:**
+
+You can specify multiple models per profile using the `-m` flag multiple times:
+
+```bash
+# Add a profile with multiple models
+cc-hub profile add myprofile -m kimi-k2.5 -m claude-sonnet-4-6 -t <token> -u <url>
+
+# Remove specific models
+cc-hub profile remove-model myprofile -m kimi-k2.5
+```
+
+When you launch Claude Code with `cc-hub run`, the models are automatically populated into Claude Code's `/model` picker via the `availableModels` setting in `~/.claude/settings.json`. The first model is used as the default.
+
+**Non-Anthropic Models:**
+
+If your profile includes non-Anthropic models (e.g., `kimi-k2.5`, `gpt-4`), the first such model is also exposed via the `ANTHROPIC_CUSTOM_MODEL_OPTION` environment variable, which adds it as a named entry in the `/model` picker.
+
 ### Run / Use
 
 Launch Claude Code with a profile's credentials injected as environment variables.
@@ -139,6 +163,8 @@ cc-hub reads from these paths (overridable via environment variables):
 
 ### Profile storage format
 
+Single-model profile:
+
 ```json
 {
   "profiles": {
@@ -152,6 +178,44 @@ cc-hub reads from these paths (overridable via environment variables):
 }
 ```
 
+Multi-model profile:
+
+```json
+{
+  "profiles": {
+    "multi": {
+      "model": "kimi-k2.5",
+      "models": ["kimi-k2.5", "claude-sonnet-4-6", "gpt-4"],
+      "token": "eyJ...",
+      "url": "https://api.example.com"
+    }
+  },
+  "default": "multi"
+}
+```
+
+When launching with a multi-model profile, cc-hub automatically configures Claude Code's `availableModels` setting, populating the `/model` picker with all specified models.
+
+## Claude Code Skill
+
+cc-hub includes a Claude Code skill for natural language profile management. The skill is located at `skills/cc-hub/SKILL.md`.
+
+**Capabilities:**
+- Add/remove models from profiles using natural language
+- List models in a profile
+- Set the default model for a profile
+
+**Examples:**
+
+```
+Add kimi-k2.5 and gpt-4 to my hy profile
+Remove claude-sonnet from the flow profile
+What models are in my hy profile?
+Set the default model for hy to gpt-4
+```
+
+The skill directly reads and writes `~/.claude/profiles.json` to make changes.
+
 ## License
 
 MIT

package/dist/index.js

@@ -1,11 +1,11 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { Command as Command5 } from "commander";
+import { Command as Command6 } from "commander";
 
 // src/profiles.ts
-import { Command } from "commander";
-import { spawnSync } from "child_process";
+import { Command as Command2 } from "commander";
+import { spawnSync, spawn } from "child_process";
 
 // src/config.ts
 import fs from "fs";
@@ -14,6 +14,7 @@ import os from "os";
 var CLAUDE_DIR = process.env.CLAUDE_DIR || path.join(os.homedir(), ".claude");
 var PROFILES_FILE = process.env.CLAUDE_PROFILES_FILE || path.join(CLAUDE_DIR, "profiles.json");
 var SETTINGS_FILE = process.env.CLAUDE_SETTINGS_FILE || path.join(CLAUDE_DIR, "settings.json");
+var CLAUDE_JSON = path.join(os.homedir(), ".claude.json");
 var PROJECTS_DIR = path.join(CLAUDE_DIR, "projects");
 var SESSIONS_DIR = path.join(CLAUDE_DIR, "sessions");
 function ensureFile(filePath, defaultContent) {
@@ -34,6 +35,396 @@ function ensureProfilesFile() {
 function ensureSettingsFile() {
   ensureFile(SETTINGS_FILE, "{}\n");
 }
+function fixJsonFile(filePath, fallback = {}) {
+  if (!fs.existsSync(filePath)) return;
+  const backupPath = path.join(CLAUDE_DIR, path.basename(filePath) + ".backup");
+  const raw = fs.readFileSync(filePath, "utf-8");
+  try {
+    JSON.parse(raw);
+    fs.copyFileSync(filePath, backupPath);
+    return;
+  } catch {
+  }
+  let text = raw.trim();
+  if (text.charCodeAt(0) === 65279) {
+    text = text.slice(1).trim();
+  }
+  text = text.replace(/,\s*$/, "");
+  text = text.replace(/,\s*([}\]])/g, "$1");
+  const lastBrace = Math.max(text.lastIndexOf("}"), text.lastIndexOf("]"));
+  if (lastBrace !== -1 && lastBrace < text.length - 1) {
+    text = text.slice(0, lastBrace + 1);
+  }
+  let openCurly = 0, openSquare = 0;
+  for (const ch of text) {
+    if (ch === "{") openCurly++;
+    else if (ch === "}") openCurly--;
+    else if (ch === "[") openSquare++;
+    else if (ch === "]") openSquare--;
+  }
+  if (openSquare > 0) text += "]".repeat(openSquare);
+  if (openCurly > 0) text += "}".repeat(openCurly);
+  try {
+    JSON.parse(text);
+    fs.writeFileSync(filePath, text + "\n", "utf-8");
+    console.error(`Fixed invalid JSON in ${path.basename(filePath)}.`);
+  } catch {
+    if (fs.existsSync(backupPath)) {
+      fs.copyFileSync(backupPath, filePath);
+      console.error(`Restored ${path.basename(filePath)} from backup.`);
+    } else {
+      writeJson(filePath, fallback);
+      console.error(`Could not fix ${path.basename(filePath)}, no backup found, reset to default.`);
+    }
+  }
+}
+
+// src/provider.ts
+import http from "http";
+import { Command } from "commander";
+function sanitizeToolId(id) {
+  let sanitized = id.replace(/[^a-zA-Z0-9_-]/g, "_");
+  if (!/^[a-zA-Z]/.test(sanitized)) {
+    sanitized = "tc_" + sanitized;
+  }
+  return sanitized;
+}
+function transformAnthropicToOpenAI(body) {
+  const messages = [];
+  if (body.system) {
+    if (typeof body.system === "string") {
+      messages.push({ role: "system", content: body.system });
+    } else if (Array.isArray(body.system)) {
+      const text = body.system.filter((b) => b.type === "text" && b.text).map((b) => b.text).join("\n");
+      if (text) messages.push({ role: "system", content: text });
+    }
+  }
+  for (const msg of body.messages ?? []) {
+    if (typeof msg.content === "string") {
+      messages.push({ role: msg.role, content: msg.content });
+      continue;
+    }
+    if (!Array.isArray(msg.content)) {
+      messages.push({ role: msg.role, content: JSON.stringify(msg.content) });
+      continue;
+    }
+    if (msg.role === "user") {
+      const toolResults = msg.content.filter(
+        (b) => b.type === "tool_result" && b.tool_use_id
+      );
+      for (const tr of toolResults) {
+        messages.push({
+          role: "tool",
+          tool_call_id: sanitizeToolId(tr.tool_use_id),
+          content: typeof tr.content === "string" ? tr.content : Array.isArray(tr.content) ? tr.content.filter((b) => b.type === "text").map((b) => b.text).join("") : JSON.stringify(tr.content)
+        });
+      }
+      const contentParts = msg.content.filter(
+        (b) => b.type === "text" && b.text || b.type === "image" && b.source
+      );
+      if (contentParts.length > 0) {
+        const converted = contentParts.map((part) => {
+          if (part.type === "image") {
+            const url = part.source?.type === "base64" ? `data:${part.source.media_type};base64,${part.source.data}` : part.source?.url ?? "";
+            return { type: "image_url", image_url: { url } };
+          }
+          return { type: "text", text: part.text };
+        });
+        if (converted.every((p) => p.type === "text")) {
+          messages.push({
+            role: "user",
+            content: converted.map((p) => p.text).join("")
+          });
+        } else {
+          messages.push({ role: "user", content: converted });
+        }
+      }
+    } else if (msg.role === "assistant") {
+      const assistantMsg = { role: "assistant", content: null };
+      const textParts = msg.content.filter(
+        (b) => b.type === "text" && b.text
+      );
+      if (textParts.length > 0) {
+        assistantMsg.content = textParts.map((b) => b.text).join("\n");
+      }
+      const toolUseParts = msg.content.filter(
+        (b) => b.type === "tool_use" && b.id
+      );
+      if (toolUseParts.length > 0) {
+        assistantMsg.tool_calls = toolUseParts.map((b) => ({
+          id: sanitizeToolId(b.id),
+          type: "function",
+          function: {
+            name: b.name,
+            arguments: JSON.stringify(b.input ?? {})
+          }
+        }));
+      }
+      messages.push(assistantMsg);
+    }
+  }
+  const result = {
+    model: body.model,
+    messages,
+    stream: body.stream ?? false
+  };
+  if (body.max_tokens != null) result.max_tokens = body.max_tokens;
+  if (body.temperature != null) result.temperature = body.temperature;
+  if (body.tools?.length) {
+    result.tools = body.tools.map((t) => ({
+      type: "function",
+      function: {
+        name: t.name,
+        description: t.description ?? "",
+        parameters: t.input_schema
+      }
+    }));
+    if (body.tool_choice) {
+      const tc = body.tool_choice;
+      if (tc.type === "auto" || tc.type === "none" || tc.type === "required") {
+        result.tool_choice = tc.type;
+      } else if (tc.type === "tool") {
+        result.tool_choice = {
+          type: "function",
+          function: { name: tc.name }
+        };
+      }
+    }
+  }
+  return result;
+}
+function transformOpenAIResponseToAnthropic(openaiResponse, originalModel) {
+  const choice = openaiResponse.choices?.[0];
+  if (!choice) throw new Error("No choices in OpenAI response");
+  const content = [];
+  if (choice.message?.content) {
+    content.push({ type: "text", text: choice.message.content });
+  }
+  if (choice.message?.tool_calls?.length) {
+    for (const tc of choice.message.tool_calls) {
+      let input = {};
+      try {
+        input = typeof tc.function.arguments === "string" ? JSON.parse(tc.function.arguments) : tc.function.arguments;
+      } catch {
+        input = { text: tc.function.arguments ?? "" };
+      }
+      content.push({
+        type: "tool_use",
+        id: tc.id,
+        name: tc.function.name,
+        input
+      });
+    }
+  }
+  const finishMap = {
+    stop: "end_turn",
+    length: "max_tokens",
+    tool_calls: "tool_use",
+    content_filter: "stop_sequence"
+  };
+  return {
+    id: openaiResponse.id ?? `msg_${Date.now()}`,
+    type: "message",
+    role: "assistant",
+    model: openaiResponse.model ?? originalModel,
+    content,
+    stop_reason: finishMap[choice.finish_reason] ?? "end_turn",
+    stop_sequence: null,
+    usage: {
+      input_tokens: (openaiResponse.usage?.prompt_tokens ?? 0) - (openaiResponse.usage?.prompt_tokens_details?.cached_tokens ?? 0),
+      output_tokens: openaiResponse.usage?.completion_tokens ?? 0,
+      cache_read_input_tokens: openaiResponse.usage?.prompt_tokens_details?.cached_tokens ?? 0
+    }
+  };
+}
+function* synthesizeAnthropicSSE(anthropicResponse) {
+  const sse = (event, data) => `event: ${event}
+data: ${JSON.stringify(data)}
+
+`;
+  const usage = anthropicResponse.usage ?? {};
+  yield sse("message_start", {
+    type: "message_start",
+    message: {
+      id: anthropicResponse.id,
+      type: "message",
+      role: "assistant",
+      content: [],
+      model: anthropicResponse.model,
+      stop_reason: null,
+      stop_sequence: null,
+      usage: {
+        input_tokens: usage.input_tokens ?? 0,
+        output_tokens: 0,
+        cache_read_input_tokens: usage.cache_read_input_tokens ?? 0
+      }
+    }
+  });
+  for (let i = 0; i < (anthropicResponse.content ?? []).length; i++) {
+    const block = anthropicResponse.content[i];
+    yield sse("content_block_start", {
+      type: "content_block_start",
+      index: i,
+      content_block: block.type === "tool_use" ? { type: "tool_use", id: block.id, name: block.name, input: {} } : { type: "text", text: "" }
+    });
+    if (block.type === "text" && block.text) {
+      yield sse("content_block_delta", {
+        type: "content_block_delta",
+        index: i,
+        delta: { type: "text_delta", text: block.text }
+      });
+    } else if (block.type === "tool_use" && block.input) {
+      yield sse("content_block_delta", {
+        type: "content_block_delta",
+        index: i,
+        delta: { type: "input_json_delta", partial_json: JSON.stringify(block.input) }
+      });
+    }
+    yield sse("content_block_stop", { type: "content_block_stop", index: i });
+  }
+  yield sse("message_delta", {
+    type: "message_delta",
+    delta: {
+      stop_reason: anthropicResponse.stop_reason ?? "end_turn",
+      stop_sequence: anthropicResponse.stop_sequence ?? null
+    },
+    usage: { output_tokens: usage.output_tokens ?? 0 }
+  });
+  yield sse("message_stop", { type: "message_stop" });
+}
+async function startOpenAIProxy(targetUrl, apiKey, model, models = []) {
+  const base = targetUrl.replace(/\/+$/, "");
+  const server = http.createServer(async (req, res) => {
+    try {
+      if (req.method === "GET" && req.url === "/v1/models") {
+        res.writeHead(200, { "Content-Type": "application/json" });
+        const modelList = models.length > 0 ? models : [model];
+        const response = {
+          object: "list",
+          data: modelList.map((m) => ({ id: m, object: "model" }))
+        };
+        res.end(JSON.stringify(response));
+        return;
+      }
+      if (req.method === "POST" && req.url?.startsWith("/v1/messages")) {
+        const body = await readBody(req);
+        let parsed;
+        try {
+          parsed = JSON.parse(body);
+        } catch {
+          res.writeHead(400, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ error: { type: "invalid_request_error", message: "invalid JSON" } }));
+          return;
+        }
+        const isStream = !!parsed.stream;
+        const openaiBody = transformAnthropicToOpenAI({ ...parsed, stream: false });
+        if (isStream) {
+          res.writeHead(200, {
+            "Content-Type": "text/event-stream",
+            "Cache-Control": "no-cache",
+            "Connection": "keep-alive"
+          });
+          const keepalive = setInterval(() => res.write(": keepalive\n\n"), 15e3);
+          try {
+            const upstream2 = await fetch(`${base}/v1/chat/completions`, {
+              method: "POST",
+              headers: {
+                "Content-Type": "application/json",
+                "Authorization": `Bearer ${apiKey}`
+              },
+              body: JSON.stringify(openaiBody)
+            });
+            if (!upstream2.ok) {
+              const errText = await upstream2.text();
+              res.write(`event: error
+data: ${errText}
+
+`);
+              res.end();
+              return;
+            }
+            const data2 = await upstream2.json();
+            const anthropicResponse2 = transformOpenAIResponseToAnthropic(data2, parsed.model ?? model);
+            for (const chunk of synthesizeAnthropicSSE(anthropicResponse2)) {
+              res.write(chunk);
+            }
+            res.end();
+          } finally {
+            clearInterval(keepalive);
+          }
+          return;
+        }
+        const upstream = await fetch(`${base}/v1/chat/completions`, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            "Authorization": `Bearer ${apiKey}`
+          },
+          body: JSON.stringify(openaiBody)
+        });
+        if (!upstream.ok) {
+          const errText = await upstream.text();
+          res.writeHead(upstream.status, { "Content-Type": "application/json" });
+          res.end(errText);
+          return;
+        }
+        const data = await upstream.json();
+        const anthropicResponse = transformOpenAIResponseToAnthropic(data, parsed.model ?? model);
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify(anthropicResponse));
+        return;
+      }
+      res.writeHead(404, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: { type: "not_found", message: "endpoint not found" } }));
+    } catch (err) {
+      if (!res.headersSent) {
+        res.writeHead(500, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: { type: "internal_error", message: String(err) } }));
+      }
+    }
+  });
+  return new Promise((resolve, reject) => {
+    server.listen(0, "127.0.0.1", () => {
+      const addr = server.address();
+      const baseUrl = `http://127.0.0.1:${addr.port}`;
+      resolve({
+        baseUrl,
+        stop: () => server.close()
+      });
+    });
+    server.on("error", reject);
+  });
+}
+function readBody(req) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    req.on("data", (c) => chunks.push(c));
+    req.on("end", () => resolve(Buffer.concat(chunks).toString("utf-8")));
+    req.on("error", reject);
+  });
+}
+var PROVIDERS = [
+  {
+    name: "anthropic",
+    description: "Default \u2014 sends Anthropic-format requests directly to the configured URL"
+  },
+  {
+    name: "openai",
+    description: "Embedded proxy \u2014 translates Anthropic requests to OpenAI Chat Completions format"
+  }
+];
+function providerCommand() {
+  const cmd = new Command("provider").description("Manage provider types");
+  cmd.command("list").description("List available provider types").action(() => {
+    const fmt = (name, desc) => `${name.padEnd(12)}  ${desc}`;
+    console.log(fmt("NAME", "DESCRIPTION"));
+    console.log(fmt("----", "-----------"));
+    for (const p of PROVIDERS) {
+      console.log(fmt(p.name, p.description));
+    }
+  });
+  return cmd;
+}
 
 // src/profiles.ts
 function maskToken(token) {
@@ -41,20 +432,94 @@ function maskToken(token) {
   if (token.length <= 12) return token;
   return token.slice(0, 8) + "..." + token.slice(-4);
 }
+function formatModels(p) {
+  if (p.models && p.models.length > 0) {
+    const nonAnthropicModels = p.models.filter((m) => !isAnthropicModel(m));
+    const parts = [];
+    p.models.forEach((m, i) => {
+      if (!isAnthropicModel(m)) {
+        const aliasIndex = nonAnthropicModels.indexOf(m);
+        if (aliasIndex === 0) parts.push(`${m} (opus)`);
+        else if (aliasIndex === 1) parts.push(`${m} (sonnet)`);
+        else if (aliasIndex === 2) parts.push(`${m} (haiku)`);
+        else parts.push(m);
+      } else {
+        parts.push(m);
+      }
+    });
+    const joined = parts.join(", ");
+    if (joined.length > 28) {
+      return parts[0] + ", +" + (parts.length - 1) + " more";
+    }
+    return joined;
+  }
+  return p.model || "(unset)";
+}
+function isAnthropicModel(model) {
+  const anthropicAliases = ["opus", "sonnet", "haiku", "best", "default", "opusplan", "opus[1m]", "sonnet[1m]"];
+  const lower = model.toLowerCase();
+  if (anthropicAliases.includes(lower)) return true;
+  if (lower.startsWith("claude-")) return true;
+  return false;
+}
+function updateSettingsForProfile(p) {
+  ensureSettingsFile();
+  const settings = readJson(SETTINGS_FILE);
+  const models = p.models || (p.model ? [p.model] : []);
+  const nonAnthropicModels = models.filter((m) => !isAnthropicModel(m));
+  if (models.length > 0) {
+    settings.model = models[0];
+    if (nonAnthropicModels.length > 0) {
+      const aliases = [];
+      if (nonAnthropicModels[0]) aliases.push("opus");
+      if (nonAnthropicModels[1]) aliases.push("sonnet");
+      if (nonAnthropicModels[2]) aliases.push("haiku");
+      settings.availableModels = aliases;
+    } else {
+      settings.availableModels = models;
+    }
+  } else {
+    delete settings.model;
+    delete settings.availableModels;
+  }
+  const envVarsToClean = [
+    "ANTHROPIC_DEFAULT_OPUS_MODEL",
+    "ANTHROPIC_DEFAULT_OPUS_MODEL_NAME",
+    "ANTHROPIC_DEFAULT_OPUS_MODEL_DESCRIPTION",
+    "ANTHROPIC_DEFAULT_SONNET_MODEL",
+    "ANTHROPIC_DEFAULT_SONNET_MODEL_NAME",
+    "ANTHROPIC_DEFAULT_SONNET_MODEL_DESCRIPTION",
+    "ANTHROPIC_DEFAULT_HAIKU_MODEL",
+    "ANTHROPIC_DEFAULT_HAIKU_MODEL_NAME",
+    "ANTHROPIC_DEFAULT_HAIKU_MODEL_DESCRIPTION",
+    "ANTHROPIC_CUSTOM_MODEL_OPTION"
+  ];
+  if (settings.env) {
+    for (const key of envVarsToClean) {
+      delete settings.env[key];
+    }
+  }
+  writeJson(SETTINGS_FILE, settings);
+}
 function profileCommand() {
-  const profile = new Command("profile").description("Manage Claude CLI profiles");
-  profile.command("add").description("Add or update a profile").argument("<name>", "Profile name").option("-m, --model <model>", "Model ID (e.g. claude-opus-4-6)").option("-t, --token <token>", "API key / token").option("-u, --url <url>", "Base URL (e.g. https://api.anthropic.com)").action((name, opts) => {
+  const profile = new Command2("profile").description("Manage Claude CLI profiles");
+  profile.command("add").description("Add or update a profile").argument("<name>", "Profile name").option("-m, --model <model>", "Model ID (e.g. claude-opus-4-6) - can be used multiple times", collect, []).option("-t, --token <token>", "API key / token").option("-u, --url <url>", "Base URL (e.g. https://api.anthropic.com)").option("-p, --provider <provider>", "Provider type: anthropic (default) or openai").action((name, opts) => {
     ensureProfilesFile();
     const data = readJson(PROFILES_FILE);
     const profile2 = data.profiles[name] || {};
-    if (opts.model) profile2.model = opts.model;
+    const models = opts.model && opts.model.length > 0 ? opts.model : void 0;
+    if (models) {
+      profile2.models = models;
+      profile2.model = models[0];
+    }
     if (opts.token) profile2.token = opts.token;
     if (opts.url) profile2.url = opts.url;
+    if (opts.provider) profile2.provider = opts.provider;
     data.profiles[name] = profile2;
     writeJson(PROFILES_FILE, data);
     console.log(`Profile '${name}' saved.`);
   });
-  profile.command("update").description("Update fields of an existing profile").argument("<name>", "Profile name (must already exist)").option("-m, --model <model>", "Model ID").option("-t, --token <token>", "API key / token").option("-u, --url <url>", "Base URL").action((name, opts) => {
+  profile.command("update").description("Update fields of an existing profile").argument("<name>", "Profile name (must already exist)").option("-m, --model <model>", "Model ID - can be used multiple times to set multiple models", collect, []).option("-d, --delete-model <model>", "Remove model ID - can be used multiple times", collect, []).option("-t, --token <token>", "API key / token").option("-u, --url <url>", "Base URL").option("-p, --provider <provider>", "Provider type: anthropic (default) or openai").action((name, opts) => {
     ensureProfilesFile();
     const data = readJson(PROFILES_FILE);
     if (!data.profiles[name]) {
@@ -62,12 +527,81 @@ function profileCommand() {
       process.exit(1);
     }
     const p = data.profiles[name];
-    if (opts.model) p.model = opts.model;
+    const providedModels = opts.model && opts.model.length > 0 ? opts.model : void 0;
+    const modelsToDelete = opts.deleteModel && opts.deleteModel.length > 0 ? opts.deleteModel : void 0;
+    if (modelsToDelete) {
+      const toRemove = new Set(modelsToDelete);
+      const currentModels = p.models || (p.model ? [p.model] : []);
+      const newModels = currentModels.filter((m) => !toRemove.has(m));
+      const removedCount = currentModels.length - newModels.length;
+      if (removedCount === 0) {
+        console.log(`No matching models to remove from profile '${name}'.`);
+      } else if (newModels.length === 0) {
+        delete p.models;
+        delete p.model;
+        console.log(`Removed all models from profile '${name}'.`);
+      } else {
+        p.models = newModels;
+        p.model = newModels[0];
+        console.log(`Removed ${removedCount} model(s) from profile '${name}'.`);
+      }
+    }
+    if (providedModels) {
+      if (providedModels.length === 1) {
+        const modelToSet = providedModels[0];
+        const currentModels = p.models || (p.model ? [p.model] : []);
+        const existingIndex = currentModels.indexOf(modelToSet);
+        if (existingIndex !== -1) {
+          currentModels.splice(existingIndex, 1);
+          currentModels.unshift(modelToSet);
+          p.models = currentModels;
+          p.model = modelToSet;
+          console.log(`Selected existing model '${modelToSet}' (position ${existingIndex + 1} -> 1).`);
+        } else {
+          currentModels.unshift(modelToSet);
+          p.models = currentModels;
+          p.model = modelToSet;
+          console.log(`Added and selected new model '${modelToSet}'.`);
+        }
+      } else {
+        p.models = providedModels;
+        p.model = providedModels[0];
+      }
+    }
     if (opts.token) p.token = opts.token;
     if (opts.url) p.url = opts.url;
+    if (opts.provider) p.provider = opts.provider;
     writeJson(PROFILES_FILE, data);
     console.log(`Profile '${name}' updated.`);
   });
+  profile.command("remove-model").description("Remove specific models from a profile").argument("<name>", "Profile name").option("-m, --model <model>", "Model ID to remove - can be used multiple times", collect, []).action((name, opts) => {
+    ensureProfilesFile();
+    const data = readJson(PROFILES_FILE);
+    if (!data.profiles[name]) {
+      console.error(`Profile '${name}' not found.`);
+      process.exit(1);
+    }
+    const p = data.profiles[name];
+    const toRemove = new Set(opts.model);
+    if (toRemove.size === 0) {
+      console.error("No models specified to remove. Use -m <model> to specify models.");
+      process.exit(1);
+    }
+    const currentModels = p.models || (p.model ? [p.model] : []);
+    const newModels = currentModels.filter((m) => !toRemove.has(m));
+    if (newModels.length === 0) {
+      delete p.models;
+      delete p.model;
+      console.log(`Removed all models from profile '${name}'.`);
+    } else {
+      const removedCount = currentModels.length - newModels.length;
+      p.models = newModels;
+      p.model = newModels[0];
+      console.log(`Removed ${removedCount} model(s) from profile '${name}'.`);
+      console.log(`Remaining models: ${newModels.join(", ")}`);
+    }
+    writeJson(PROFILES_FILE, data);
+  });
   profile.command("list").description("List all profiles").action(() => {
     ensureProfilesFile();
     const data = readJson(PROFILES_FILE);
@@ -78,17 +612,18 @@ function profileCommand() {
       return;
     }
     const def = data.default || "";
-    const fmt = (marker, name, model, token, url) => `${marker.padEnd(2)}  ${name.padEnd(20)}  ${model.padEnd(30)}  ${token.padEnd(20)}  ${url}`;
-    console.log(fmt("", "NAME", "MODEL", "TOKEN", "URL"));
-    console.log(fmt("", "----", "-----", "-----", "---"));
+    const fmt = (marker, name, model, token, provider, url) => `${marker.padEnd(2)}  ${name.padEnd(20)}  ${model.padEnd(30)}  ${token.padEnd(20)}  ${provider.padEnd(12)}  ${url}`;
+    console.log(fmt("", "NAME", "MODEL(S)", "TOKEN", "PROVIDER", "URL"));
+    console.log(fmt("", "----", "--------", "-----", "--------", "---"));
     for (const name of names) {
       const p = profiles[name];
       const marker = name === def ? "* " : "  ";
       console.log(fmt(
         marker,
         name,
-        p.model || "(unset)",
+        formatModels(p),
         maskToken(p.token || ""),
+        p.provider || "anthropic",
         p.url || "(default)"
       ));
     }
@@ -104,10 +639,27 @@ function profileCommand() {
     if (opts.json) {
       console.log(JSON.stringify({ name, ...p }, null, 2));
     } else {
-      console.log(`Name:   ${name}`);
-      console.log(`Model:  ${p.model || "(unset)"}`);
-      console.log(`Token:  ${p.token || "(unset)"}`);
-      console.log(`URL:    ${p.url || "(default)"}`);
+      console.log(`Name:     ${name}`);
+      console.log(`Model:    ${p.model || "(unset)"}`);
+      if (p.models && p.models.length > 0) {
+        const nonAnthropicModels = p.models.filter((m) => !isAnthropicModel(m));
+        console.log(`Models:`);
+        for (const m of p.models) {
+          if (!isAnthropicModel(m)) {
+            const aliasIndex = nonAnthropicModels.indexOf(m);
+            let alias = "";
+            if (aliasIndex === 0) alias = " (opus)";
+            else if (aliasIndex === 1) alias = " (sonnet)";
+            else if (aliasIndex === 2) alias = " (haiku)";
+            console.log(`  - ${m}${alias}`);
+          } else {
+            console.log(`  - ${m}`);
+          }
+        }
+      }
+      console.log(`Token:    ${p.token || "(unset)"}`);
+      console.log(`URL:      ${p.url || "(default)"}`);
+      console.log(`Provider: ${p.provider || "anthropic"}`);
     }
   });
   profile.command("remove").description("Remove a profile").argument("<name>", "Profile name").action((name) => {
@@ -134,25 +686,70 @@ function profileCommand() {
   });
   return profile;
 }
+function collect(value, previous) {
+  return previous.concat([value]);
+}
 function execClaude(profileName, p, extraArgs) {
+  updateSettingsForProfile(p);
+  const models = p.models || (p.model ? [p.model] : []);
+  const firstModel = models[0];
   const cmd = ["claude"];
-  if (p.model) cmd.push("--model", p.model);
+  if (firstModel) cmd.push("--model", firstModel);
   cmd.push(...extraArgs);
   const env = {
     ...process.env,
     ANTHROPIC_AUTH_TOKEN: p.token || void 0,
     ANTHROPIC_BASE_URL: p.url || void 0
   };
+  const nonAnthropicModels = models.filter((m) => !isAnthropicModel(m));
+  if (nonAnthropicModels.length > 0) {
+    if (nonAnthropicModels[0]) {
+      env.ANTHROPIC_DEFAULT_OPUS_MODEL = nonAnthropicModels[0];
+      env.ANTHROPIC_DEFAULT_OPUS_MODEL_NAME = nonAnthropicModels[0];
+      env.ANTHROPIC_DEFAULT_OPUS_MODEL_DESCRIPTION = `Custom: ${nonAnthropicModels[0]}`;
+    }
+    if (nonAnthropicModels[1]) {
+      env.ANTHROPIC_DEFAULT_SONNET_MODEL = nonAnthropicModels[1];
+      env.ANTHROPIC_DEFAULT_SONNET_MODEL_NAME = nonAnthropicModels[1];
+      env.ANTHROPIC_DEFAULT_SONNET_MODEL_DESCRIPTION = `Custom: ${nonAnthropicModels[1]}`;
+    }
+    if (nonAnthropicModels[2]) {
+      env.ANTHROPIC_DEFAULT_HAIKU_MODEL = nonAnthropicModels[2];
+      env.ANTHROPIC_DEFAULT_HAIKU_MODEL_NAME = nonAnthropicModels[2];
+      env.ANTHROPIC_DEFAULT_HAIKU_MODEL_DESCRIPTION = `Custom: ${nonAnthropicModels[2]}`;
+    }
+    env.ANTHROPIC_CUSTOM_MODEL_OPTION = nonAnthropicModels[0];
+  }
   delete env.ANTHROPIC_API_KEY;
-  console.error(`Using profile '${profileName}': model=${p.model || "(default)"} url=${p.url || "(default)"}`);
-  const result = spawnSync(cmd[0], cmd.slice(1), {
-    stdio: "inherit",
-    env
-  });
-  process.exit(result.status ?? 1);
+  console.error(`Using profile '${profileName}': model=${firstModel || "(default)"} url=${p.url || "(default)"} provider=${p.provider || "anthropic"}`);
+  if (p.provider === "openai") {
+    const allModels = p.models || (p.model ? [p.model] : []);
+    startOpenAIProxy(
+      p.url || "https://api.openai.com",
+      p.token || "",
+      firstModel || "gpt-4o",
+      allModels
+    ).then(({ baseUrl, stop }) => {
+      env.ANTHROPIC_BASE_URL = baseUrl;
+      const child = spawn(cmd[0], cmd.slice(1), { stdio: "inherit", env });
+      child.on("close", (code) => {
+        stop();
+        process.exit(code ?? 1);
+      });
+    }).catch((err) => {
+      console.error("Failed to start OpenAI proxy:", err);
+      process.exit(1);
+    });
+  } else {
+    const result = spawnSync(cmd[0], cmd.slice(1), {
+      stdio: "inherit",
+      env
+    });
+    process.exit(result.status ?? 1);
+  }
 }
 function useCommand() {
-  return new Command("use").description("Set a profile as the default").argument("<name>", "Profile name").action((name) => {
+  return new Command2("use").description("Set a profile as the default").argument("<name>", "Profile name").action((name) => {
     ensureProfilesFile();
     const data = readJson(PROFILES_FILE);
     if (!data.profiles[name]) {
@@ -165,7 +762,8 @@ function useCommand() {
   });
 }
 function runCommand() {
-  return new Command("run").description("Launch Claude Code using the default or a specified profile").allowUnknownOption().argument("[args...]", "Optional profile name followed by extra arguments").action((args) => {
+  return new Command2("run").description("Launch Claude Code using the default or a specified profile").allowUnknownOption().argument("[args...]", "Optional profile name followed by extra arguments").action((args) => {
+    fixJsonFile(CLAUDE_JSON);
     ensureProfilesFile();
     const data = readJson(PROFILES_FILE);
     let profileName = "";
@@ -187,7 +785,7 @@ function runCommand() {
 }
 
 // src/hooks.ts
-import { Command as Command2 } from "commander";
+import { Command as Command3 } from "commander";
 function buildFlat(data) {
   const rows = [];
   const hooksRoot = data.hooks || {};
@@ -227,7 +825,7 @@ function buildFlat(data) {
   return rows;
 }
 function hooksCommand() {
-  const hooks = new Command2("hook").description("Manage Claude Code hooks in settings.json");
+  const hooks = new Command3("hook").description("Manage Claude Code hooks in settings.json");
   hooks.command("list").description("List all hooks").action(() => {
     ensureSettingsFile();
     const data = readJson(SETTINGS_FILE);
@@ -379,7 +977,7 @@ function hooksCommand() {
 }
 
 // src/sessions.ts
-import { Command as Command3 } from "commander";
+import { Command as Command4 } from "commander";
 import fs2 from "fs";
 import path2 from "path";
 import { execSync } from "child_process";
@@ -463,7 +1061,7 @@ function snippet(text, query, width = 150) {
   return prefix + text.slice(start, end) + suffix;
 }
 function sessionCommand() {
-  const session = new Command3("session").description("Manage Claude Code sessions");
+  const session = new Command4("session").description("Manage Claude Code sessions");
   session.command("list").description("List all Claude Code project sessions").option("-n, --limit <n>", "Max number of projects to show", "30").option("-s, --short", "Show encoded names only (no decoding)").option("-j, --json", "Output as JSON lines").action((opts) => {
     const limit = parseInt(opts.limit, 10);
     let dirs;
@@ -755,7 +1353,7 @@ function sessionCommand() {
 }
 
 // src/complete.ts
-import { Command as Command4 } from "commander";
+import { Command as Command5 } from "commander";
 var ZSH_COMPLETION = `#compdef cc-hub
 
 _cc-hub() {
@@ -766,14 +1364,22 @@ _cc-hub() {
     'run:Launch Claude Code using the default or a specified profile'
     'hook:Manage Claude Code hooks in settings.json'
     'session:Manage Claude Code sessions'
+    'provider:Manage provider types'
     'complete:Print shell completion functions'
     'help:Display help for a command'
   )
 
+  local -a provider_subcmds
+  provider_subcmds=(
+    'list:List available provider types'
+  )
+
+
   local -a profile_subcmds
   profile_subcmds=(
     'add:Add or update a profile'
     'update:Update fields of an existing profile'
+    'remove-model:Remove specific models from a profile'
     'list:List all profiles'
     'view:View full details of a profile'
     'remove:Remove a profile'
@@ -803,16 +1409,21 @@ _cc-hub() {
     local profiles_file="\${CLAUDE_PROFILES_FILE:-$HOME/.claude/profiles.json}"
     if [[ -f "$profiles_file" ]]; then
       local -a names
-      names=(\${(f)"$(command python3 -c "
-import json
-data = json.load(open('$profiles_file'))
-for name in data.get('profiles', {}):
-    print(name)
-" 2>/dev/null)"})
+      names=(\${(f)"$(command jq -r '.profiles | keys[]' "$profiles_file" 2>/dev/null)"})
       _describe -t profiles 'profile' names
     fi
   }
 
+  _cc_hub_models_for_profile() {
+    local profile_name="$1"
+    local profiles_file="\${CLAUDE_PROFILES_FILE:-$HOME/.claude/profiles.json}"
+    if [[ -f "$profiles_file" && -n "$profile_name" ]]; then
+      local -a models
+      models=(\${(f)"$(command jq -r --arg p "$profile_name" '(.profiles[$p].models // [ .profiles[$p].model ] )[]? // empty' "$profiles_file" 2>/dev/null)"})
+      _describe -t models 'model' models
+    fi
+  }
+
   _arguments -C \\
     '1: :->command' \\
     '*::arg:->args'
@@ -826,8 +1437,26 @@ for name in data.get('profiles', {}):
         profile)
           if (( CURRENT == 2 )); then
             _describe -t profile-subcmds 'profile subcommand' profile_subcmds
-          elif [[ $words[2] == "view" || $words[2] == "remove" || $words[2] == "default" || $words[2] == "update" ]]; then
+          elif [[ $words[2] == "view" || $words[2] == "remove" || $words[2] == "default" || $words[2] == "remove-model" ]]; then
             _cc_hub_profiles
+          elif [[ $words[2] == "update" ]]; then
+            if (( CURRENT == 3 )); then
+              _cc_hub_profiles
+            else
+              words=("stub" $words[3,-1])
+              (( CURRENT-- ))
+              _arguments -C -S                 '1:profile:_cc_hub_profiles'                 '(-m --model)*'{-m,--model}'[Model ID]:model:->profileModel'                 '(-d --delete-model)*'{-d,--delete-model}'[Remove model ID]:model:->profileModel'                 '(-t --token)'{-t,--token}'[API key / token]:token:'                 '(-u --url)'{-u,--url}'[Base URL]:url:'                 '(-p --provider)'{-p,--provider}'[Provider type]:provider:(anthropic openai)'
+              case $state in
+                profileModel)
+                  _cc_hub_models_for_profile $line[1]
+                  ;;
+              esac
+            fi
+          fi
+          ;;
+        provider)
+          if (( CURRENT == 2 )); then
+            _describe -t provider-subcmds 'provider subcommand' provider_subcmds
           fi
           ;;
         use|run)
@@ -864,14 +1493,39 @@ for name in data.get('profiles', {}):
   fi
 }
 
+_cc-hub_models_for_profile() {
+  local profile_name="$1"
+  local profiles_file="\${CLAUDE_PROFILES_FILE:-$HOME/.claude/profiles.json}"
+  if [[ -f "$profiles_file" && -n "$profile_name" ]]; then
+    local models
+    models=$(command python3 -c "
+import json
+data = json.load(open('$profiles_file'))
+p = data.get('profiles', {}).get('$profile_name', {})
+models = p.get('models')
+if isinstance(models, list):
+    for m in models:
+        if m:
+            print(m)
+else:
+    m = p.get('model')
+    if m:
+        print(m)
+" 2>/dev/null)
+    COMPREPLY=($(compgen -W "$models" -- "\${cur}"))
+  fi
+}
+
 _cc-hub() {
   local cur prev commands
   COMPREPLY=()
   cur="\${COMP_WORDS[COMP_CWORD]}"
   prev="\${COMP_WORDS[COMP_CWORD-1]}"
-  commands="profile use run hook session complete help"
+  commands="profile use run hook session provider complete help"
 
-  local profile_subcmds="add update list view remove default"
+  local profile_subcmds="add update remove-model list view remove default"
+  local provider_subcmds="list"
+  local provider_types="anthropic openai"
   local hooks_subcmds="list add remove enable disable"
   local session_subcmds="list show search ps stats clean"
 
@@ -887,10 +1541,28 @@ _cc-hub() {
     profile)
       if [[ \${COMP_CWORD} -eq 2 ]]; then
         COMPREPLY=($(compgen -W "$profile_subcmds" -- "$cur"))
-      elif [[ "$prev" == "view" || "$prev" == "remove" || "$prev" == "default" || "$prev" == "update" ]]; then
+      elif [[ "$prev" == "view" || "$prev" == "remove" || "$prev" == "default" || "$prev" == "remove-model" ]]; then
         _cc-hub_profiles
       elif [[ "$prev" == "profile" ]]; then
         COMPREPLY=($(compgen -W "$profile_subcmds" -- "$cur"))
+      elif [[ "\${COMP_WORDS[2]}" == "update" && \${COMP_CWORD} -eq 3 ]]; then
+        _cc-hub_profiles
+      elif [[ "\${COMP_WORDS[2]}" == "update" ]]; then
+        if [[ "$prev" == "--provider" || "$prev" == "-p" ]]; then
+          COMPREPLY=($(compgen -W "$provider_types" -- "$cur"))
+        elif [[ "$prev" == "--model" || "$prev" == "-m" || "$prev" == "--delete-model" || "$prev" == "-d" ]]; then
+          _cc-hub_models_for_profile "\${COMP_WORDS[3]}"
+        else
+          local update_opts="--model -m --delete-model -d --token -t --url -u --provider -p"
+          COMPREPLY=($(compgen -W "$update_opts" -- "$cur"))
+        fi
+      fi
+      ;;
+    provider)
+      if [[ \${COMP_CWORD} -eq 2 ]]; then
+        COMPREPLY=($(compgen -W "$provider_subcmds" -- "$cur"))
+      elif [[ "$prev" == "provider" ]]; then
+        COMPREPLY=($(compgen -W "$provider_subcmds" -- "$cur"))
       fi
       ;;
     use|run)
@@ -914,7 +1586,7 @@ _cc-hub() {
 complete -F _cc-hub cc-hub
 `;
 function completeCommand() {
-  return new Command4("complete").description("Print shell completion script").argument("<shell>", "Shell type: bash or zsh").action((shell) => {
+  return new Command5("complete").description("Print shell completion script").argument("<shell>", "Shell type: bash or zsh").action((shell) => {
     switch (shell) {
       case "zsh":
         process.stdout.write(ZSH_COMPLETION);
@@ -930,7 +1602,7 @@ function completeCommand() {
 }
 
 // src/index.ts
-var program = new Command5();
+var program = new Command6();
 program.name("cc-hub").description("Manage Claude CLI profiles, hooks, and sessions").version("1.0.0");
 program.addCommand(profileCommand());
 program.addCommand(useCommand());
@@ -938,4 +1610,5 @@ program.addCommand(runCommand());
 program.addCommand(hooksCommand());
 program.addCommand(sessionCommand());
 program.addCommand(completeCommand());
+program.addCommand(providerCommand());
 program.parse();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cc-hub-cli",
-  "version": "1.0.4",
+  "version": "1.0.7",
   "description": "Manage Claude CLI profiles, hooks, and sessions",
   "type": "module",
   "bin": {
@@ -10,7 +10,11 @@
     "build": "tsup",
     "dev": "tsup --watch",
     "start": "node dist/index.js",
-    "prepublishOnly": "npm run build"
+    "prepublishOnly": "npm run build",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "test:build": "npm test && npm run build"
   },
   "repository": {
     "type": "git",
@@ -29,7 +33,9 @@
   },
   "devDependencies": {
     "tsup": "^8.4.0",
-    "typescript": "^5.7.0"
+    "typescript": "^5.7.0",
+    "vitest": "^3.0.0",
+    "@vitest/coverage-v8": "^3.0.0"
   },
   "engines": {
     "node": ">=18"