cc-x10ded 3.0.0

package/src/commands/setup.ts

@@ -0,0 +1,125 @@
+import { intro, outro, text, confirm, select, spinner, isCancel, cancel, note } from "@clack/prompts";
+import { ConfigManager } from "../core/config";
+import { ShellIntegrator } from "../core/shell";
+import { spawn } from "bun";
+import pc from "picocolors";
+
+export async function setupCommand() {
+  intro(pc.bgBlue(pc.white(" Claude-GLM Setup ")));
+
+  const configManager = new ConfigManager();
+  const config = await configManager.read();
+  const shellInt = new ShellIntegrator();
+
+  // 1. Check for Claude Binary (Self-Healing)
+  const claudePath = await shellInt.findClaudeBinary();
+  if (!claudePath) {
+      note(pc.yellow("Claude Code is not installed or not found."));
+      const installClaude = await confirm({
+          message: "Would you like to install Claude Code now? (npm required)",
+          initialValue: true
+      });
+      
+      if (isCancel(installClaude)) { cancel("Setup cancelled"); process.exit(0); }
+      
+      if (installClaude) {
+          const s = spinner();
+          s.start("Installing @anthropic-ai/claude-code...");
+          try {
+              const proc = spawn(["npm", "install", "-g", "@anthropic-ai/claude-code"], {
+                  stdio: ["ignore", "ignore", "ignore"]
+              });
+              await proc.exited;
+              if (proc.exitCode === 0) {
+                  s.stop(pc.green("Claude Code installed successfully!"));
+              } else {
+                  s.stop(pc.red("Installation failed. Please install manually: npm install -g @anthropic-ai/claude-code"));
+              }
+          } catch {
+              s.stop(pc.red("npm not found or failed."));
+          }
+      }
+  }
+
+  // 2. Z.AI Config
+  if (!config.zaiApiKey) {
+    const openBrowser = await confirm({
+        message: "No Z.AI API key found. Open dashboard to get one?",
+        initialValue: true
+    });
+    
+    if (openBrowser && !isCancel(openBrowser)) {
+        spawn(["open", "https://z.ai/manage-apikey/apikey-list"]).catch(() => {});
+        spawn(["xdg-open", "https://z.ai/manage-apikey/apikey-list"]).catch(() => {}); // Linux
+        spawn(["explorer", "https://z.ai/manage-apikey/apikey-list"]).catch(() => {}); // Windows
+    }
+
+    const zaiKey = await text({
+      message: "Enter your Z.AI API Key:",
+      placeholder: "sk-...",
+      validate: (value) => {
+        if (!value) return "API Key is required";
+      },
+    });
+
+    if (isCancel(zaiKey)) {
+      cancel("Setup cancelled");
+      process.exit(0);
+    }
+    
+    config.zaiApiKey = zaiKey as string;
+  }
+
+  // 3. Minimax Config
+  const minimax = await confirm({
+    message: "Do you want to configure Minimax (M2.1)?",
+    initialValue: !!config.minimaxApiKey,
+  });
+
+  if (isCancel(minimax)) { cancel("Setup cancelled"); process.exit(0); }
+
+  if (minimax) {
+    const mmKey = await text({
+      message: "Enter Minimax API Key:",
+      initialValue: config.minimaxApiKey,
+      placeholder: "Enter key or leave empty to skip",
+    });
+    if (isCancel(mmKey)) { cancel("Setup cancelled"); process.exit(0); }
+    if (mmKey) config.minimaxApiKey = mmKey as string;
+  }
+
+  // 4. Shell Config
+  const detectedShell = shellInt.detectShell();
+
+  if (detectedShell !== "unknown") {
+    const installAliases = await select({
+      message: `Install shell aliases for ${detectedShell}? (cc, ccg, ccm...)`,
+      options: [
+        { value: "yes", label: "Yes, install standard aliases", hint: "Recommended" },
+        { value: "no", label: "No, I will use 'ccx' directly" },
+      ],
+    });
+
+    if (isCancel(installAliases)) { cancel("Setup cancelled"); process.exit(0); }
+
+    if (installAliases === "yes") {
+      const s = spinner();
+      s.start("Installing aliases...");
+      const success = await shellInt.installAliases(detectedShell);
+      
+      // Attempt to ensure local bin is in path
+      await shellInt.ensureLocalBinInPath(detectedShell);
+
+      if (success) {
+        s.stop("Aliases installed!");
+        config.aliases = true;
+      } else {
+        s.stop("Failed to install aliases (check permissions)");
+      }
+    }
+  }
+
+  await configManager.write(config);
+  
+  outro(pc.green("Setup complete! Run 'ccx' to start."));
+}

package/src/core/config.ts

@@ -0,0 +1,111 @@
+import { join } from "path";
+import { homedir } from "os";
+import { existsSync, mkdirSync } from "fs";
+
+export interface Config {
+  zaiApiKey?: string;
+  minimaxApiKey?: string;
+  providers: {
+    openai?: { apiKey: string; baseUrl?: string };
+    openrouter?: { apiKey: string; baseUrl?: string; referer?: string; title?: string };
+    gemini?: { apiKey: string; baseUrl?: string };
+    anthropic?: { apiKey: string; baseUrl?: string };
+  };
+  defaults: {
+    model: string; // e.g., "glm-4.7"
+    provider: string; // e.g., "glm"
+  };
+  aliases: boolean; // whether to install aliases
+}
+
+const DEFAULT_CONFIG: Config = {
+  providers: {},
+  defaults: {
+    model: "glm-4.7",
+    provider: "glm",
+  },
+  aliases: false,
+};
+
+export class ConfigManager {
+  private configDir: string;
+  private configFile: string;
+
+  constructor() {
+    const home = homedir();
+    // Use XDG config standard if possible, but fallback to ~/.config
+    this.configDir = join(home, ".config", "claude-glm");
+    this.configFile = join(this.configDir, "config.json");
+  }
+
+  ensureConfigDir() {
+    if (!existsSync(this.configDir)) {
+      mkdirSync(this.configDir, { recursive: true });
+    }
+  }
+
+  async read(): Promise<Config> {
+    let config = { ...DEFAULT_CONFIG };
+    
+    // 1. Read from file
+    try {
+      const file = Bun.file(this.configFile);
+      if (await file.exists()) {
+        const json = await file.json();
+        config = { ...config, ...json };
+      }
+    } catch (e) {
+      // ignore error
+    }
+
+    // 2. Env Var Fallback (Auto-Discovery)
+    if (!config.zaiApiKey && process.env.ZAI_API_KEY) {
+        config.zaiApiKey = process.env.ZAI_API_KEY;
+    }
+    if (!config.zaiApiKey && process.env.GLM_API_KEY) {
+        config.zaiApiKey = process.env.GLM_API_KEY;
+    }
+    
+    if (!config.minimaxApiKey && process.env.MINIMAX_API_KEY) {
+        config.minimaxApiKey = process.env.MINIMAX_API_KEY;
+    }
+
+    if (!config.providers.openai?.apiKey && process.env.OPENAI_API_KEY) {
+        config.providers.openai = { 
+            apiKey: process.env.OPENAI_API_KEY,
+            baseUrl: process.env.OPENAI_BASE_URL
+        };
+    }
+
+    if (!config.providers.anthropic?.apiKey && process.env.ANTHROPIC_API_KEY) {
+        config.providers.anthropic = {
+            apiKey: process.env.ANTHROPIC_API_KEY,
+            baseUrl: process.env.ANTHROPIC_BASE_URL
+        };
+    }
+    
+    if (!config.providers.gemini?.apiKey && process.env.GEMINI_API_KEY) {
+        config.providers.gemini = { apiKey: process.env.GEMINI_API_KEY };
+    }
+
+    if (!config.providers.openrouter?.apiKey && process.env.OPENROUTER_API_KEY) {
+        config.providers.openrouter = { 
+            apiKey: process.env.OPENROUTER_API_KEY,
+            baseUrl: process.env.OPENROUTER_BASE_URL,
+            referer: process.env.OPENROUTER_REFERER,
+            title: process.env.OPENROUTER_TITLE
+        };
+    }
+
+    return config;
+  }
+
+  async write(config: Config) {
+    this.ensureConfigDir();
+    await Bun.write(this.configFile, JSON.stringify(config, null, 2));
+  }
+
+  getPath() {
+    return this.configFile;
+  }
+}

package/src/core/shell.ts

@@ -0,0 +1,166 @@
+import { join } from "path";
+import { homedir, platform } from "os";
+import { existsSync, readFileSync, appendFileSync, writeFileSync } from "fs";
+
+export type ShellType = "bash" | "zsh" | "fish" | "powershell" | "unknown";
+
+export class ShellIntegrator {
+  private home = homedir();
+
+  detectShell(): ShellType {
+    const shellPath = process.env.SHELL;
+    if (platform() === "win32") return "powershell";
+    if (!shellPath) return "unknown";
+    if (shellPath.includes("zsh")) return "zsh";
+    if (shellPath.includes("bash")) return "bash";
+    if (shellPath.includes("fish")) return "fish";
+    return "unknown";
+  }
+
+  getProfilePath(shell: ShellType): string | null {
+    if (shell === "zsh") return join(this.home, ".zshrc");
+    if (shell === "bash") {
+      // Prefer .bashrc, fallback to .bash_profile
+      const bashrc = join(this.home, ".bashrc");
+      const bashProfile = join(this.home, ".bash_profile");
+      if (existsSync(bashrc)) return bashrc;
+      if (existsSync(bashProfile)) return bashProfile;
+      return bashrc; // default
+    }
+    if (shell === "fish") return join(this.home, ".config", "fish", "config.fish");
+    if (shell === "powershell") {
+        // Standard PowerShell profile paths
+        // We try to find Documents folder first
+        const docs = join(this.home, "Documents");
+        if (existsSync(docs)) {
+             const psDir = join(docs, "PowerShell");
+             if (!existsSync(psDir)) {
+                 try { mkdirSync(psDir, { recursive: true }); } catch {}
+             }
+             return join(psDir, "Microsoft.PowerShell_profile.ps1");
+        }
+        // Fallback to OneDrive/Documents if needed or just home/Documents
+        return join(this.home, "Documents", "PowerShell", "Microsoft.PowerShell_profile.ps1");
+    }
+    return null;
+  }
+
+  async installAliases(shell: ShellType) {
+    const profile = this.getProfilePath(shell);
+    if (!profile) return false;
+
+    // Ensure directory exists for the profile
+    const dir = join(profile, "..");
+    if (!existsSync(dir)) {
+        try { mkdirSync(dir, { recursive: true }); } catch {}
+    }
+    
+    // Check if file exists, if not create empty
+    if (!existsSync(profile)) {
+        await Bun.write(profile, "");
+    }
+
+    const aliasBlock = this.generateAliasBlock(shell);
+    if (!aliasBlock) return false;
+
+    let content = "";
+    if (existsSync(profile)) {
+      content = await Bun.file(profile).text();
+    }
+
+    const startMarker = "# >>> claude-glm-wrapper >>>";
+    const endMarker = "# <<< claude-glm-wrapper <<<";
+
+    // Remove existing block
+    const regex = new RegExp(`${startMarker}[\\s\\S]*?${endMarker}`, "g");
+    content = content.replace(regex, "").trim();
+
+    // Append new block
+    const newContent = `${content}\n\n${startMarker}\n${aliasBlock}\n${endMarker}\n`;
+    
+    await Bun.write(profile, newContent);
+    return true;
+  }
+
+  private generateAliasBlock(shell: ShellType): string {
+    if (shell === "zsh" || shell === "bash") {
+      return `
+alias cc='ccx'
+alias ccg='ccx --model=glm-4.7'
+alias ccg46='ccx --model=glm-4.6'
+alias ccg45='ccx --model=glm-4.5'
+alias ccf='ccx --model=glm-4.5-air'
+alias ccm='ccx --model=MiniMax-M2.1'
+`.trim();
+    }
+    if (shell === "fish") {
+       return `
+alias cc 'ccx'
+alias ccg 'ccx --model=glm-4.7'
+alias ccg46 'ccx --model=glm-4.6'
+alias ccg45 'ccx --model=glm-4.5'
+alias ccf 'ccx --model=glm-4.5-air'
+alias ccm 'ccx --model=MiniMax-M2.1'
+`.trim();
+    }
+    if (shell === "powershell") {
+        return `
+Function cc { ccx @args }
+Function ccg { ccx --model=glm-4.7 @args }
+Function ccg46 { ccx --model=glm-4.6 @args }
+Function ccg45 { ccx --model=glm-4.5 @args }
+Function ccf { ccx --model=glm-4.5-air @args }
+Function ccm { ccx --model=MiniMax-M2.1 @args }
+`.trim();
+    }
+    return "";
+  }
+  
+  async ensureLocalBinInPath(shell: ShellType) {
+      if (platform() === "win32") return; // Windows handles PATH differently (usually handled by installer or user)
+
+      const profile = this.getProfilePath(shell);
+      if (!profile || !existsSync(profile)) return;
+      
+      const localBin = join(this.home, ".local", "bin");
+      const content = await Bun.file(profile).text();
+      
+      // Heuristic check
+      if (!content.includes(localBin) && !process.env.PATH?.includes(localBin)) {
+          const exportCmd = `export PATH="$HOME/.local/bin:$PATH"`;
+          if (!content.includes(exportCmd)) {
+              await Bun.write(profile, `${content}\n\n# Added by claude-glm-wrapper\n${exportCmd}\n`);
+          }
+      }
+  }
+
+  /**
+   * Hunt for the 'claude' binary in common locations
+   */
+  async findClaudeBinary(): Promise<string | null> {
+    // 1. Check PATH
+    try {
+        const path = Bun.which("claude");
+        if (path) return path;
+    } catch {}
+
+    // 2. Common Locations
+    const locations = [
+        join(this.home, ".npm-global", "bin", "claude"),
+        "/usr/local/bin/claude",
+        "/opt/homebrew/bin/claude",
+        join(this.home, "bin", "claude"),
+        join(this.home, ".local", "bin", "claude"),
+        // Windows
+        join(process.env.APPDATA || "", "npm", "claude.cmd"),
+        join(process.env.APPDATA || "", "npm", "claude.ps1"),
+    ];
+
+    for (const loc of locations) {
+        if (existsSync(loc)) return loc;
+    }
+
+    return null;
+  }
+
+}

package/src/index.ts

@@ -0,0 +1,53 @@
+#!/usr/bin/env bun
+import { cac } from "cac";
+import { runCommand } from "./commands/run";
+import { setupCommand } from "./commands/setup";
+import { configCommand } from "./commands/config";
+import { doctorCommand } from "./commands/doctor";
+import packageJson from "../package.json";
+
+const cli = cac("ccx");
+
+cli
+  .command("setup", "Run the interactive setup wizard")
+  .action(setupCommand);
+
+cli
+  .command("config", "Edit configuration file")
+  .action(configCommand);
+
+cli
+  .command("doctor", "Run self-diagnostics")
+  .action(doctorCommand);
+
+cli
+  .command("update", "Update ccx to the latest version")
+  .action(async () => {
+    console.log("Updating ccx...");
+    const { spawn } = await import("bun");
+    const proc = spawn(["npm", "install", "-g", "claude-glm-wrapper"], { stdio: "inherit" });
+    await proc.exited;
+    if (proc.exitCode === 0) {
+        console.log("✅ Update complete!");
+    } else {
+        console.error("❌ Update failed.");
+    }
+  });
+
+cli
+  .command("[...args]", "Run Claude Code with proxy (default)")
+  .option("-m, --model <model>", "Override the model (e.g., glm-4.5, openai:gpt-4o)")
+  .option("-p, --port <port>", "Port for the local proxy (default: 17870)")
+  .action((args, options) => {
+    runCommand(args, options);
+  });
+
+cli.help();
+cli.version(packageJson.version);
+
+try {
+  cli.parse();
+} catch (error: any) {
+  console.error(error.message);
+  process.exit(1);
+}

package/src/proxy/map.ts

@@ -0,0 +1,86 @@
+import { AnthropicMessage, AnthropicRequest, ProviderKey, ProviderModel } from "./types";
+
+const PROVIDER_PREFIXES: ProviderKey[] = ["openai", "openrouter", "gemini", "glm", "anthropic", "minimax"];
+
+const PROVIDER_ALIASES: Record<string, ProviderKey> = {
+    "gpt": "openai",
+    "gpt4": "openai",
+    "oai": "openai",
+    "or": "openrouter",
+    "router": "openrouter",
+    "google": "gemini",
+    "bard": "gemini",
+    "ant": "anthropic",
+    "sonnet": "anthropic",
+    "claude": "anthropic",
+    "z": "glm",
+    "zai": "glm",
+    "mini": "minimax",
+    "mm": "minimax"
+};
+
+export function parseProviderModel(modelField: string, defaults?: ProviderModel): ProviderModel {
+  if (!modelField) {
+    if (defaults) return defaults;
+    throw new Error("Missing 'model' in request");
+  }
+
+  const sep = modelField.includes(":") ? ":" : modelField.includes("/") ? "/" : null;
+  if (!sep) {
+    // Try to auto-detect common model names without prefix
+    const lower = modelField.toLowerCase();
+    if (lower.startsWith("gpt")) return { provider: "openai", model: modelField };
+    if (lower.startsWith("gemini")) return { provider: "gemini", model: modelField };
+    if (lower.startsWith("claude")) return { provider: "anthropic", model: modelField };
+    if (lower.startsWith("glm")) return { provider: "glm", model: modelField };
+    
+    return defaults ?? { provider: "glm", model: modelField };
+  }
+
+  const [maybeProv, ...rest] = modelField.split(sep);
+  let prov = maybeProv.toLowerCase();
+
+  // Resolve alias
+  if (PROVIDER_ALIASES[prov]) {
+      prov = PROVIDER_ALIASES[prov];
+  }
+
+  if (!PROVIDER_PREFIXES.includes(prov as ProviderKey)) {
+    // If prefix unknown, treat whole string as model for default provider
+    return defaults ?? { provider: "glm", model: modelField };
+  }
+
+  return { provider: prov as ProviderKey, model: rest.join(sep) };
+}
+
+export function toPlainText(content: AnthropicMessage["content"]): string {
+  if (typeof content === "string") return content;
+  return content
+    .map((c) => {
+      if (typeof c === "string") return c;
+      if (c.type === "text") return c.text;
+      // @ts-ignore
+      if (c.type === "tool_result") {
+        // @ts-ignore
+        if (typeof c.content === "string") return c.content;
+        // @ts-ignore
+        return JSON.stringify(c.content);
+      }
+      return "";
+    })
+    .join("");
+}
+
+export function toOpenAIMessages(messages: AnthropicMessage[]) {
+  return messages.map((m) => ({
+    role: m.role,
+    content: toPlainText(m.content)
+  }));
+}
+
+export function toGeminiContents(messages: AnthropicMessage[]) {
+  return messages.map((m) => ({
+    role: m.role === "assistant" ? "model" : "user",
+    parts: [{ text: toPlainText(m.content) }]
+  }));
+}

package/src/proxy/providers.ts

@@ -0,0 +1,142 @@
+import { createParser } from "eventsource-parser";
+import { AnthropicRequest } from "./types";
+import { toOpenAIMessages, toGeminiContents } from "./map";
+import { createStartMessage, createDelta, createStopMessage, ApiError } from "./utils";
+
+// OpenAI
+export async function* streamOpenAI(
+  body: AnthropicRequest,
+  model: string,
+  key: string,
+  baseUrl: string
+) {
+  const url = `${baseUrl}/chat/completions`;
+  const reqBody: any = {
+    model,
+    messages: toOpenAIMessages(body.messages),
+    stream: true,
+    temperature: body.temperature ?? 0.7,
+    max_tokens: body.max_tokens
+  };
+  
+  if (body.tools?.length) reqBody.tools = body.tools;
+
+  const resp = await fetch(url, {
+    method: "POST",
+    headers: { Authorization: `Bearer ${key}`, "Content-Type": "application/json" },
+    body: JSON.stringify(reqBody)
+  });
+
+  if (!resp.ok) throw new ApiError(await resp.text(), resp.status);
+  if (!resp.body) throw new ApiError("No response body", 500);
+
+  yield createStartMessage(model);
+
+  const reader = resp.body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = ""; // Store partial chunks if needed, but parser handles it
+
+  const parser = createParser((event) => {
+    if (event.type !== "event") return;
+    const data = event.data;
+    if (!data || data === "[DONE]") return;
+    try {
+      const json = JSON.parse(data);
+      const chunk = json.choices?.[0]?.delta?.content ?? "";
+      if (chunk) buffer += createDelta(chunk);
+    } catch {}
+  });
+
+  while (true) {
+    const { value, done } = await reader.read();
+    if (done) break;
+    parser.feed(decoder.decode(value));
+    if (buffer) {
+      yield buffer;
+      buffer = "";
+    }
+  }
+  
+  yield createStopMessage();
+}
+
+// Gemini
+export async function* streamGemini(
+  body: AnthropicRequest,
+  model: string,
+  key: string,
+  baseUrl: string
+) {
+  const url = `${baseUrl}/models/${encodeURIComponent(model)}:streamGenerateContent?alt=sse&key=${key}`;
+  const reqBody = {
+    contents: toGeminiContents(body.messages),
+    generationConfig: {
+      temperature: body.temperature ?? 0.7,
+      maxOutputTokens: body.max_tokens
+    }
+  };
+
+  const resp = await fetch(url, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(reqBody)
+  });
+
+  if (!resp.ok) throw new ApiError(await resp.text(), resp.status);
+  if (!resp.body) throw new ApiError("No response body", 500);
+
+  yield createStartMessage(model);
+
+  const reader = resp.body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+
+  const parser = createParser((event) => {
+    if (event.type !== "event") return;
+    const data = event.data;
+    if (!data) return;
+    try {
+      const json = JSON.parse(data);
+      const text = json?.candidates?.[0]?.content?.parts?.map((p: any) => p?.text || "").join("") || "";
+      if (text) buffer += createDelta(text);
+    } catch {}
+  });
+
+  while (true) {
+    const { value, done } = await reader.read();
+    if (done) break;
+    parser.feed(decoder.decode(value));
+    if (buffer) {
+      yield buffer;
+      buffer = "";
+    }
+  }
+
+  yield createStopMessage();
+}
+
+// PassThrough (GLM, Anthropic, Minimax)
+export async function* streamPassThrough(
+  body: AnthropicRequest,
+  baseUrl: string,
+  headers: Record<string, string>
+) {
+  const url = `${baseUrl.endsWith("/") ? baseUrl.slice(0, -1) : baseUrl}/v1/messages`;
+  body.stream = true;
+
+  const resp = await fetch(url, {
+    method: "POST",
+    headers,
+    body: JSON.stringify(body)
+  });
+
+  if (!resp.ok) throw new ApiError(await resp.text(), resp.status);
+  if (!resp.body) throw new ApiError("No response body", 500);
+
+  const reader = resp.body.getReader();
+  while (true) {
+    const { value, done } = await reader.read();
+    if (done) break;
+    yield value;
+  }
+}