cc-x10ded 3.0.17 → 3.0.18

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/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();

package/src/core/logger.ts

@@ -0,0 +1,173 @@
+import type { LogLevel } from "../types";
+
+const LOG_LEVELS: LogLevel[] = ["debug", "info", "warn", "error"];
+
+export interface LogContext {
+  requestId?: string;
+  provider?: string;
+  model?: string;
+  port?: number;
+  command?: string;
+  [key: string]: unknown;
+}
+
+export interface LogEntry {
+  level: LogLevel;
+  time: string;
+  msg: string;
+  requestId?: string;
+  provider?: string;
+  model?: string;
+  port?: number;
+  command?: string;
+  error?: string;
+  stack?: string;
+  [key: string]: unknown;
+}
+
+export class Logger {
+  private level: LogLevel = "info";
+  private jsonMode: boolean = false;
+  private requestId: string | null = null;
+
+  constructor(options?: { level?: LogLevel; jsonMode?: boolean }) {
+    if (options?.level) this.level = options.level;
+    if (options?.jsonMode) this.jsonMode = options.jsonMode;
+    if (process.env.CCX_LOG_LEVEL) {
+      const envLevel = process.env.CCX_LOG_LEVEL as LogLevel;
+      if (LOG_LEVELS.includes(envLevel)) {
+        this.level = envLevel;
+      }
+    }
+    if (process.env.CCX_JSON_LOG === "1" || process.env.CCX_JSON_LOG === "true") {
+      this.jsonMode = true;
+    }
+  }
+
+  setJsonMode(enabled: boolean): void {
+    this.jsonMode = enabled;
+  }
+
+  setLevel(level: LogLevel): void {
+    this.level = level;
+  }
+
+  setRequestId(id: string): void {
+    this.requestId = id;
+  }
+
+  clearRequestId(): void {
+    this.requestId = null;
+  }
+
+  private shouldLog(level: LogLevel): boolean {
+    return LOG_LEVELS.indexOf(level) >= LOG_LEVELS.indexOf(this.level);
+  }
+
+  private formatLog(entry: LogEntry): string {
+    if (this.jsonMode) {
+      return JSON.stringify(entry);
+    }
+
+    const timeParts = entry.time.split("T");
+    const timestamp = timeParts[1]?.split(".")[0] || "00:00:00";
+    const parts = [timestamp];
+
+    const levelColors: Record<LogLevel, string> = {
+      debug: "\x1b[90m",
+      info: "\x1b[36m",
+      warn: "\x1b[33m",
+      error: "\x1b[31m",
+    };
+    const reset = "\x1b[0m";
+
+    parts.push(`${levelColors[entry.level]}[${entry.level.toUpperCase()}]${reset}`);
+
+    if (entry.provider) {
+      parts.push(`[${entry.provider}]`);
+    }
+
+    parts.push(entry.msg);
+
+    const contextParts: string[] = [];
+    if (entry.requestId) contextParts.push(`req=${entry.requestId}`);
+    if (entry.model) contextParts.push(`model=${entry.model}`);
+    if (entry.port) contextParts.push(`port=${entry.port}`);
+
+    if (contextParts.length > 0) {
+      parts.push(`\x1b[90m${contextParts.join(" ")}${reset}`);
+    }
+
+    if (entry.error) {
+      parts.push(`\x1b[31m${entry.error}${reset}`);
+    }
+
+    return parts.join(" ");
+  }
+
+  private createEntry(
+    level: LogLevel,
+    msg: string,
+    context?: LogContext,
+    error?: Error
+  ): LogEntry {
+    const entry: LogEntry = {
+      level,
+      time: new Date().toISOString(),
+      msg,
+    };
+
+    if (this.requestId) {
+      entry.requestId = this.requestId;
+    }
+
+    if (context) {
+      if (context.requestId && !entry.requestId) {
+        entry.requestId = context.requestId;
+      }
+      if (context.provider) entry.provider = context.provider;
+      if (context.model) entry.model = context.model;
+      if (context.port) entry.port = context.port;
+      if (context.command) entry.command = context.command;
+
+      for (const [key, value] of Object.entries(context)) {
+        if (!["requestId", "provider", "model", "port", "command"].includes(key)) {
+          entry[key] = value;
+        }
+      }
+    }
+
+    if (error) {
+      entry.error = error.message;
+      entry.stack = error.stack;
+    }
+
+    return entry;
+  }
+
+  debug(msg: string, context?: LogContext, error?: Error): void {
+    if (!this.shouldLog("debug")) return;
+    console.log(this.formatLog(this.createEntry("debug", msg, context, error)));
+  }
+
+  info(msg: string, context?: LogContext, error?: Error): void {
+    if (!this.shouldLog("info")) return;
+    console.log(this.formatLog(this.createEntry("info", msg, context, error)));
+  }
+
+  warn(msg: string, context?: LogContext, error?: Error): void {
+    if (!this.shouldLog("warn")) return;
+    console.warn(this.formatLog(this.createEntry("warn", msg, context, error)));
+  }
+
+  error(msg: string, context?: LogContext, error?: Error): void {
+    if (!this.shouldLog("error")) return;
+    console.error(this.formatLog(this.createEntry("error", msg, context, error)));
+  }
+}
+
+export function createLogger(options?: { level?: LogLevel; jsonMode?: boolean }): Logger {
+  return new Logger(options);
+}
+
+export const defaultLogger = createLogger();

package/src/core/plugins.ts

@@ -0,0 +1,138 @@
+import { join, dirname } from "path";
+import { existsSync, readdirSync, readFileSync } from "fs";
+import { homedir } from "os";
+import type { ProviderPlugin, ProviderInfo } from "../types";
+import { providerRegistry } from "./registry";
+import { createLogger } from "./logger";
+
+const logger = createLogger();
+
+interface PluginManifest {
+  id: string;
+  name: string;
+  version: string;
+  description?: string;
+  entry: string;
+}
+
+export class PluginManager {
+  private plugins: Map<string, ProviderPlugin> = new Map();
+  private pluginDir: string;
+  private static instance: PluginManager | null = null;
+
+  private constructor() {
+    this.pluginDir = join(homedir(), ".config", "claude-glm", "plugins");
+  }
+
+  static getInstance(): PluginManager {
+    if (!PluginManager.instance) {
+      PluginManager.instance = new PluginManager();
+    }
+    return PluginManager.instance;
+  }
+
+  async discoverAndLoad(): Promise<void> {
+    if (!existsSync(this.pluginDir)) {
+      logger.debug("Plugin directory does not exist", { path: this.pluginDir });
+      return;
+    }
+
+    const entries = readdirSync(this.pluginDir, { withFileTypes: true });
+
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+
+      const pluginPath = join(this.pluginDir, entry.name);
+      await this.loadPlugin(pluginPath);
+    }
+
+    logger.info("Plugin discovery complete", { count: this.plugins.size });
+  }
+
+  private async loadPlugin(pluginPath: string): Promise<void> {
+    const manifestPath = join(pluginPath, "plugin.json");
+
+    if (!existsSync(manifestPath)) {
+      logger.warn("Plugin missing manifest", { path: pluginPath });
+      return;
+    }
+
+    let manifest: PluginManifest;
+    try {
+      const content = readFileSync(manifestPath, "utf-8");
+      manifest = JSON.parse(content);
+    } catch (error) {
+      logger.warn("Failed to parse plugin manifest", { error: (error as Error).message });
+      return;
+    }
+
+    if (!manifest.id || !manifest.entry) {
+      logger.warn("Plugin manifest incomplete", { manifest });
+      return;
+    }
+
+    const entryPath = join(pluginPath, manifest.entry);
+    if (!existsSync(entryPath)) {
+      logger.warn("Plugin entry file not found", { entry: manifest.entry });
+      return;
+    }
+
+    try {
+      const pluginModule = await import(entryPath);
+      const plugin = pluginModule.default as ProviderPlugin;
+
+      if (!plugin.id || !plugin.name || !plugin.models || !plugin.createClient) {
+        logger.warn("Plugin missing required fields", { id: plugin.id });
+        return;
+      }
+
+      this.plugins.set(plugin.id, plugin);
+      providerRegistry.registerPlugin({
+        id: plugin.id,
+        name: plugin.name,
+        models: plugin.models,
+        isNative: false,
+        requiresKey: `plugins.${plugin.id}.apiKey`
+      });
+
+      logger.info("Plugin loaded", { id: plugin.id, name: plugin.name, version: plugin.version });
+    } catch (error) {
+      logger.warn("Failed to load plugin", { id: manifest.id, error: (error as Error).message });
+    }
+  }
+
+  getPlugins(): ProviderPlugin[] {
+    return Array.from(this.plugins.values());
+  }
+
+  getPlugin(id: string): ProviderPlugin | undefined {
+    return this.plugins.get(id);
+  }
+
+  isPluginLoaded(id: string): boolean {
+    return this.plugins.has(id);
+  }
+
+  async unloadPlugin(id: string): Promise<void> {
+    const plugin = this.plugins.get(id);
+    if (!plugin) return;
+
+    if (typeof (plugin as unknown as { onUnload?: () => Promise<void> }).onUnload === "function") {
+      try {
+        await (plugin as unknown as { onUnload: () => Promise<void> }).onUnload();
+      } catch (error) {
+        logger.warn("Plugin onUnload failed", { id, error: (error as Error).message });
+      }
+    }
+
+    this.plugins.delete(id);
+    providerRegistry.unregisterPlugin(id);
+    logger.info("Plugin unloaded", { id });
+  }
+
+  getPluginCount(): number {
+    return this.plugins.size;
+  }
+}
+
+export const pluginManager = PluginManager.getInstance();