cc-x10ded 3.0.16 → 3.0.18

package/src/commands/doctor.ts

@@ -1,73 +1,203 @@
 import { intro, outro, spinner } from "@clack/prompts";
 import { ShellIntegrator } from "../core/shell";
 import { ConfigManager } from "../core/config";
+import { telemetry } from "../core/telemetry";
+import { circuitBreaker } from "../core/circuit-breaker";
+import { pluginManager } from "../core/plugins";
 import * as pc from "picocolors";
 import { existsSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
 
 export async function doctorCommand() {
   intro(pc.bgBlue(pc.white(" ccx Doctor 🩺 ")));
 
   const s = spinner();
   const issues: string[] = [];
+  const warnings: string[] = [];
   const checks: string[] = [];
+  const home = homedir();
 
-  // 1. Check Config
+  // 1. Check for old/shadowing binaries
+  s.start("Checking for conflicting binaries...");
+  const oldLocations = [
+    join(home, ".local", "bin", "ccx"),
+    join(home, ".npm-global", "bin", "ccx"),
+    join(home, "bin", "ccx"),
+  ];
+
+  const foundOld: string[] = [];
+  for (const loc of oldLocations) {
+    if (existsSync(loc)) foundOld.push(loc);
+  }
+
+  if (foundOld.length > 0) {
+    issues.push("❌ Old ccx binaries found that may shadow the new one:");
+    for (const p of foundOld) {
+      issues.push(`   ${p}`);
+    }
+    issues.push("   👉 Run 'ccx update' to remove them automatically");
+  } else {
+    checks.push("✅ No conflicting binaries");
+  }
+  s.stop("Binary check complete");
+
+  // 2. Check PATH priority
+  s.start("Checking PATH configuration...");
+  const shellInt = new ShellIntegrator();
+
+  if (!shellInt.isBunBinFirst()) {
+    warnings.push("⚠️  ~/.bun/bin is not first in PATH");
+    warnings.push("   This may cause the wrong ccx to run.");
+    warnings.push('   👉 Add to TOP of your shell config: export PATH="$HOME/.bun/bin:$PATH"');
+  } else {
+    checks.push("✅ PATH is correctly configured");
+  }
+  s.stop("PATH check complete");
+
+  // 3. Check Config
   s.start("Checking configuration...");
   const configManager = new ConfigManager();
   const config = await configManager.read();
-  
+
   if (!config.zaiApiKey && !config.minimaxApiKey && Object.keys(config.providers).length === 0) {
-      issues.push("❌ No API keys configured. Run 'ccx setup'.");
+    issues.push("❌ No API keys configured. Run 'ccx setup'.");
   } else {
-      checks.push("✅ Configuration loaded");
+    const keys: string[] = [];
+    if (config.zaiApiKey) keys.push("Z.AI");
+    if (config.minimaxApiKey) keys.push("Minimax");
+    if (config.providers.openai?.apiKey) keys.push("OpenAI");
+    if (config.providers.gemini?.apiKey) keys.push("Gemini");
+    checks.push(`✅ API keys configured: ${keys.join(", ")}`);
   }
   s.stop("Configuration check complete");
 
-  // 2. Check Claude Binary
+  // 4. Check Claude Binary
   s.start("Checking Claude Code installation...");
-  const shellInt = new ShellIntegrator();
   const claudePath = await shellInt.findClaudeBinary();
-  
+
   if (claudePath) {
-      checks.push(`✅ Claude binary found: ${claudePath}`);
+    checks.push(`✅ Claude binary: ${claudePath}`);
   } else {
-      issues.push("❌ 'claude' command not found in common locations.");
-      issues.push("   👉 Suggestion: Run 'npm install -g @anthropic-ai/claude-code'");
+    issues.push("❌ 'claude' command not found.");
+    issues.push("   👉 Run: npm install -g @anthropic-ai/claude-code");
   }
   s.stop("Claude check complete");
 
-  // 3. Check Shell Integration
+  // 5. Check Shell Integration
   s.start("Checking shell integration...");
   const shell = shellInt.detectShell();
   const profile = shellInt.getProfilePath(shell);
-  
+
   if (shell === "unknown") {
-      issues.push("⚠️  Could not detect shell type.");
+    warnings.push("⚠️  Could not detect shell type.");
   } else {
-      checks.push(`✅ Shell detected: ${shell}`);
-      if (profile && existsSync(profile)) {
-          const content = await Bun.file(profile).text();
-          if (content.includes("ccx")) {
-              checks.push("✅ Aliases found in profile");
-          } else {
-              issues.push(`⚠️  Aliases missing in ${profile}. Run 'ccx setup'.`);
-          }
+    checks.push(`✅ Shell: ${shell}`);
+    if (profile && existsSync(profile)) {
+      const content = await Bun.file(profile).text();
+      if (content.includes("claude-glm-wrapper")) {
+        if (content.includes("bunx cc-x10ded")) {
+          warnings.push("⚠️  Old bunx-based aliases detected");
+          warnings.push("   👉 Run 'ccx update' to migrate to faster direct aliases");
+        } else {
+          checks.push("✅ Aliases installed (new format)");
+        }
+      } else {
+        warnings.push(`⚠️  Aliases missing. Run 'ccx setup' to install.`);
       }
+    }
   }
   s.stop("Shell check complete");
 
-  // 4. Check Network/Proxy (Port 17870)
-  // We won't actually bind, just check if we can
-  
+  // 6. Telemetry (Local)
+  s.start("Checking telemetry...");
+  const sessionDuration = telemetry.getSessionDuration();
+  const requestCount = telemetry.getRequestCount();
+  const providerStats = telemetry.getProviderStats();
+  const errors = telemetry.getErrors();
+  const fallbacks = telemetry.getFallbacks();
+
+  console.log("\n" + pc.bold("Telemetry (this session):"));
+  console.log(`  Session: ${Math.round(sessionDuration / 1000)}s | Requests: ${requestCount}`);
+
+  if (Object.keys(providerStats).length > 0) {
+    console.log("\n  Provider Usage:");
+    for (const [provider, stats] of Object.entries(providerStats)) {
+      const statusIcon = stats.errors > 0 ? "🔴" : "🟢";
+      console.log(`  ${statusIcon} ${provider}: ${stats.count} requests (avg ${stats.avgLatency}ms)${stats.errors > 0 ? `, ${stats.errors} errors` : ""}`);
+    }
+  }
+
+  if (errors.length > 0) {
+    console.log("\n  Errors:");
+    for (const error of errors) {
+      console.log(`    ${error.provider}: ${error.error} (${error.count})`);
+    }
+  }
+
+  if (fallbacks.length > 0) {
+    console.log("\n  Fallbacks:");
+    for (const fallback of fallbacks) {
+      console.log(`    ${fallback.fromProvider} → ${fallback.toProvider} (${fallback.reason})`);
+    }
+  }
+
+  if (requestCount === 0) {
+    console.log("  No requests yet in this session.");
+  }
+  s.stop("Telemetry check complete");
+
+  // 7. Circuit Breaker Status
+  s.start("Checking circuit breaker...");
+  const circuitStates = circuitBreaker.getStates();
+  if (circuitStates.length > 0) {
+    console.log("\n" + pc.bold("Circuit Breaker Status:"));
+    for (const state of circuitStates) {
+      const icon = state.state === "closed" ? "🟢" : state.state === "half-open" ? "🟡" : "🔴";
+      console.log(`  ${icon} ${state.provider}: ${state.state} (${state.failures} failures)`);
+    }
+  } else {
+    console.log("  No circuit breaker activity yet.");
+  }
+  s.stop("Circuit breaker check complete");
+
+  // 8. Plugins
+  s.start("Checking plugins...");
+  const pluginCount = pluginManager.getPluginCount();
+  if (pluginCount > 0) {
+    const plugins = pluginManager.getPlugins();
+    console.log(`\n  Installed Plugins: ${pluginCount}`);
+    for (const plugin of plugins) {
+      console.log(`    - ${plugin.name} v${plugin.version}`);
+    }
+  } else {
+    console.log("  No plugins installed.");
+  }
+  s.stop("Plugin check complete");
+
+  // Report
   console.log("\n" + pc.bold("Diagnostic Report:"));
-  checks.forEach(c => console.log(c));
-  console.log("");
-  
+  for (const c of checks) {
+    console.log(c);
+  }
+
+  if (warnings.length > 0) {
+    console.log("");
+    for (const w of warnings) {
+      console.log(pc.yellow(w));
+    }
+  }
+
   if (issues.length > 0) {
-      issues.forEach(i => console.log(i));
-      outro(pc.yellow("Issues found. Please resolve them above."));
-      process.exit(1);
+    console.log("");
+    for (const i of issues) {
+      console.log(pc.red(i));
+    }
+    outro(pc.red("Issues found. Please resolve them above."));
+    process.exit(1);
+  } else if (warnings.length > 0) {
+    outro(pc.yellow("Some warnings. ccx should work, but consider fixing them."));
   } else {
-      outro(pc.green("All systems operational! 🚀"));
+    outro(pc.green("All systems operational! 🚀"));
   }
 }

package/src/commands/models.ts

@@ -0,0 +1,71 @@
+import { providerRegistry } from "../core/registry";
+import { pluginManager } from "../core/plugins";
+import { createLogger } from "../core/logger";
+
+const logger = createLogger();
+
+export async function modelsCommand(): Promise<void> {
+  console.log("\n");
+
+  const providers = providerRegistry.listProviders();
+  const plugins = pluginManager.getPlugins();
+
+  const allModels = providerRegistry.getAllModels();
+
+  const maxProviderWidth = Math.max(
+    ...providers.map(p => p.name.length),
+    ...plugins.map(p => p.name.length)
+  );
+  const maxModelWidth = Math.max(
+    ...allModels.map(m => `${m.provider.id}:${m.model.id}`.length),
+    30
+  );
+
+  console.log("╔" + "═".repeat(maxProviderWidth + maxModelWidth + 7) + "╗");
+  console.log("║" + " ".repeat(Math.floor((maxProviderWidth + maxModelWidth + 7 - 26) / 2)) + "ccx Available Models" + " ".repeat(Math.ceil((maxProviderWidth + maxModelWidth + 7 - 26) / 2)) + "║");
+  console.log("╠" + "═".repeat(maxProviderWidth + maxModelWidth + 7) + "╣");
+
+  for (const provider of providers) {
+    const statusIcon = provider.isNative ? "🔵" : "🟢";
+    const keyHint = provider.isNative ? "[Native - No proxy needed]" : `[Requires: ${provider.requiresKey.split(".").pop()?.replace("ApiKey", "_KEY") || "key"}]`;
+
+    console.log("║");
+    console.log(`║  ${statusIcon} ${provider.name.padEnd(maxProviderWidth)} ${keyHint}`);
+
+    for (const model of provider.models) {
+      const defaultMark = model.default ? " (default)" : "";
+      const modelLine = `  ├── ${model.id}${defaultMark}`;
+      console.log(`║  ${modelLine.padEnd(maxProviderWidth + maxModelWidth + 3)}║`);
+    }
+  }
+
+  console.log("║");
+  console.log("╠" + "═".repeat(maxProviderWidth + maxModelWidth + 7) + "╣");
+
+  if (plugins.length > 0) {
+    console.log("║");
+    console.log("║  Installed Plugins (" + plugins.length + ")");
+
+    for (const plugin of plugins) {
+      console.log(`║  ├── ${plugin.name} v${plugin.version}`);
+      for (const model of plugin.models) {
+        const modelLine = `  │   ├── ${model.id}`;
+        console.log(`║  ${modelLine.padEnd(maxProviderWidth + maxModelWidth + 3)}║`);
+      }
+    }
+  } else {
+    console.log("║");
+    console.log("║  Plugins: 0 installed");
+    console.log("║  To add a plugin, create: ~/.config/claude-glm/plugins/<name>/");
+  }
+
+  console.log("║");
+  console.log("╚" + "═".repeat(maxProviderWidth + maxModelWidth + 7) + "╝");
+  console.log("\n");
+  console.log("Usage:");
+  console.log("  ccx                    # Interactive selection");
+  console.log("  ccx --model=glm-4.7    # Use specific model");
+  console.log("  ccx --list             # Show this list");
+  console.log("  ccx setup              # Configure API keys");
+  console.log("\n");
+}

package/src/commands/run.ts

@@ -2,10 +2,14 @@ import { spawn } from "bun";
 import { ConfigManager } from "../core/config";
 import { startProxyServer } from "../proxy/server";
 import { ShellIntegrator } from "../core/shell";
+import { pluginManager } from "../core/plugins";
 import { parseProviderModel } from "../proxy/map";
+import { telemetry } from "../core/telemetry";
 import * as pc from "picocolors";
 
 export async function runCommand(args: string[], options: { model?: string; port?: number }) {
+  await pluginManager.discoverAndLoad();
+
   const configManager = new ConfigManager();
   const config = await configManager.read();
 
@@ -13,53 +17,51 @@ export async function runCommand(args: string[], options: { model?: string; port
     console.log(pc.yellow("Configuration missing. Running setup..."));
     const { setupCommand } = await import("./setup");
     await setupCommand();
-    // Re-read config
     Object.assign(config, await configManager.read());
   }
 
   const model = options.model || config.defaults.model || "glm-4.7";
   const { provider } = parseProviderModel(model);
-  
-  // Check if we should use the proxy or fallback to native Claude (for Anthropic without API Key)
+
   let useProxy = true;
-  if (provider === "anthropic" && !config.providers.anthropic?.apiKey) {
-      useProxy = false;
+
+  if (provider === "anthropic") {
+    useProxy = false;
   }
 
-  // Port hunting logic
   let port = options.port || 17870;
-  let server;
-  
+  let server: ReturnType<typeof startProxyServer> | undefined = undefined;
+
   if (useProxy) {
     let retries = 0;
     while (retries < 10) {
-        try {
-            server = startProxyServer(config, port);
-            break;
-        } catch (e: any) {
-            if (e.code === "EADDRINUSE" || e.message.includes("EADDRINUSE")) {
-                port++;
-                retries++;
-            } else {
-                throw e;
-            }
+      try {
+        server = startProxyServer(config, port);
+        break;
+      } catch (e: unknown) {
+        const error = e as { code?: string; message?: string };
+        if (error.code === "EADDRINUSE" || (error.message && error.message.includes("EADDRINUSE"))) {
+          port++;
+          retries++;
+        } else {
+          throw e;
         }
+      }
     }
-    
+
     if (!server) {
-        console.error(pc.red(`Failed to start proxy server after 10 attempts (ports ${options.port || 17870}-${port}).`));
-        process.exit(1);
+      console.error(pc.red(`Failed to start proxy server after 10 attempts (ports ${options.port || 17870}-${port}).`));
+      process.exit(1);
     }
   }
 
-  // Robust binary finding
   const shellInt = new ShellIntegrator();
   const claudePath = await shellInt.findClaudeBinary();
 
   if (!claudePath) {
-      console.error(pc.red("Error: 'claude' command not found."));
-      console.error(pc.yellow("Self-Healing Tip: Run 'ccx setup' or 'npm install -g @anthropic-ai/claude-code'"));
-      process.exit(1);
+    console.error(pc.red("Error: 'claude' command not found."));
+    console.error(pc.yellow("Self-Healing Tip: Run 'ccx setup' or 'npm install -g @anthropic-ai/claude-code'"));
+    process.exit(1);
   }
 
   const env: Record<string, string | undefined> = {
@@ -67,9 +69,9 @@ export async function runCommand(args: string[], options: { model?: string; port
   };
 
   if (useProxy) {
-      env.ANTHROPIC_BASE_URL = `http://127.0.0.1:${port}`;
-      env.ANTHROPIC_AUTH_TOKEN = "ccx-proxy-token"; // Dummy token for the client
-      env.ANTHROPIC_MODEL = model;
+    env.ANTHROPIC_BASE_URL = `http://127.0.0.1:${port}`;
+    env.ANTHROPIC_AUTH_TOKEN = `ccx-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
+    env.ANTHROPIC_MODEL = model;
   }
 
   try {
@@ -85,5 +87,6 @@ export async function runCommand(args: string[], options: { model?: string; port
     process.exit(1);
   } finally {
     if (server) server.stop();
+    telemetry.trackEvent({ type: "session_end" });
   }
 }

package/src/commands/setup.ts

@@ -88,21 +88,32 @@ export async function setupCommand() {
     if (mmKey) config.minimaxApiKey = mmKey as string;
   }
 
-  // 4. Install ccx globally
+  // 4. Clean up old binaries and install ccx globally
   const s2 = spinner();
-  s2.start("Installing ccx globally...");
+  s2.start("Cleaning up old installations...");
+
+  // Remove old binaries that might shadow the new one
+  const removed = await shellInt.cleanupOldBinaries();
+  if (removed.length > 0) {
+    s2.stop(pc.yellow(`Removed ${removed.length} old ccx binary(s)`));
+  } else {
+    s2.stop("No old binaries found");
+  }
+
+  const s3 = spinner();
+  s3.start("Installing ccx globally...");
   try {
     const proc = spawn(["bun", "install", "-g", "cc-x10ded@latest"], {
       stdio: ["ignore", "ignore", "ignore"]
     });
     await proc.exited;
     if (proc.exitCode === 0) {
-      s2.stop(pc.green("ccx installed globally!"));
+      s3.stop(pc.green("ccx installed globally!"));
     } else {
-      s2.stop(pc.yellow("Global install may have failed. You can still use: bunx cc-x10ded"));
+      s3.stop(pc.yellow("Global install may have failed. You can still use: bunx cc-x10ded"));
     }
   } catch {
-    s2.stop(pc.yellow("Could not install globally (bun not found?). Use: bunx cc-x10ded"));
+    s3.stop(pc.yellow("Could not install globally (bun not found?). Use: bunx cc-x10ded"));
   }
 
   // 5. Shell Config

package/src/core/circuit-breaker.ts

@@ -0,0 +1,167 @@
+import type { CircuitState } from "../types";
+import { providerRegistry } from "./registry";
+import { telemetry } from "./telemetry";
+import { createLogger } from "./logger";
+
+const logger = createLogger();
+
+const CIRCUIT_THRESHOLD = 5;
+const CIRCUIT_TIMEOUT = 30000;
+
+export class CircuitBreaker {
+  private states: Map<string, CircuitState> = new Map();
+  private static instance: CircuitBreaker | null = null;
+
+  private constructor() {}
+
+  static getInstance(): CircuitBreaker {
+    if (!CircuitBreaker.instance) {
+      CircuitBreaker.instance = new CircuitBreaker();
+    }
+    return CircuitBreaker.instance;
+  }
+
+  private getState(provider: string): CircuitState {
+    let state = this.states.get(provider);
+    if (!state) {
+      state = {
+        provider,
+        state: "closed",
+        failures: 0,
+        lastFailure: null
+      };
+      this.states.set(provider, state);
+    }
+    return state;
+  }
+
+  isOpen(provider: string): boolean {
+    const state = this.getState(provider);
+    if (state.state === "open") {
+      const timeSinceFailure = Date.now() - (state.lastFailure || 0);
+      if (timeSinceFailure > CIRCUIT_TIMEOUT) {
+        state.state = "half-open";
+        logger.debug("Circuit breaker transitioning to half-open", { provider });
+        return false;
+      }
+      return true;
+    }
+    return false;
+  }
+
+  isClosed(provider: string): boolean {
+    return this.getState(provider).state === "closed";
+  }
+
+  async execute<T>(
+    provider: string,
+    fn: () => Promise<T>
+  ): Promise<T> {
+    const state = this.getState(provider);
+
+    if (state.state === "open") {
+      const timeSinceFailure = Date.now() - (state.lastFailure || 0);
+      if (timeSinceFailure > CIRCUIT_TIMEOUT) {
+        state.state = "half-open";
+        logger.debug("Circuit breaker transitioning to half-open", { provider });
+      } else {
+        const fallbackProvider = this.getFallbackProvider(provider);
+        if (fallbackProvider) {
+          logger.warn("Circuit open, falling back", { from: provider, to: fallbackProvider });
+          telemetry.trackEvent({
+            type: "fallback",
+            fromProvider: provider,
+            toProvider: fallbackProvider,
+            reason: "circuit_open"
+          });
+          return this.execute(fallbackProvider, fn);
+        }
+        throw new CircuitOpenError(provider, CIRCUIT_TIMEOUT - timeSinceFailure);
+      }
+    }
+
+    try {
+      const result = await fn();
+      this.recordSuccess(provider);
+      return result;
+    } catch (error) {
+      this.recordFailure(provider, error as Error);
+      throw error;
+    }
+  }
+
+  private getFallbackProvider(currentProvider: string): string | null {
+    const order = providerRegistry.getProviderOrder();
+    const currentIndex = order.indexOf(currentProvider);
+
+    for (let i = currentIndex + 1; i < order.length; i++) {
+      const candidate = order[i];
+      if (candidate && !this.isOpen(candidate) && !providerRegistry.isNative(candidate)) {
+        return candidate;
+      }
+    }
+
+    for (const provider of order) {
+      if (provider !== currentProvider && !this.isOpen(provider) && !providerRegistry.isNative(provider)) {
+        return provider;
+      }
+    }
+
+    return null;
+  }
+
+  private recordSuccess(provider: string): void {
+    const state = this.getState(provider);
+
+    if (state.state === "half-open") {
+      state.state = "closed";
+      state.failures = 0;
+      state.lastFailure = null;
+      logger.debug("Circuit breaker closed", { provider });
+    } else if (state.state === "closed" && state.failures > 0) {
+      state.failures = Math.max(0, state.failures - 1);
+    }
+  }
+
+  private recordFailure(provider: string, error: Error): void {
+    const state = this.getState(provider);
+    state.failures++;
+    state.lastFailure = Date.now();
+
+    if (state.failures >= CIRCUIT_THRESHOLD && state.state !== "open") {
+      state.state = "open";
+      logger.warn("Circuit breaker opened", { provider, failures: state.failures });
+    }
+  }
+
+  reset(provider: string): void {
+    const state = this.getState(provider);
+    state.state = "closed";
+    state.failures = 0;
+    state.lastFailure = null;
+  }
+
+  resetAll(): void {
+    this.states.clear();
+  }
+
+  getStates(): CircuitState[] {
+    return Array.from(this.states.values());
+  }
+
+  getStateInfo(provider: string): CircuitState {
+    return this.getState(provider);
+  }
+}
+
+export class CircuitOpenError extends Error {
+  constructor(
+    public readonly provider: string,
+    public readonly retryAfterMs: number
+  ) {
+    super(`Circuit open for ${provider}. Retry after ${Math.ceil(retryAfterMs / 1000)}s`);
+    this.name = "CircuitOpenError";
+  }
+}
+
+export const circuitBreaker = CircuitBreaker.getInstance();