ccjk 9.0.3 → 9.1.0

package/dist/chunks/ccjk-hooks.mjs

@@ -629,6 +629,8 @@ async function validateGitTrigger(pattern, condition, projectInfo) {
   const validGitHooks = [
     "pre-commit",
     "post-commit",
+    "commit-msg",
+    "prepare-commit-msg",
     "pre-push",
     "post-push",
     "pre-merge",
@@ -636,7 +638,13 @@ async function validateGitTrigger(pattern, condition, projectInfo) {
     "pre-rebase",
     "post-rebase",
     "pre-checkout",
-    "post-checkout"
+    "post-checkout",
+    "pre-receive",
+    "post-receive",
+    "update",
+    "pre-applypatch",
+    "post-applypatch",
+    "applypatch-msg"
   ];
   if (!validGitHooks.includes(pattern)) {
     throw new Error(`Invalid git hook: ${pattern}`);

package/dist/chunks/fs-operations.mjs

@@ -106,6 +106,18 @@ function readJsonFile(path) {
     );
   }
 }
+function writeJsonFile(path, data, pretty = true) {
+  try {
+    const content = pretty ? JSON.stringify(data, null, 2) : JSON.stringify(data);
+    writeFile(path, content, "utf-8");
+  } catch (error) {
+    throw new FileSystemError(
+      `Failed to write JSON file: ${path}`,
+      path,
+      error
+    );
+  }
+}
 function copyFile(src, dest) {
   try {
     ensureFileDir(dest);
@@ -177,4 +189,4 @@ function copyDir(src, dest, options = {}) {
   }
 }
 
-export { FileSystemError, copyDir, copyFile, ensureDir, ensureFileDir, exists, getStatsSafe, readDir, readFile, readJsonFile, removeFile, writeFile, writeFileAtomic, writeFileAtomicAsync };
+export { FileSystemError, copyDir, copyFile, ensureDir, ensureFileDir, exists, getStatsSafe, readDir, readFile, readJsonFile, removeFile, writeFile, writeFileAtomic, writeFileAtomicAsync, writeJsonFile };

package/dist/chunks/package.mjs

@@ -1,4 +1,4 @@
-const version = "9.0.3";
+const version = "9.1.0";
 const homepage = "https://github.com/miounet11/ccjk";
 
 export { homepage, version };

package/dist/chunks/quick-provider.mjs

@@ -0,0 +1,899 @@
+import ansis from 'ansis';
+import inquirer from 'inquirer';
+import ora from 'ora';
+
+function isValidApiUrl(url) {
+  try {
+    const parsed = new URL(url);
+    return parsed.protocol === "https:" || parsed.protocol === "http:";
+  } catch {
+    return false;
+  }
+}
+
+const DEFAULT_TIMEOUT = 3e4;
+const DEFAULT_RETRY_ATTEMPTS = 3;
+const DEFAULT_RETRY_DELAY = 1e3;
+class CloudApiClient {
+  baseUrl;
+  timeout;
+  authToken;
+  userAgent;
+  retry;
+  /**
+   * Create a new CloudApiClient instance
+   *
+   * @param config - Client configuration
+   */
+  constructor(config) {
+    this.baseUrl = config.baseUrl.replace(/\/$/, "");
+    this.timeout = config.timeout || DEFAULT_TIMEOUT;
+    this.authToken = config.authToken;
+    this.userAgent = config.userAgent || "CCJK-Client/1.0";
+    this.retry = config.retry || {
+      maxAttempts: DEFAULT_RETRY_ATTEMPTS,
+      delay: DEFAULT_RETRY_DELAY
+    };
+  }
+  // ==========================================================================
+  // Configuration Methods
+  // ==========================================================================
+  /**
+   * Set authentication token
+   *
+   * @param token - Authentication token
+   */
+  setAuthToken(token) {
+    this.authToken = token;
+  }
+  /**
+   * Clear authentication token
+   */
+  clearAuthToken() {
+    this.authToken = void 0;
+  }
+  /**
+   * Get current base URL
+   */
+  getBaseUrl() {
+    return this.baseUrl;
+  }
+  /**
+   * Update base URL
+   *
+   * @param url - New base URL
+   */
+  setBaseUrl(url) {
+    this.baseUrl = url.replace(/\/$/, "");
+  }
+  // ==========================================================================
+  // Request Methods
+  // ==========================================================================
+  /**
+   * Make an HTTP request to the cloud service
+   *
+   * @param path - API endpoint path (e.g., '/plugins/recommend')
+   * @param options - Request options
+   * @returns API response
+   *
+   * @example
+   * ```typescript
+   * const response = await client.request<{ data: string }>('/api/endpoint', {
+   *   method: 'POST',
+   *   body: { key: 'value' },
+   *   timeout: 5000
+   * })
+   * ```
+   */
+  async request(path, options) {
+    const maxAttempts = options.retry?.maxAttempts || this.retry.maxAttempts;
+    const retryDelay = options.retry?.delay || this.retry.delay;
+    let lastError = null;
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+      try {
+        return await this.executeRequest(path, options);
+      } catch (error) {
+        lastError = error instanceof Error ? error : new Error(String(error));
+        if (attempt === maxAttempts || this.isClientError(lastError)) {
+          break;
+        }
+        await this.sleep(retryDelay * attempt);
+      }
+    }
+    return {
+      success: false,
+      error: lastError?.message || "Request failed",
+      code: "REQUEST_FAILED"
+    };
+  }
+  /**
+   * Execute a single HTTP request
+   *
+   * @private
+   */
+  async executeRequest(path, options) {
+    const url = this.buildUrl(path, options.query);
+    const timeout = options.timeout || this.timeout;
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeout);
+    try {
+      const headers = this.buildHeaders(options);
+      const response = await fetch(url, {
+        method: options.method,
+        headers,
+        body: options.body ? JSON.stringify(options.body) : void 0,
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      const data = await response.json();
+      if (!response.ok) {
+        return {
+          success: false,
+          error: data.error || `HTTP ${response.status}: ${response.statusText}`,
+          code: data.code || `HTTP_${response.status}`
+        };
+      }
+      return {
+        ...data,
+        success: true
+      };
+    } catch (error) {
+      clearTimeout(timeoutId);
+      if (error instanceof Error) {
+        if (error.name === "AbortError") {
+          return {
+            success: false,
+            error: "Request timeout",
+            code: "TIMEOUT"
+          };
+        }
+        return {
+          success: false,
+          error: error.message,
+          code: "NETWORK_ERROR"
+        };
+      }
+      return {
+        success: false,
+        error: String(error),
+        code: "UNKNOWN_ERROR"
+      };
+    }
+  }
+  // ==========================================================================
+  // Convenience Methods
+  // ==========================================================================
+  /**
+   * Make a GET request
+   *
+   * @param path - API endpoint path
+   * @param query - Query parameters
+   * @param options - Additional request options
+   * @returns API response
+   */
+  async get(path, query, options) {
+    return this.request(path, {
+      method: "GET",
+      query,
+      ...options
+    });
+  }
+  /**
+   * Make a POST request
+   *
+   * @param path - API endpoint path
+   * @param body - Request body
+   * @param options - Additional request options
+   * @returns API response
+   */
+  async post(path, body, options) {
+    return this.request(path, {
+      method: "POST",
+      body,
+      ...options
+    });
+  }
+  /**
+   * Make a PUT request
+   *
+   * @param path - API endpoint path
+   * @param body - Request body
+   * @param options - Additional request options
+   * @returns API response
+   */
+  async put(path, body, options) {
+    return this.request(path, {
+      method: "PUT",
+      body,
+      ...options
+    });
+  }
+  /**
+   * Make a DELETE request
+   *
+   * @param path - API endpoint path
+   * @param options - Additional request options
+   * @returns API response
+   */
+  async delete(path, options) {
+    return this.request(path, {
+      method: "DELETE",
+      ...options
+    });
+  }
+  // ==========================================================================
+  // Helper Methods
+  // ==========================================================================
+  /**
+   * Build full URL with query parameters
+   *
+   * @private
+   */
+  buildUrl(path, query) {
+    const url = `${this.baseUrl}${path}`;
+    if (!query || Object.keys(query).length === 0) {
+      return url;
+    }
+    const params = new URLSearchParams();
+    for (const [key, value] of Object.entries(query)) {
+      params.append(key, String(value));
+    }
+    return `${url}?${params.toString()}`;
+  }
+  /**
+   * Build request headers
+   *
+   * @private
+   */
+  buildHeaders(options) {
+    const headers = {
+      "Content-Type": "application/json",
+      "User-Agent": this.userAgent,
+      ...options.headers
+    };
+    const token = options.authToken || this.authToken;
+    if (token) {
+      headers.Authorization = `Bearer ${token}`;
+    }
+    return headers;
+  }
+  /**
+   * Check if error is a client error (4xx)
+   *
+   * @private
+   */
+  isClientError(error) {
+    return error.message.includes("HTTP 4");
+  }
+  /**
+   * Sleep for specified milliseconds
+   *
+   * @private
+   */
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+}
+function createApiClient(config) {
+  return new CloudApiClient(config);
+}
+
+const CLOUD_API_BASE_URL = "https://api.claudehome.cn/v1";
+const REQUEST_TIMEOUT = 1e4;
+const BUILTIN_PROVIDERS = {
+  "302": {
+    shortcode: "302",
+    name: "302.AI",
+    apiUrl: "https://api.302.ai",
+    description: "302.AI \u4E2D\u8F6C\u670D\u52A1 - \u652F\u6301\u591A\u79CD\u6A21\u578B",
+    models: ["gpt-4", "gpt-4-turbo", "gpt-3.5-turbo", "claude-3-opus", "claude-3-sonnet"],
+    verified: true,
+    category: "relay",
+    status: "active",
+    createdAt: "2024-01-01T00:00:00Z"
+  },
+  "glm": {
+    shortcode: "glm",
+    name: "\u667A\u8C31AI",
+    apiUrl: "https://open.bigmodel.cn/api/paas/v4",
+    description: "\u667A\u8C31 GLM \u5927\u6A21\u578B",
+    models: ["glm-4", "glm-4-plus", "glm-3-turbo"],
+    verified: true,
+    category: "domestic",
+    status: "active",
+    createdAt: "2024-01-01T00:00:00Z"
+  },
+  "kimi": {
+    shortcode: "kimi",
+    name: "\u6708\u4E4B\u6697\u9762 Kimi",
+    apiUrl: "https://api.moonshot.cn/v1",
+    description: "Moonshot Kimi \u5927\u6A21\u578B",
+    models: ["moonshot-v1-8k", "moonshot-v1-32k", "moonshot-v1-128k"],
+    verified: true,
+    category: "domestic",
+    status: "active",
+    createdAt: "2024-01-01T00:00:00Z"
+  },
+  "minimax": {
+    shortcode: "minimax",
+    name: "MiniMax",
+    apiUrl: "https://api.minimax.chat/v1",
+    description: "MiniMax \u5927\u6A21\u578B",
+    models: ["abab5.5-chat", "abab6-chat", "abab6.5-chat"],
+    verified: true,
+    category: "domestic",
+    status: "active",
+    createdAt: "2024-01-01T00:00:00Z"
+  },
+  "deepseek": {
+    shortcode: "deepseek",
+    name: "DeepSeek",
+    apiUrl: "https://api.deepseek.com/v1",
+    description: "DeepSeek \u5927\u6A21\u578B",
+    models: ["deepseek-chat", "deepseek-coder"],
+    verified: true,
+    category: "domestic",
+    status: "active",
+    createdAt: "2024-01-01T00:00:00Z"
+  },
+  "qwen": {
+    shortcode: "qwen",
+    name: "\u901A\u4E49\u5343\u95EE",
+    apiUrl: "https://dashscope.aliyuncs.com/compatible-mode/v1",
+    description: "\u963F\u91CC\u901A\u4E49\u5343\u95EE\u5927\u6A21\u578B",
+    models: ["qwen-turbo", "qwen-plus", "qwen-max"],
+    verified: true,
+    category: "domestic",
+    status: "active",
+    createdAt: "2024-01-01T00:00:00Z"
+  }
+};
+class ProviderRegistryService {
+  client;
+  useCloud = true;
+  constructor(options) {
+    this.client = createApiClient({
+      baseUrl: options?.baseUrl || CLOUD_API_BASE_URL,
+      timeout: REQUEST_TIMEOUT,
+      userAgent: "CCJK-QuickLaunch/1.0"
+    });
+    this.useCloud = options?.useCloud ?? true;
+  }
+  // ==========================================================================
+  // Query Methods
+  // ==========================================================================
+  /**
+   * Get provider by shortcode
+   *
+   * First tries cloud registry, falls back to built-in providers.
+   *
+   * @param shortcode - Provider shortcode (e.g., "302", "glm")
+   * @returns Provider info or null if not found
+   */
+  async getProvider(shortcode) {
+    const normalizedCode = shortcode.toLowerCase().trim();
+    if (this.useCloud) {
+      try {
+        const response = await this.client.get(
+          `/providers/${encodeURIComponent(normalizedCode)}`
+        );
+        if (response.success && response.data?.data) {
+          return response.data.data;
+        }
+      } catch {
+      }
+    }
+    return BUILTIN_PROVIDERS[normalizedCode] || null;
+  }
+  /**
+   * Check if shortcode exists
+   *
+   * @param shortcode - Provider shortcode to check
+   * @returns true if exists, false otherwise
+   */
+  async exists(shortcode) {
+    const provider = await this.getProvider(shortcode);
+    return provider !== null;
+  }
+  /**
+   * Check if shortcode is available for registration
+   *
+   * @param shortcode - Provider shortcode to check
+   * @returns true if available, false if taken
+   */
+  async isAvailable(shortcode) {
+    return !await this.exists(shortcode);
+  }
+  // ==========================================================================
+  // Registration Methods
+  // ==========================================================================
+  /**
+   * Create a new provider in the cloud registry
+   *
+   * @param input - Provider creation data
+   * @returns Created provider or error
+   */
+  async createProvider(input) {
+    if (!this.useCloud) {
+      return {
+        success: false,
+        error: {
+          code: "CLOUD_DISABLED",
+          message: "Cloud service is disabled"
+        }
+      };
+    }
+    try {
+      const response = await this.client.post(
+        "/providers",
+        input
+      );
+      if (response.success && response.data) {
+        return response.data;
+      }
+      return {
+        success: false,
+        error: {
+          code: response.code || "CREATE_FAILED",
+          message: response.error || "Failed to create provider"
+        }
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: {
+          code: "NETWORK_ERROR",
+          message: error instanceof Error ? error.message : "Network error"
+        }
+      };
+    }
+  }
+  // ==========================================================================
+  // List Methods
+  // ==========================================================================
+  /**
+   * List all available providers
+   *
+   * @param options - List options
+   * @returns List of providers
+   */
+  async listProviders(options) {
+    if (this.useCloud) {
+      try {
+        const query = {};
+        if (options?.category) query.category = options.category;
+        if (options?.verified !== void 0) query.verified = options.verified;
+        if (options?.limit) query.limit = options.limit;
+        const response = await this.client.get(
+          "/providers",
+          query
+        );
+        if (response.success && response.data?.data?.providers) {
+          return response.data.data.providers;
+        }
+      } catch {
+      }
+    }
+    let providers = Object.values(BUILTIN_PROVIDERS);
+    if (options?.category) {
+      providers = providers.filter((p) => p.category === options.category);
+    }
+    if (options?.verified !== void 0) {
+      providers = providers.filter((p) => p.verified === options.verified);
+    }
+    if (options?.limit) {
+      providers = providers.slice(0, options.limit);
+    }
+    return providers;
+  }
+  /**
+   * Get built-in provider (always available, no network)
+   *
+   * @param shortcode - Provider shortcode
+   * @returns Built-in provider or null
+   */
+  getBuiltinProvider(shortcode) {
+    return BUILTIN_PROVIDERS[shortcode.toLowerCase()] || null;
+  }
+  /**
+   * List all built-in providers
+   *
+   * @returns Array of built-in providers
+   */
+  listBuiltinProviders() {
+    return Object.values(BUILTIN_PROVIDERS);
+  }
+  // ==========================================================================
+  // Configuration
+  // ==========================================================================
+  /**
+   * Enable or disable cloud service
+   */
+  setUseCloud(enabled) {
+    this.useCloud = enabled;
+  }
+  /**
+   * Check if cloud service is enabled
+   */
+  isCloudEnabled() {
+    return this.useCloud;
+  }
+}
+let _instance = null;
+function getProviderRegistry() {
+  if (!_instance) {
+    _instance = new ProviderRegistryService();
+  }
+  return _instance;
+}
+
+const KNOWN_COMMANDS = /* @__PURE__ */ new Set([
+  // Core commands
+  "",
+  "init",
+  "update",
+  "doctor",
+  "help",
+  // Extended commands
+  "serve",
+  "mcp",
+  "browser",
+  "interview",
+  "commit",
+  "config",
+  "daemon",
+  "providers",
+  "task",
+  "tasks",
+  "keybinding",
+  "kb",
+  "history",
+  "hist",
+  "ccr",
+  "vim",
+  "permissions",
+  "perm",
+  "skills",
+  "sk",
+  "skill",
+  "agent",
+  "ag",
+  "ccu",
+  "stats",
+  "uninstall",
+  "check-updates",
+  "check",
+  "config-switch",
+  "cs",
+  "workflows",
+  "wf",
+  "notification",
+  "notify",
+  "session",
+  "context",
+  "ctx",
+  "api",
+  "team",
+  "thinking",
+  "think",
+  "postmortem",
+  "pm",
+  "claude",
+  "monitor",
+  // CCJK v8 commands
+  "ccjk:mcp",
+  "ccjk-mcp",
+  "ccjk:skills",
+  "ccjk-skills",
+  "ccjk:agents",
+  "ccjk-agents",
+  "ccjk:hooks",
+  "ccjk-hooks",
+  "ccjk:all",
+  "ccjk-all",
+  "ccjk:setup",
+  "ccjk-setup",
+  // Special commands
+  "cloud",
+  "system",
+  "sys",
+  "plugin",
+  "completion",
+  // Deprecated but still recognized
+  "skills-sync",
+  "agents-sync",
+  "marketplace",
+  "quick",
+  "deep",
+  "setup",
+  "sync",
+  "versions",
+  "upgrade",
+  "config-scan",
+  "workspace"
+]);
+function isKnownCommand(arg) {
+  if (!arg) return true;
+  if (arg.startsWith("-")) return true;
+  return KNOWN_COMMANDS.has(arg.toLowerCase());
+}
+function couldBeShortcode(arg) {
+  if (!arg) return false;
+  if (arg.startsWith("-")) return false;
+  if (isKnownCommand(arg)) return false;
+  return /^[a-z0-9][a-z0-9-]{0,18}[a-z0-9]?$/i.test(arg);
+}
+async function quickProviderLaunch(shortcode, options = {}) {
+  const registry = getProviderRegistry();
+  const normalizedCode = shortcode.toLowerCase().trim();
+  console.log();
+  const spinner = ora({
+    text: ansis.gray(`\u6B63\u5728\u67E5\u8BE2\u4F9B\u5E94\u5546 "${normalizedCode}"...`),
+    color: "cyan"
+  }).start();
+  try {
+    const provider = await registry.getProvider(normalizedCode);
+    spinner.stop();
+    if (provider) {
+      return await handleExistingProvider(provider, options);
+    } else {
+      return await handleNewProvider(normalizedCode, options);
+    }
+  } catch (error) {
+    spinner.fail(ansis.red("\u67E5\u8BE2\u5931\u8D25"));
+    console.error(ansis.gray(error instanceof Error ? error.message : "\u7F51\u7EDC\u9519\u8BEF"));
+    return false;
+  }
+}
+async function handleExistingProvider(provider, options) {
+  console.log(ansis.cyan.bold(`
+\u{1F680} \u5FEB\u901F\u914D\u7F6E: ${provider.name}`));
+  console.log(ansis.gray("\u2500".repeat(40)));
+  console.log(`   ${ansis.yellow("\u77ED\u7801:")} ${provider.shortcode}`);
+  console.log(`   ${ansis.yellow("API URL:")} ${provider.apiUrl}`);
+  if (provider.description) {
+    console.log(`   ${ansis.yellow("\u63CF\u8FF0:")} ${provider.description}`);
+  }
+  if (provider.verified) {
+    console.log(`   ${ansis.green("\u2713")} \u5B98\u65B9\u9A8C\u8BC1`);
+  }
+  console.log();
+  const { confirmed } = await inquirer.prompt([
+    {
+      type: "confirm",
+      name: "confirmed",
+      message: `\u662F\u5426\u4F7F\u7528 ${ansis.cyan(provider.name)} \u4F5C\u4E3A API \u4F9B\u5E94\u5546?`,
+      default: true
+    }
+  ]);
+  if (!confirmed) {
+    console.log(ansis.gray("\n\u5DF2\u53D6\u6D88\uFF0C\u8FDB\u5165\u4E3B\u83DC\u5355...\n"));
+    return false;
+  }
+  const config = await configureProvider(provider);
+  if (config) {
+    await saveProviderConfig(config);
+    showSuccessMessage(config);
+    return true;
+  }
+  return false;
+}
+async function handleNewProvider(shortcode, options) {
+  console.log(ansis.yellow(`
+\u26A0\uFE0F  \u4F9B\u5E94\u5546 "${shortcode}" \u5C1A\u672A\u6CE8\u518C`));
+  console.log(ansis.gray("\u8BE5\u77ED\u7801\u5728\u4E91\u7AEF\u6CE8\u518C\u8868\u4E2D\u4E0D\u5B58\u5728\n"));
+  const { createNew } = await inquirer.prompt([
+    {
+      type: "confirm",
+      name: "createNew",
+      message: "\u662F\u5426\u521B\u5EFA\u8BE5\u4F9B\u5E94\u5546?",
+      default: false
+    }
+  ]);
+  if (!createNew) {
+    console.log(ansis.gray("\n\u5DF2\u53D6\u6D88\uFF0C\u8FDB\u5165\u4E3B\u83DC\u5355...\n"));
+    return false;
+  }
+  const { name, apiUrl } = await inquirer.prompt([
+    {
+      type: "input",
+      name: "name",
+      message: "\u4F9B\u5E94\u5546\u540D\u79F0:",
+      default: shortcode.toUpperCase(),
+      validate: (value) => {
+        if (!value.trim()) return "\u540D\u79F0\u4E0D\u80FD\u4E3A\u7A7A";
+        if (value.length > 50) return "\u540D\u79F0\u8FC7\u957F\uFF08\u6700\u591A50\u5B57\u7B26\uFF09";
+        return true;
+      }
+    },
+    {
+      type: "input",
+      name: "apiUrl",
+      message: "API URL (\u5982 https://api.example.com/v1):",
+      validate: (value) => {
+        if (!value.trim()) return "URL \u4E0D\u80FD\u4E3A\u7A7A";
+        if (!isValidApiUrl(value)) return "\u8BF7\u8F93\u5165\u6709\u6548\u7684 URL\uFF08http:// \u6216 https://\uFF09";
+        return true;
+      }
+    }
+  ]);
+  const spinner = ora("\u6B63\u5728\u6CE8\u518C\u4F9B\u5E94\u5546...").start();
+  try {
+    const registry = getProviderRegistry();
+    const result = await registry.createProvider({
+      shortcode,
+      name: name.trim(),
+      apiUrl: apiUrl.trim()
+    });
+    if (result.success && result.data) {
+      spinner.succeed(ansis.green("\u4F9B\u5E94\u5546\u6CE8\u518C\u6210\u529F!"));
+      const config = await configureProvider(result.data, options);
+      if (config) {
+        await saveProviderConfig(config);
+        showSuccessMessage(config);
+        return true;
+      }
+    } else {
+      spinner.fail(ansis.red("\u6CE8\u518C\u5931\u8D25"));
+      console.error(ansis.gray(result.error?.message || "\u672A\u77E5\u9519\u8BEF"));
+      const { continueLocal } = await inquirer.prompt([
+        {
+          type: "confirm",
+          name: "continueLocal",
+          message: "\u662F\u5426\u4ECD\u7136\u4F7F\u7528\u6B64\u914D\u7F6E\uFF08\u4EC5\u672C\u5730\uFF09?",
+          default: true
+        }
+      ]);
+      if (continueLocal) {
+        const localProvider = {
+          shortcode,
+          name: name.trim(),
+          apiUrl: apiUrl.trim(),
+          verified: false,
+          createdAt: (/* @__PURE__ */ new Date()).toISOString()
+        };
+        const config = await configureProvider(localProvider, options);
+        if (config) {
+          await saveProviderConfig(config);
+          showSuccessMessage(config);
+          return true;
+        }
+      }
+    }
+  } catch (error) {
+    spinner.fail(ansis.red("\u6CE8\u518C\u5931\u8D25"));
+    console.error(ansis.gray(error instanceof Error ? error.message : "\u7F51\u7EDC\u9519\u8BEF"));
+  }
+  return false;
+}
+async function configureProvider(provider, _options) {
+  console.log(ansis.cyan("\n\u{1F4DD} \u914D\u7F6E API \u51ED\u8BC1"));
+  console.log(ansis.gray("\u2500".repeat(40)));
+  const { apiKey } = await inquirer.prompt([
+    {
+      type: "password",
+      name: "apiKey",
+      message: "API Key:",
+      mask: "*",
+      validate: (value) => {
+        if (!value.trim()) return "API Key \u4E0D\u80FD\u4E3A\u7A7A";
+        if (value.length < 10) return "API Key \u683C\u5F0F\u4E0D\u6B63\u786E";
+        return true;
+      }
+    }
+  ]);
+  let model;
+  if (provider.models && provider.models.length > 0) {
+    const { modelChoice } = await inquirer.prompt([
+      {
+        type: "list",
+        name: "modelChoice",
+        message: "\u9009\u62E9\u6A21\u578B:",
+        choices: [
+          ...provider.models.map((m) => ({
+            name: m,
+            value: m
+          })),
+          {
+            name: ansis.gray("\u81EA\u5B9A\u4E49..."),
+            value: "__custom__"
+          }
+        ]
+      }
+    ]);
+    if (modelChoice === "__custom__") {
+      const { customModel } = await inquirer.prompt([
+        {
+          type: "input",
+          name: "customModel",
+          message: "\u8F93\u5165\u6A21\u578B\u540D\u79F0:",
+          validate: (value) => {
+            if (!value.trim()) return "\u6A21\u578B\u540D\u79F0\u4E0D\u80FD\u4E3A\u7A7A";
+            return true;
+          }
+        }
+      ]);
+      model = customModel;
+    } else {
+      model = modelChoice;
+    }
+  } else {
+    const { inputModel } = await inquirer.prompt([
+      {
+        type: "input",
+        name: "inputModel",
+        message: "\u6A21\u578B\u540D\u79F0 (\u5982 gpt-4, claude-3-opus):",
+        default: "gpt-4",
+        validate: (value) => {
+          if (!value.trim()) return "\u6A21\u578B\u540D\u79F0\u4E0D\u80FD\u4E3A\u7A7A";
+          return true;
+        }
+      }
+    ]);
+    model = inputModel;
+  }
+  return {
+    shortcode: provider.shortcode,
+    provider,
+    apiKey: apiKey.trim(),
+    model: model.trim()
+  };
+}
+async function saveProviderConfig(config) {
+  const spinner = ora("\u6B63\u5728\u4FDD\u5B58\u914D\u7F6E...").start();
+  try {
+    const { readJsonFile, writeJsonFile } = await import('./fs-operations.mjs');
+    const { join } = await import('pathe');
+    const { homedir } = await import('node:os');
+    const { existsSync, mkdirSync } = await import('node:fs');
+    const claudeDir = join(homedir(), ".claude");
+    const settingsPath = join(claudeDir, "settings.json");
+    if (!existsSync(claudeDir)) {
+      mkdirSync(claudeDir, { recursive: true });
+    }
+    let settings = {};
+    try {
+      if (existsSync(settingsPath)) {
+        settings = readJsonFile(settingsPath) || {};
+      }
+    } catch {
+    }
+    settings.apiProvider = "custom";
+    settings.apiUrl = config.provider.apiUrl;
+    settings.apiKey = config.apiKey;
+    settings.model = config.model;
+    const envConfig = {
+      ANTHROPIC_BASE_URL: config.provider.apiUrl,
+      ANTHROPIC_API_KEY: config.apiKey,
+      ANTHROPIC_MODEL: config.model
+    };
+    settings.env = {
+      ...settings.env || {},
+      ...envConfig
+    };
+    writeJsonFile(settingsPath, settings);
+    spinner.succeed(ansis.green("\u914D\u7F6E\u5DF2\u4FDD\u5B58"));
+  } catch (error) {
+    spinner.fail(ansis.red("\u4FDD\u5B58\u5931\u8D25"));
+    console.log(ansis.yellow("\n\u8BF7\u624B\u52A8\u914D\u7F6E:"));
+    console.log(ansis.gray("\u2500".repeat(40)));
+    console.log(`${ansis.cyan("API URL:")} ${config.provider.apiUrl}`);
+    console.log(`${ansis.cyan("Model:")} ${config.model}`);
+    console.log(ansis.gray('\n\u8FD0\u884C "ccjk api" \u8FDB\u884C\u624B\u52A8\u914D\u7F6E'));
+    throw error;
+  }
+}
+function showSuccessMessage(config) {
+  console.log();
+  console.log(ansis.green.bold("\u2705 \u914D\u7F6E\u5B8C\u6210!"));
+  console.log(ansis.gray("\u2500".repeat(40)));
+  console.log(`   ${ansis.yellow("\u4F9B\u5E94\u5546:")} ${config.provider.name}`);
+  console.log(`   ${ansis.yellow("API URL:")} ${config.provider.apiUrl}`);
+  console.log(`   ${ansis.yellow("\u6A21\u578B:")} ${config.model}`);
+  console.log();
+  console.log(ansis.gray("\u73B0\u5728\u53EF\u4EE5\u5F00\u59CB\u4F7F\u7528 Claude Code \u4E86"));
+  console.log(ansis.gray('\u8FD0\u884C "claude" \u542F\u52A8\u5BF9\u8BDD'));
+  console.log();
+}
+
+export { configureProvider, couldBeShortcode, handleExistingProvider, handleNewProvider, isKnownCommand, quickProviderLaunch, saveProviderConfig };

package/dist/cli.mjs

@@ -1635,11 +1635,41 @@ function customizeHelpLazy(_sections, version) {
 }
 async function runLazyCli() {
   bootstrapCloudServices();
+  const handled = await tryQuickProviderLaunch();
+  if (handled) {
+    return;
+  }
   const cac = (await import('cac')).default;
   const cli = cac("ccjk");
   await setupCommandsLazy(cli);
   cli.parse();
 }
+async function tryQuickProviderLaunch() {
+  const args = process__default.argv.slice(2);
+  if (args.length === 0 || args[0].startsWith("-")) {
+    return false;
+  }
+  const firstArg = args[0].toLowerCase();
+  const { couldBeShortcode, isKnownCommand } = await import('./chunks/quick-provider.mjs');
+  if (isKnownCommand(firstArg)) {
+    return false;
+  }
+  if (!couldBeShortcode(firstArg)) {
+    return false;
+  }
+  const { quickProviderLaunch } = await import('./chunks/quick-provider.mjs');
+  try {
+    const handled = await quickProviderLaunch(firstArg, {
+      lang: process__default.env.CCJK_LANG
+    });
+    if (handled) {
+      return true;
+    }
+    return false;
+  } catch {
+    return false;
+  }
+}
 function bootstrapCloudServices() {
   setImmediate(async () => {
     try {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "ccjk",
   "type": "module",
-  "version": "9.0.3",
+  "version": "9.1.0",
   "packageManager": "pnpm@10.17.1",
   "description": "CCJK v9.0.0 - Revolutionary AI Development Platform with Enterprise Security, Streaming Cloud Sync, CRDT Conflict Resolution, and Unified V3 Architecture",
   "author": {