cc-x10ded 3.0.17 → 3.0.18

package/src/core/registry.ts

@@ -0,0 +1,172 @@
+import type { ProviderInfo, ModelInfo } from "../types";
+
+const BUILTIN_PROVIDERS: ProviderInfo[] = [
+  {
+    id: "glm",
+    name: "GLM (Z.AI)",
+    models: [
+      { id: "glm-4.7", name: "GLM-4.7", default: true },
+      { id: "glm-4.6", name: "GLM-4.6" },
+      { id: "glm-4.5", name: "GLM-4.5" },
+      { id: "glm-4.5-air", name: "GLM-4.5-Air" }
+    ],
+    isNative: false,
+    requiresKey: "zaiApiKey"
+  },
+  {
+    id: "minimax",
+    name: "Minimax",
+    models: [
+      { id: "MiniMax-M2.1", name: "MiniMax-M2.1", default: true },
+      { id: "MiniMax-M2.1-32k", name: "MiniMax-M2.1-32k" }
+    ],
+    isNative: false,
+    requiresKey: "minimaxApiKey"
+  },
+  {
+    id: "openai",
+    name: "OpenAI",
+    models: [
+      { id: "gpt-4o", name: "GPT-4o", default: true },
+      { id: "gpt-4o-mini", name: "GPT-4o Mini" },
+      { id: "gpt-4-turbo", name: "GPT-4 Turbo" }
+    ],
+    isNative: false,
+    requiresKey: "providers.openai.apiKey"
+  },
+  {
+    id: "anthropic",
+    name: "Anthropic (Claude Code)",
+    models: [
+      { id: "claude-sonnet-4-20250514", name: "Claude Sonnet 4", default: true },
+      { id: "claude-haiku-4-20250514", name: "Claude Haiku 4" },
+      { id: "claude-opus-4-20250514", name: "Claude Opus 4" }
+    ],
+    isNative: true,
+    requiresKey: "providers.anthropic.apiKey"
+  },
+  {
+    id: "gemini",
+    name: "Google Gemini",
+    models: [
+      { id: "gemini-2.0-flash", name: "Gemini 2.0 Flash", default: true },
+      { id: "gemini-1.5-pro", name: "Gemini 1.5 Pro" }
+    ],
+    isNative: false,
+    requiresKey: "providers.gemini.apiKey"
+  },
+  {
+    id: "openrouter",
+    name: "OpenRouter",
+    models: [
+      { id: "openrouter.auto", name: "Auto-Select", default: true },
+      { id: "anthropic/claude-sonnet-4", name: "Anthropic Sonnet" }
+    ],
+    isNative: false,
+    requiresKey: "providers.openrouter.apiKey"
+  }
+];
+
+const DEFAULT_PROVIDER_ORDER = ["glm", "minimax", "openai", "gemini", "openrouter", "anthropic"];
+
+export class ProviderRegistry {
+  private providers: Map<string, ProviderInfo> = new Map();
+  private plugins: Map<string, ProviderInfo> = new Map();
+
+  constructor() {
+    for (const provider of BUILTIN_PROVIDERS) {
+      this.providers.set(provider.id, provider);
+    }
+  }
+
+  registerPlugin(plugin: ProviderInfo): void {
+    this.plugins.set(plugin.id, plugin);
+  }
+
+  unregisterPlugin(pluginId: string): void {
+    this.plugins.delete(pluginId);
+  }
+
+  listProviders(): ProviderInfo[] {
+    const all: ProviderInfo[] = [];
+    for (const id of DEFAULT_PROVIDER_ORDER) {
+      const builtin = this.providers.get(id);
+      const plugin = this.plugins.get(id);
+      if (builtin) all.push(builtin);
+      if (plugin) all.push(plugin);
+    }
+    for (const [id, plugin] of this.plugins) {
+      if (!DEFAULT_PROVIDER_ORDER.includes(id)) {
+        all.push(plugin);
+      }
+    }
+    return all;
+  }
+
+  getProvider(id: string): ProviderInfo | null {
+    return this.providers.get(id) || this.plugins.get(id) || null;
+  }
+
+  getProviderOrder(): string[] {
+    const order: string[] = [];
+    for (const id of DEFAULT_PROVIDER_ORDER) {
+      if (this.providers.has(id) || this.plugins.has(id)) {
+        order.push(id);
+      }
+    }
+    for (const id of this.plugins.keys()) {
+      if (!DEFAULT_PROVIDER_ORDER.includes(id) && !order.includes(id)) {
+        order.push(id);
+      }
+    }
+    return order;
+  }
+
+  getDefaultProvider(): ProviderInfo | null {
+    const order = this.getProviderOrder();
+    for (const id of order) {
+      const provider = this.getProvider(id);
+      if (provider) {
+        const defaultModel = provider.models.find(m => m.default);
+        if (defaultModel) {
+          return provider;
+        }
+      }
+    }
+    return null;
+  }
+
+  getDefaultModelForProvider(providerId: string): ModelInfo | null {
+    const provider = this.getProvider(providerId);
+    if (!provider) return null;
+    return provider.models.find(m => m.default) || provider.models[0] || null;
+  }
+
+  getModel(providerId: string, modelId: string): ModelInfo | null {
+    const provider = this.getProvider(providerId);
+    if (!provider) return null;
+    return provider.models.find(m => m.id === modelId) || null;
+  }
+
+  getAllModels(): Array<{ provider: ProviderInfo; model: ModelInfo }> {
+    const all: Array<{ provider: ProviderInfo; model: ModelInfo }> = [];
+    for (const provider of this.listProviders()) {
+      for (const model of provider.models) {
+        all.push({ provider, model });
+      }
+    }
+    return all;
+  }
+
+  isNative(providerId: string): boolean {
+    const provider = this.getProvider(providerId);
+    return provider?.isNative ?? false;
+  }
+
+  requiresKey(providerId: string): string | null {
+    const provider = this.getProvider(providerId);
+    return provider?.requiresKey ?? null;
+  }
+}
+
+export const providerRegistry = new ProviderRegistry();

package/src/core/telemetry.ts

@@ -0,0 +1,253 @@
+import { join } from "path";
+import { existsSync, writeFileSync, readFileSync } from "fs";
+import { homedir } from "os";
+import type { TelemetryEvent } from "../types";
+import { createLogger } from "./logger";
+
+const logger = createLogger();
+
+export interface TelemetryData {
+  sessionId: string;
+  sessionStart: number;
+  requests: TelemetryRequest[];
+  errors: TelemetryError[];
+  fallbacks: TelemetryFallback[];
+}
+
+interface TelemetryRequest {
+  provider: string;
+  model: string;
+  latencyMs: number;
+  success: boolean;
+  timestamp: number;
+  errorCode?: string;
+}
+
+interface TelemetryError {
+  provider: string;
+  error: string;
+  count: number;
+}
+
+interface TelemetryFallback {
+  fromProvider: string;
+  toProvider: string;
+  reason: string;
+  timestamp: number;
+}
+
+export class Telemetry {
+  private data: TelemetryData;
+  private telemetryDir: string;
+  private telemetryFile: string;
+  private enabled: boolean = true;
+  private static instance: Telemetry | null = null;
+
+  private constructor() {
+    this.telemetryDir = join(homedir(), ".config", "claude-glm");
+    this.telemetryFile = join(this.telemetryDir, "telemetry.json");
+    this.data = this.loadOrCreate();
+  }
+
+  static getInstance(): Telemetry {
+    if (!Telemetry.instance) {
+      Telemetry.instance = new Telemetry();
+    }
+    return Telemetry.instance;
+  }
+
+  private loadOrCreate(): TelemetryData {
+    if (!existsSync(this.telemetryDir)) {
+      return this.createNewSession();
+    }
+
+    try {
+      if (existsSync(this.telemetryFile)) {
+        const content = readFileSync(this.telemetryFile, "utf-8");
+        const data = JSON.parse(content) as TelemetryData;
+        const sessionAge = Date.now() - data.sessionStart;
+        const ONE_DAY = 24 * 60 * 60 * 1000;
+
+        if (sessionAge > ONE_DAY) {
+          return this.createNewSession();
+        }
+        return data;
+      }
+    } catch (error) {
+      logger.warn("Failed to load telemetry data", { error: (error as Error).message });
+    }
+
+    return this.createNewSession();
+  }
+
+  private createNewSession(): TelemetryData {
+    return {
+      sessionId: this.generateSessionId(),
+      sessionStart: Date.now(),
+      requests: [],
+      errors: [],
+      fallbacks: []
+    };
+  }
+
+  private generateSessionId(): string {
+    const array = new Uint8Array(16);
+    crypto.getRandomValues(array);
+    return Array.from(array, byte => byte.toString(16).padStart(2, "0")).join("");
+  }
+
+  private save(): void {
+    try {
+      writeFileSync(this.telemetryFile, JSON.stringify(this.data, null, 2));
+    } catch (error) {
+      logger.warn("Failed to save telemetry data", { error: (error as Error).message });
+    }
+  }
+
+  disable(): void {
+    this.enabled = false;
+  }
+
+  isEnabled(): boolean {
+    return this.enabled;
+  }
+
+  trackRequest(
+    provider: string,
+    model: string,
+    latencyMs: number,
+    success: boolean,
+    errorCode?: string
+  ): void {
+    if (!this.enabled) return;
+
+    const request: TelemetryRequest = {
+      provider,
+      model,
+      latencyMs,
+      success,
+      timestamp: Date.now()
+    };
+
+    if (errorCode) {
+      request.errorCode = errorCode;
+      this.trackError(provider, errorCode);
+    }
+
+    this.data.requests.push(request);
+    this.save();
+  }
+
+  private trackError(provider: string, error: string): void {
+    const existing = this.data.errors.find(e => e.provider === provider && e.error === error);
+    if (existing) {
+      existing.count++;
+    } else {
+      this.data.errors.push({ provider, error, count: 1 });
+    }
+  }
+
+  trackFallback(fromProvider: string, toProvider: string, reason: string): void {
+    if (!this.enabled) return;
+
+    this.data.fallbacks.push({
+      fromProvider,
+      toProvider,
+      reason,
+      timestamp: Date.now()
+    });
+    this.save();
+  }
+
+  trackEvent(event: Omit<TelemetryEvent, "timestamp">): void {
+    if (!this.enabled) return;
+
+    const fullEvent: TelemetryEvent = {
+      ...event,
+      timestamp: Date.now()
+    };
+
+    switch (event.type) {
+      case "request_complete":
+        if (event.provider && event.model && event.latencyMs !== undefined) {
+          this.trackRequest(
+            event.provider,
+            event.model,
+            event.latencyMs,
+            event.success ?? true,
+            event.errorCode
+          );
+        }
+        break;
+      case "fallback":
+        if (event.fromProvider && event.toProvider) {
+          this.trackFallback(event.fromProvider, event.toProvider, event.reason || "unknown");
+        }
+        break;
+    }
+  }
+
+  getSessionId(): string {
+    return this.data.sessionId;
+  }
+
+  getSessionStart(): number {
+    return this.data.sessionStart;
+  }
+
+  getRequestCount(): number {
+    return this.data.requests.length;
+  }
+
+  getRequests(): TelemetryRequest[] {
+    return [...this.data.requests];
+  }
+
+  getErrors(): TelemetryError[] {
+    return [...this.data.errors];
+  }
+
+  getFallbacks(): TelemetryFallback[] {
+    return [...this.data.fallbacks];
+  }
+
+  getProviderStats(): Record<string, { count: number; avgLatency: number; errors: number }> {
+    const stats: Record<string, { count: number; totalLatency: number; errors: number }> = {};
+
+    for (const request of this.data.requests) {
+      if (!stats[request.provider]) {
+        stats[request.provider] = { count: 0, totalLatency: 0, errors: 0 };
+      }
+      const providerStats = stats[request.provider];
+      if (providerStats) {
+        providerStats.count++;
+        providerStats.totalLatency += request.latencyMs;
+        if (!request.success) {
+          providerStats.errors++;
+        }
+      }
+    }
+
+    const result: Record<string, { count: number; avgLatency: number; errors: number }> = {};
+    for (const [provider, stat] of Object.entries(stats)) {
+      result[provider] = {
+        count: stat.count,
+        avgLatency: Math.round(stat.totalLatency / stat.count),
+        errors: stat.errors
+      };
+    }
+
+    return result;
+  }
+
+  getSessionDuration(): number {
+    return Date.now() - this.data.sessionStart;
+  }
+
+  clear(): void {
+    this.data = this.createNewSession();
+    this.save();
+  }
+}
+
+export const telemetry = Telemetry.getInstance();

package/src/index.ts

@@ -4,7 +4,11 @@ import { runCommand } from "./commands/run";
 import { setupCommand } from "./commands/setup";
 import { configCommand } from "./commands/config";
 import { doctorCommand } from "./commands/doctor";
+import { modelsCommand } from "./commands/models";
 import packageJson from "../package.json";
+import { createLogger } from "./core/logger";
+
+const logger = createLogger();
 
 const cli = cac("ccx");
 
@@ -20,6 +24,12 @@ cli
   .command("doctor", "Run self-diagnostics")
   .action(doctorCommand);
 
+cli
+  .command("models", "List all available models")
+  .action(async () => {
+    await modelsCommand();
+  });
+
 cli
   .command("update", "Update ccx to the latest version")
   .option("--skip-aliases", "Skip alias installation")
@@ -32,16 +42,16 @@ cli
     const shellInt = new ShellIntegrator();
     const shell = shellInt.detectShell();
 
-    // 1. Clean up old binaries first
     if (!options.skipCleanup) {
       const removed = await shellInt.cleanupOldBinaries();
       if (removed.length > 0) {
         console.log(pc.default.yellow("🧹 Removed old ccx binaries:"));
-        removed.forEach(p => console.log(pc.default.dim(`   ${p}`)));
+        for (const p of removed) {
+          console.log(pc.default.dim(`   ${p}`));
+        }
       }
     }
 
-    // 2. Update via bun global install
     console.log(pc.default.blue("📦 Updating ccx..."));
     const proc = spawn(["bun", "install", "-g", "cc-x10ded@latest"], {
       stdio: ["inherit", "inherit", "inherit"]
@@ -55,7 +65,6 @@ cli
 
     console.log(pc.default.green("✅ ccx updated!"));
 
-    // 3. Ensure bun bin is in PATH (and prioritized)
     if (shell !== "unknown") {
       await shellInt.ensureBunBinInPath(shell);
 
@@ -66,7 +75,6 @@ cli
       }
     }
 
-    // 4. Reinstall aliases (unless skipped)
     if (!options.skipAliases && shell !== "unknown") {
       const success = await shellInt.installAliases(shell);
       if (success) {
@@ -84,8 +92,18 @@ 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)")
+  .option("--json-log", "Output logs in JSON format")
   .action((args, options) => {
-    runCommand(args, options);
+    if (options.jsonLog) {
+      logger.setJsonMode(true);
+    }
+    runCommand(args, { model: options.model, port: options.port });
+  });
+
+cli
+  .command("--list", "List all available models (alias for 'models')")
+  .action(async () => {
+    await modelsCommand();
   });
 
 cli.help();

package/src/proxy/map.ts

@@ -80,8 +80,26 @@ export function toOpenAIMessages(messages: AnthropicMessage[]) {
 }
 
 export function toGeminiContents(messages: AnthropicMessage[]) {
-  return messages.map((m) => ({
-    role: m.role === "assistant" ? "model" : "user",
-    parts: [{ text: toPlainText(m.content) }]
-  }));
+  let systemInstruction: string | null = null;
+  const mappedMessages: Array<{ role: string; parts: Array<{ text: string }> }> = [];
+
+  for (const m of messages) {
+    if (m.role === "system") {
+      systemInstruction = toPlainText(m.content);
+    } else {
+      mappedMessages.push({
+        role: m.role === "assistant" ? "model" : "user",
+        parts: [{ text: toPlainText(m.content) }]
+      });
+    }
+  }
+
+  if (systemInstruction && mappedMessages.length > 0) {
+    const firstMessage = mappedMessages[0];
+    if (firstMessage) {
+      firstMessage.parts.unshift({ text: `[System Instruction: ${systemInstruction}] ` });
+    }
+  }
+
+  return mappedMessages;
 }

package/src/proxy/providers.ts

@@ -1,7 +1,9 @@
 import { createParser } from "eventsource-parser";
 import type { AnthropicRequest } from "./types";
 import { toOpenAIMessages, toGeminiContents } from "./map";
-import { createStartMessage, createDelta, createStopMessage, ApiError } from "./utils";
+import { createStartMessage, createDelta, createStopMessage, ApiError, parseErrorResponse } from "./utils";
+
+const MAX_BUFFER_SIZE = 65536;
 
 // OpenAI
 export async function* streamOpenAI(
@@ -27,14 +29,14 @@ export async function* streamOpenAI(
     body: JSON.stringify(reqBody)
   });
 
-  if (!resp.ok) throw new ApiError(await resp.text(), resp.status);
+   if (!resp.ok) throw new ApiError(parseErrorResponse(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
+  let buffer = "";
 
   const parser = createParser(((event: any) => {
     if (event.type !== "event") return;
@@ -51,7 +53,10 @@ export async function* streamOpenAI(
     const { value, done } = await reader.read();
     if (done) break;
     parser.feed(decoder.decode(value));
-    if (buffer) {
+    if (buffer.length >= MAX_BUFFER_SIZE) {
+      yield buffer;
+      buffer = "";
+    } else if (buffer) {
       yield buffer;
       buffer = "";
     }
@@ -82,7 +87,7 @@ export async function* streamGemini(
     body: JSON.stringify(reqBody)
   });
 
-  if (!resp.ok) throw new ApiError(await resp.text(), resp.status);
+   if (!resp.ok) throw new ApiError(parseErrorResponse(await resp.text()), resp.status);
   if (!resp.body) throw new ApiError("No response body", 500);
 
   yield createStartMessage(model);
@@ -106,7 +111,10 @@ export async function* streamGemini(
     const { value, done } = await reader.read();
     if (done) break;
     parser.feed(decoder.decode(value));
-    if (buffer) {
+    if (buffer.length >= MAX_BUFFER_SIZE) {
+      yield buffer;
+      buffer = "";
+    } else if (buffer) {
       yield buffer;
       buffer = "";
     }
@@ -130,7 +138,7 @@ export async function* streamPassThrough(
     body: JSON.stringify(body)
   });
 
-  if (!resp.ok) throw new ApiError(await resp.text(), resp.status);
+   if (!resp.ok) throw new ApiError(parseErrorResponse(await resp.text()), resp.status);
   if (!resp.body) throw new ApiError("No response body", 500);
 
   const reader = resp.body.getReader();

package/src/proxy/server.ts

@@ -6,7 +6,7 @@ import type { Config } from "../core/config";
 import type { AnthropicRequest } from "./types";
 
 export function startProxyServer(config: Config, port: number = 17870) {
-  return serve({
+  const server = serve({
     port,
     hostname: "127.0.0.1",
     async fetch(req) {
@@ -85,4 +85,14 @@ export function startProxyServer(config: Config, port: number = 17870) {
       }
     },
   });
+
+  const shutdown = () => {
+    server.stop();
+    process.exit(0);
+  };
+
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+
+  return server;
 }

package/src/proxy/types.ts

@@ -6,7 +6,7 @@ export interface ProviderModel {
 }
 
 export interface AnthropicMessage {
-  role: "user" | "assistant";
+  role: "user" | "assistant" | "system";
   content: string | Array<{ type: "text"; text: string } | { type: "tool_result"; content: string | any }>;
 }
 

package/src/proxy/utils.ts

@@ -53,6 +53,16 @@ export class ApiError extends Error {
   }
 }
 
+export function parseErrorResponse(text: string): string {
+  try {
+    const json = JSON.parse(text);
+    if (json.error?.message) return json.error.message;
+    if (json.message) return json.message;
+    if (json.error) return typeof json.error === "string" ? json.error : JSON.stringify(json.error);
+  } catch {}
+  return text;
+}
+
 // Convert an async generator to a ReadableStream
 export function toReadableStream<T>(gen: AsyncGenerator<T>): ReadableStream<T> {
   return new ReadableStream({