cc-x10ded 3.0.16 → 3.0.18

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

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/shell.ts

@@ -180,6 +180,53 @@ Function ccm { ccx --model=MiniMax-M2.1 @args }`;
       return await this.installAliases(shell);
   }
 
+  /**
+   * Remove old ccx binaries from common locations that might shadow the bun global
+   */
+  async cleanupOldBinaries(): Promise<string[]> {
+    const removed: string[] = [];
+    const oldLocations = [
+      join(this.home, ".local", "bin", "ccx"),
+      join(this.home, ".npm-global", "bin", "ccx"),
+      join(this.home, "bin", "ccx"),
+      "/usr/local/bin/ccx",
+    ];
+
+    for (const loc of oldLocations) {
+      if (existsSync(loc)) {
+        try {
+          const { unlinkSync } = await import("fs");
+          unlinkSync(loc);
+          removed.push(loc);
+        } catch {
+          // Ignore permission errors
+        }
+      }
+    }
+
+    return removed;
+  }
+
+  /**
+   * Check if bun bin is properly prioritized in PATH
+   */
+  isBunBinFirst(): boolean {
+    const bunBin = join(this.home, ".bun", "bin");
+    const path = process.env.PATH || "";
+    const paths = path.split(":");
+
+    // Check if bun bin comes before other common locations
+    const bunIndex = paths.findIndex(p => p.includes(".bun/bin"));
+    const localIndex = paths.findIndex(p => p.includes(".local/bin"));
+    const npmGlobalIndex = paths.findIndex(p => p.includes(".npm-global/bin"));
+
+    if (bunIndex === -1) return false;
+    if (localIndex !== -1 && localIndex < bunIndex) return false;
+    if (npmGlobalIndex !== -1 && npmGlobalIndex < bunIndex) return false;
+
+    return true;
+  }
+
   /**
    * Hunt for the 'claude' binary in common locations
    */