cc-x10ded 3.0.16 → 3.0.18

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,17 +24,35 @@ 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")
-  .action(async (options: { skipAliases?: boolean }) => {
+  .option("--skip-cleanup", "Skip removal of old binaries")
+  .action(async (options: { skipAliases?: boolean; skipCleanup?: boolean }) => {
     const { spawn } = await import("bun");
     const { ShellIntegrator } = await import("./core/shell");
     const pc = await import("picocolors");
 
-    console.log(pc.default.blue("Updating ccx..."));
+    const shellInt = new ShellIntegrator();
+    const shell = shellInt.detectShell();
+
+    if (!options.skipCleanup) {
+      const removed = await shellInt.cleanupOldBinaries();
+      if (removed.length > 0) {
+        console.log(pc.default.yellow("🧹 Removed old ccx binaries:"));
+        for (const p of removed) {
+          console.log(pc.default.dim(`   ${p}`));
+        }
+      }
+    }
 
-    // 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"]
     });
@@ -43,33 +65,45 @@ cli
 
     console.log(pc.default.green("✅ ccx updated!"));
 
-    // Always reinstall aliases (unless skipped)
-    if (!options.skipAliases) {
-      const shellInt = new ShellIntegrator();
-      const shell = shellInt.detectShell();
+    if (shell !== "unknown") {
+      await shellInt.ensureBunBinInPath(shell);
 
-      if (shell !== "unknown") {
-        // Ensure bun bin is in PATH
-        await shellInt.ensureBunBinInPath(shell);
+      if (!shellInt.isBunBinFirst()) {
+        console.log(pc.default.yellow("⚠️  ~/.bun/bin should be first in PATH for ccx to work correctly."));
+        console.log(pc.default.dim("   Add this to the TOP of your shell config:"));
+        console.log(pc.default.cyan('   export PATH="$HOME/.bun/bin:$PATH"'));
+      }
+    }
 
-        // Install/update aliases
-        const success = await shellInt.installAliases(shell);
-        if (success) {
-          console.log(pc.default.green("✅ Aliases updated!"));
-          console.log(pc.default.dim(`   Run: source ~/.${shell}rc (or restart your terminal)`));
-        }
+    if (!options.skipAliases && shell !== "unknown") {
+      const success = await shellInt.installAliases(shell);
+      if (success) {
+        console.log(pc.default.green("✅ Aliases updated!"));
       }
     }
 
     console.log(pc.default.green("\n🎉 Update complete!"));
+    if (shell !== "unknown") {
+      console.log(pc.default.dim(`   Run: source ~/.${shell}rc (or restart your terminal)`));
+    }
   });
 
 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({

package/src/types.ts

@@ -0,0 +1,71 @@
+export type LogLevel = "debug" | "info" | "warn" | "error";
+
+export interface TelemetryEvent {
+  type: string;
+  timestamp: number;
+  provider?: string;
+  model?: string;
+  latencyMs?: number;
+  success?: boolean;
+  errorCode?: string;
+  reason?: string;
+  fromProvider?: string;
+  toProvider?: string;
+}
+
+export interface ProviderInfo {
+  id: string;
+  name: string;
+  models: ModelInfo[];
+  isNative: boolean;
+  requiresKey: string;
+}
+
+export interface ModelInfo {
+  id: string;
+  name: string;
+  contextWindow?: number;
+  maxOutputTokens?: number;
+  capabilities?: readonly ("text" | "vision" | "tools")[];
+  default?: boolean;
+}
+
+export interface CircuitState {
+  provider: string;
+  state: "closed" | "open" | "half-open";
+  failures: number;
+  lastFailure: number | null;
+}
+
+export interface HealthStatus {
+  healthy: boolean;
+  latencyMs?: number;
+  error?: string;
+}
+
+export interface PluginConfig {
+  apiKey?: string;
+  baseUrl: string;
+  extra?: Record<string, unknown>;
+}
+
+export interface ProviderClient {
+  readonly provider: string;
+  streamComplete(request: object): AsyncGenerator<object>;
+  getModelInfo(): ModelInfo | undefined;
+  healthCheck(): Promise<HealthStatus>;
+}
+
+export interface ProviderPlugin {
+  id: string;
+  name: string;
+  version: string;
+  description?: string;
+  models: ModelInfo[];
+  createClient(config: PluginConfig): ProviderClient;
+}
+
+export interface SSEMessage {
+  type: string;
+  data: unknown;
+}