ccjk 2.0.7 → 2.0.8

package/dist/cli.mjs

@@ -1,9 +1,9 @@
 #!/usr/bin/env node
 import cac from 'cac';
 import ansis from 'ansis';
-import { S as STATUS, ch as i18n, n as runConfigWizard, ci as testApiConnection, m as displayCurrentStatus, cj as quickSetup, ck as format, k as COLORS, cl as getAllPresets, cm as ensureI18nInitialized, cn as readCcrConfig, co as isCcrInstalled, cp as installCcr, cq as configureCcrFeature, cr as promptBoolean, cs as handleExitPromptError, ct as handleGeneralError, cu as COMETIX_COMMAND_NAME, cv as COMETIX_COMMANDS, cw as installCometixLine, cx as addNumbersToChoices, cy as checkAndUpdateTools, aW as runCodexUpdate, cz as resolveCodeType$1, a2 as resolveCodeToolType$1, cA as readZcfConfig, $ as isCodeToolType, W as DEFAULT_CODE_TOOL_TYPE, a_ as switchCodexProvider, aM as listCodexProviders, aR as readCodexConfig, aD as switchToOfficialLogin, a$ as switchToProvider, q as commandExists, y as CLAUDE_DIR, z as SETTINGS_FILE, cB as readJsonConfig, cC as writeJsonConfig, cD as moveToTrash, U as ZCF_CONFIG_FILE, ah as displayBanner, cE as updateZcfConfig, v as version, cF as resolveAiOutputLanguage, cG as updatePromptOnly, cH as selectAndInstallWorkflows, cI as checkClaudeCodeVersionAndPrompt, l as init, ai as displayBannerWithInfo, X as CODE_TOOL_BANNERS, aV as runCodexUninstall, b5 as configureCodexMcp, aE as configureCodexApi, aY as runCodexWorkflowImportWithLanguageSelection, aT as runCodexFullInit, cJ as checkSuperpowersInstalled, cK as getSuperpowersSkills, cL as updateSuperpowers, cM as uninstallSuperpowers, cN as installSuperpowers, cO as installSuperpowersViaGit, _ as CODE_TOOL_INFO, bb as getToolStatus, bc as getAllToolsStatus, V as CODE_TOOL_TYPES, aj as boxify, be as installTool, cP as readZcfConfigAsync, cQ as initI18n, bV as quickSync, cf as checkAllVersions, cg as upgradeAll, i as detectAllConfigs, bB as displayConfigScan, c9 as displayPermissions, cR as selectScriptLanguage, cS as changeLanguage, bU as runOnboarding } from './chunks/simple-config.mjs';
-import { existsSync, readdirSync, mkdirSync, writeFileSync, readFileSync } from 'node:fs';
-import { homedir } from 'node:os';
+import { S as STATUS, ch as i18n, n as runConfigWizard$1, ci as testApiConnection, m as displayCurrentStatus, cj as quickSetup, ck as format, k as COLORS, cl as getAllPresets, cm as ensureI18nInitialized, cn as readCcrConfig, co as isCcrInstalled, cp as installCcr, cq as configureCcrFeature, cr as promptBoolean, cs as handleExitPromptError, ct as handleGeneralError, cu as COMETIX_COMMAND_NAME, cv as COMETIX_COMMANDS, cw as installCometixLine, cx as addNumbersToChoices, cy as checkAndUpdateTools, aW as runCodexUpdate, cz as resolveCodeType$1, a2 as resolveCodeToolType$1, cA as readZcfConfig, $ as isCodeToolType, W as DEFAULT_CODE_TOOL_TYPE, a_ as switchCodexProvider, aM as listCodexProviders, aR as readCodexConfig, aD as switchToOfficialLogin, a$ as switchToProvider, q as commandExists, y as CLAUDE_DIR, z as SETTINGS_FILE, cB as readJsonConfig, cC as writeJsonConfig, cD as moveToTrash, U as ZCF_CONFIG_FILE, ah as displayBanner, cE as updateZcfConfig, v as version, cF as resolveAiOutputLanguage, cG as updatePromptOnly, cH as selectAndInstallWorkflows, cI as checkClaudeCodeVersionAndPrompt, l as init, ai as displayBannerWithInfo, X as CODE_TOOL_BANNERS, aV as runCodexUninstall, b5 as configureCodexMcp, aE as configureCodexApi, aY as runCodexWorkflowImportWithLanguageSelection, aT as runCodexFullInit, cJ as checkSuperpowersInstalled, cK as getSuperpowersSkills, cL as updateSuperpowers, cM as uninstallSuperpowers, cN as installSuperpowers, cO as installSuperpowersViaGit, _ as CODE_TOOL_INFO, bb as getToolStatus, bc as getAllToolsStatus, V as CODE_TOOL_TYPES, aj as boxify, be as installTool, cP as readZcfConfigAsync, cQ as initI18n, bV as quickSync, cf as checkAllVersions, cg as upgradeAll, i as detectAllConfigs, bB as displayConfigScan, c9 as displayPermissions, cR as selectScriptLanguage, cS as changeLanguage, bU as runOnboarding } from './chunks/simple-config.mjs';
+import nodeFs__default, { existsSync, readdirSync, mkdirSync, writeFileSync, readFileSync } from 'node:fs';
+import os, { homedir } from 'node:os';
 import inquirer from 'inquirer';
 import { join, resolve as resolve$1 } from 'pathe';
 import { runCcrStop, runCcrStart, runCcrRestart, runCcrStatus, runCcrUi } from './chunks/commands.mjs';
@@ -16,8 +16,10 @@ import { spawn, exec } from 'node:child_process';
 import { promisify } from 'node:util';
 import { ClaudeCodeConfigManager } from './chunks/claude-code-config-manager.mjs';
 import { pathExists } from 'fs-extra';
-import { join as join$1, resolve, dirname } from 'node:path';
-import { randomUUID } from 'node:crypto';
+import path, { join as join$1, resolve, dirname } from 'node:path';
+import crypto, { randomUUID } from 'node:crypto';
+import { parse, stringify } from '@iarna/toml';
+import { Buffer } from 'node:buffer';
 import ora from 'ora';
 import 'smol-toml';
 import 'dayjs';
@@ -65,14 +67,14 @@ function setupApi(providerId, apiKey, _lang = "en") {
     console.log(STATUS.error(format(i18n.t("api:configFailed"), { error: result.error || "Unknown error" })));
   }
 }
-function showStatus(lang = "en") {
+function showStatus$1(lang = "en") {
   displayCurrentStatus(lang);
 }
 async function testApi(lang = "en") {
   await testApiConnection(lang);
 }
 async function runWizard(lang = "en") {
-  await runConfigWizard(lang);
+  await runConfigWizard$1(lang);
 }
 async function apiCommand(action = "wizard", args = [], options = {}) {
   const lang = options.lang || "en";
@@ -95,7 +97,7 @@ async function apiCommand(action = "wizard", args = [], options = {}) {
       break;
     case "status":
     case "s":
-      showStatus(lang);
+      showStatus$1(lang);
       break;
     case "test":
     case "t":
@@ -6309,6 +6311,1239 @@ async function mcpMarket(action, args, options = {}) {
   }
 }
 
+const TOKEN_PREFIX = "ccjk_";
+const TOKEN_LENGTH = 64;
+const TOKEN_VERSION = 1;
+function generateDeviceToken() {
+  const randomBytes = crypto.randomBytes(TOKEN_LENGTH / 2);
+  const randomHex = randomBytes.toString("hex");
+  return `${TOKEN_PREFIX}${TOKEN_VERSION}${randomHex}`;
+}
+function isValidTokenFormat(token) {
+  if (!token || typeof token !== "string") {
+    return false;
+  }
+  if (!token.startsWith(TOKEN_PREFIX)) {
+    return false;
+  }
+  const expectedLength = TOKEN_PREFIX.length + 1 + TOKEN_LENGTH;
+  if (token.length !== expectedLength) {
+    return false;
+  }
+  const version = token[TOKEN_PREFIX.length];
+  if (!/^\d$/.test(version)) {
+    return false;
+  }
+  const hexPart = token.slice(TOKEN_PREFIX.length + 1);
+  if (!/^[a-f0-9]+$/i.test(hexPart)) {
+    return false;
+  }
+  return true;
+}
+function getDeviceInfo() {
+  return {
+    name: os.hostname(),
+    platform: os.platform(),
+    osVersion: os.release(),
+    arch: os.arch(),
+    username: os.userInfo().username,
+    machineId: generateMachineId()
+  };
+}
+function generateMachineId() {
+  const components = [
+    os.hostname(),
+    os.platform(),
+    os.arch(),
+    os.cpus()[0]?.model || "unknown",
+    os.userInfo().username,
+    // Add network interface MAC addresses for uniqueness
+    ...Object.values(os.networkInterfaces()).flat().filter((iface) => iface && !iface.internal && iface.mac !== "00:00:00:00:00:00").map((iface) => iface?.mac).filter(Boolean).slice(0, 3)
+    // Limit to first 3 MACs
+  ];
+  const combined = components.join("|");
+  return crypto.createHash("sha256").update(combined).digest("hex").slice(0, 32);
+}
+function deriveEncryptionKey() {
+  const machineId = generateMachineId();
+  const salt = "ccjk-notification-token-v1";
+  return crypto.pbkdf2Sync(machineId, salt, 1e5, 32, "sha256");
+}
+function encryptToken(token) {
+  const key = deriveEncryptionKey();
+  const iv = crypto.randomBytes(16);
+  const cipher = crypto.createCipheriv("aes-256-gcm", key, iv);
+  let encrypted = cipher.update(token, "utf8", "hex");
+  encrypted += cipher.final("hex");
+  const authTag = cipher.getAuthTag();
+  return `${iv.toString("hex")}:${authTag.toString("hex")}:${encrypted}`;
+}
+function decryptToken(encryptedToken) {
+  try {
+    const parts = encryptedToken.split(":");
+    if (parts.length !== 3) {
+      return null;
+    }
+    const [ivHex, authTagHex, encrypted] = parts;
+    const key = deriveEncryptionKey();
+    const iv = Buffer.from(ivHex, "hex");
+    const authTag = Buffer.from(authTagHex, "hex");
+    const decipher = crypto.createDecipheriv("aes-256-gcm", key, iv);
+    decipher.setAuthTag(authTag);
+    let decrypted = decipher.update(encrypted, "hex", "utf8");
+    decrypted += decipher.final("utf8");
+    return decrypted;
+  } catch {
+    return null;
+  }
+}
+function maskToken(token) {
+  if (!token || token.length < 12) {
+    return "***";
+  }
+  const prefix = token.slice(0, TOKEN_PREFIX.length + 1);
+  const suffix = token.slice(-4);
+  return `${prefix}***...***${suffix}`;
+}
+
+const DEFAULT_NOTIFICATION_CONFIG = {
+  enabled: false,
+  deviceToken: "",
+  threshold: 10,
+  // 10 minutes
+  cloudEndpoint: "https://api.claudehome.cn",
+  channels: {},
+  quietHours: {
+    enabled: false,
+    startHour: 22,
+    endHour: 8
+  }
+};
+function validateNotificationConfig(config) {
+  const errors = [];
+  const warnings = [];
+  if (config.threshold !== void 0) {
+    if (config.threshold < 1) {
+      errors.push({
+        field: "threshold",
+        message: "Threshold must be at least 1 minute",
+        code: "THRESHOLD_TOO_LOW"
+      });
+    }
+    if (config.threshold > 1440) {
+      warnings.push("Threshold is set to more than 24 hours");
+    }
+  }
+  if (config.channels?.feishu?.enabled) {
+    if (!config.channels.feishu.webhookUrl) {
+      errors.push({
+        field: "channels.feishu.webhookUrl",
+        message: "Feishu webhook URL is required when enabled",
+        code: "FEISHU_WEBHOOK_REQUIRED"
+      });
+    } else if (!config.channels.feishu.webhookUrl.startsWith("https://")) {
+      errors.push({
+        field: "channels.feishu.webhookUrl",
+        message: "Feishu webhook URL must use HTTPS",
+        code: "FEISHU_WEBHOOK_INVALID"
+      });
+    }
+  }
+  if (config.channels?.wechat?.enabled) {
+    if (!config.channels.wechat.corpId) {
+      errors.push({
+        field: "channels.wechat.corpId",
+        message: "WeChat Work Corp ID is required when enabled",
+        code: "WECHAT_CORPID_REQUIRED"
+      });
+    }
+    if (!config.channels.wechat.agentId) {
+      errors.push({
+        field: "channels.wechat.agentId",
+        message: "WeChat Work Agent ID is required when enabled",
+        code: "WECHAT_AGENTID_REQUIRED"
+      });
+    }
+    if (!config.channels.wechat.secret) {
+      errors.push({
+        field: "channels.wechat.secret",
+        message: "WeChat Work Secret is required when enabled",
+        code: "WECHAT_SECRET_REQUIRED"
+      });
+    }
+  }
+  if (config.channels?.email?.enabled) {
+    if (!config.channels.email.address) {
+      errors.push({
+        field: "channels.email.address",
+        message: "Email address is required when enabled",
+        code: "EMAIL_ADDRESS_REQUIRED"
+      });
+    } else if (!/^[^\s@]+@[^\s@][^\s.@]*\.[^\s@]+$/.test(config.channels.email.address)) {
+      errors.push({
+        field: "channels.email.address",
+        message: "Invalid email address format",
+        code: "EMAIL_ADDRESS_INVALID"
+      });
+    }
+  }
+  if (config.channels?.sms?.enabled) {
+    if (!config.channels.sms.phone) {
+      errors.push({
+        field: "channels.sms.phone",
+        message: "Phone number is required when enabled",
+        code: "SMS_PHONE_REQUIRED"
+      });
+    } else if (!/^\d{10,15}$/.test(config.channels.sms.phone.replace(/\D/g, ""))) {
+      errors.push({
+        field: "channels.sms.phone",
+        message: "Invalid phone number format",
+        code: "SMS_PHONE_INVALID"
+      });
+    }
+  }
+  if (config.quietHours?.enabled) {
+    if (config.quietHours.startHour < 0 || config.quietHours.startHour > 23) {
+      errors.push({
+        field: "quietHours.startHour",
+        message: "Start hour must be between 0 and 23",
+        code: "QUIET_HOURS_INVALID"
+      });
+    }
+    if (config.quietHours.endHour < 0 || config.quietHours.endHour > 23) {
+      errors.push({
+        field: "quietHours.endHour",
+        message: "End hour must be between 0 and 23",
+        code: "QUIET_HOURS_INVALID"
+      });
+    }
+  }
+  return {
+    valid: errors.length === 0,
+    errors,
+    warnings
+  };
+}
+
+const CCJK_CONFIG_DIR = path.join(os.homedir(), ".ccjk");
+const CONFIG_FILE_PATH = path.join(CCJK_CONFIG_DIR, "config.toml");
+const SECRETS_FILE_PATH = path.join(CCJK_CONFIG_DIR, ".notification-secrets");
+async function loadNotificationConfig() {
+  try {
+    if (!nodeFs__default.existsSync(CCJK_CONFIG_DIR)) {
+      nodeFs__default.mkdirSync(CCJK_CONFIG_DIR, { recursive: true });
+    }
+    if (!nodeFs__default.existsSync(CONFIG_FILE_PATH)) {
+      return { ...DEFAULT_NOTIFICATION_CONFIG };
+    }
+    const configContent = nodeFs__default.readFileSync(CONFIG_FILE_PATH, "utf-8");
+    const config = parse(configContent);
+    const notificationConfig = config.notification;
+    if (!notificationConfig) {
+      return { ...DEFAULT_NOTIFICATION_CONFIG };
+    }
+    const deviceToken = await loadDeviceToken();
+    const quietHoursConfig = notificationConfig.quietHours || {};
+    const defaultQuietHours = DEFAULT_NOTIFICATION_CONFIG.quietHours || {
+      enabled: false,
+      startHour: 22,
+      endHour: 8,
+      timezone: "local"
+    };
+    return {
+      ...DEFAULT_NOTIFICATION_CONFIG,
+      ...notificationConfig,
+      deviceToken: deviceToken || notificationConfig.deviceToken || "",
+      channels: {
+        ...DEFAULT_NOTIFICATION_CONFIG.channels,
+        ...notificationConfig.channels
+      },
+      quietHours: {
+        enabled: quietHoursConfig.enabled ?? defaultQuietHours.enabled,
+        startHour: quietHoursConfig.startHour ?? defaultQuietHours.startHour,
+        endHour: quietHoursConfig.endHour ?? defaultQuietHours.endHour,
+        timezone: quietHoursConfig.timezone ?? defaultQuietHours.timezone
+      }
+    };
+  } catch (error) {
+    console.error("Failed to load notification config:", error);
+    return { ...DEFAULT_NOTIFICATION_CONFIG };
+  }
+}
+async function loadDeviceToken() {
+  try {
+    if (!nodeFs__default.existsSync(SECRETS_FILE_PATH)) {
+      return null;
+    }
+    const secretsContent = nodeFs__default.readFileSync(SECRETS_FILE_PATH, "utf-8");
+    const secrets = JSON.parse(secretsContent);
+    if (!secrets.deviceToken) {
+      return null;
+    }
+    const decryptedToken = decryptToken(secrets.deviceToken);
+    return decryptedToken;
+  } catch {
+    return null;
+  }
+}
+async function saveNotificationConfig(config) {
+  try {
+    if (!nodeFs__default.existsSync(CCJK_CONFIG_DIR)) {
+      nodeFs__default.mkdirSync(CCJK_CONFIG_DIR, { recursive: true });
+    }
+    let existingConfig = {};
+    if (nodeFs__default.existsSync(CONFIG_FILE_PATH)) {
+      const configContent = nodeFs__default.readFileSync(CONFIG_FILE_PATH, "utf-8");
+      existingConfig = parse(configContent);
+    }
+    const notificationConfig = { ...config };
+    if (notificationConfig.deviceToken) {
+      await saveDeviceToken(notificationConfig.deviceToken);
+      delete notificationConfig.deviceToken;
+    }
+    existingConfig.notification = {
+      ...existingConfig.notification || {},
+      ...notificationConfig
+    };
+    const tomlContent = stringify(existingConfig);
+    nodeFs__default.writeFileSync(CONFIG_FILE_PATH, tomlContent, "utf-8");
+  } catch (error) {
+    throw new Error(`Failed to save notification config: ${error}`);
+  }
+}
+async function saveDeviceToken(token) {
+  try {
+    const encryptedToken = encryptToken(token);
+    let secrets = {};
+    if (nodeFs__default.existsSync(SECRETS_FILE_PATH)) {
+      const secretsContent = nodeFs__default.readFileSync(SECRETS_FILE_PATH, "utf-8");
+      secrets = JSON.parse(secretsContent);
+    }
+    secrets.deviceToken = encryptedToken;
+    secrets.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    nodeFs__default.writeFileSync(SECRETS_FILE_PATH, JSON.stringify(secrets, null, 2), {
+      encoding: "utf-8",
+      mode: 384
+      // Owner read/write only
+    });
+  } catch (error) {
+    throw new Error(`Failed to save device token: ${error}`);
+  }
+}
+async function initializeNotificationConfig() {
+  const existingConfig = await loadNotificationConfig();
+  if (!existingConfig.deviceToken || !isValidTokenFormat(existingConfig.deviceToken)) {
+    existingConfig.deviceToken = generateDeviceToken();
+    await saveNotificationConfig(existingConfig);
+  }
+  return existingConfig;
+}
+async function updateNotificationConfig(updates) {
+  const currentConfig = await loadNotificationConfig();
+  const updatesQuietHours = updates.quietHours || {};
+  const currentQuietHours = currentConfig.quietHours || {
+    enabled: false,
+    startHour: 22,
+    endHour: 8,
+    timezone: "local"
+  };
+  const newConfig = {
+    ...currentConfig,
+    ...updates,
+    channels: {
+      ...currentConfig.channels,
+      ...updates.channels
+    },
+    quietHours: {
+      enabled: updatesQuietHours.enabled ?? currentQuietHours.enabled,
+      startHour: updatesQuietHours.startHour ?? currentQuietHours.startHour,
+      endHour: updatesQuietHours.endHour ?? currentQuietHours.endHour,
+      timezone: updatesQuietHours.timezone ?? currentQuietHours.timezone
+    }
+  };
+  await saveNotificationConfig(newConfig);
+  return newConfig;
+}
+async function enableChannel(channel, config) {
+  const currentConfig = await loadNotificationConfig();
+  currentConfig.channels[channel] = {
+    ...config,
+    enabled: true
+  };
+  await saveNotificationConfig(currentConfig);
+}
+async function disableChannel(channel) {
+  const currentConfig = await loadNotificationConfig();
+  if (currentConfig.channels[channel]) {
+    currentConfig.channels[channel].enabled = false;
+    await saveNotificationConfig(currentConfig);
+  }
+}
+async function getEnabledChannels() {
+  const config = await loadNotificationConfig();
+  const enabledChannels = [];
+  if (config.channels.feishu?.enabled) {
+    enabledChannels.push("feishu");
+  }
+  if (config.channels.wechat?.enabled) {
+    enabledChannels.push("wechat");
+  }
+  if (config.channels.email?.enabled) {
+    enabledChannels.push("email");
+  }
+  if (config.channels.sms?.enabled) {
+    enabledChannels.push("sms");
+  }
+  return enabledChannels;
+}
+async function validateCurrentConfig() {
+  const config = await loadNotificationConfig();
+  return validateNotificationConfig(config);
+}
+async function getConfigSummary() {
+  const config = await loadNotificationConfig();
+  const enabledChannels = await getEnabledChannels();
+  return {
+    enabled: config.enabled,
+    deviceToken: maskToken(config.deviceToken),
+    threshold: config.threshold,
+    enabledChannels,
+    quietHours: {
+      enabled: config.quietHours?.enabled || false,
+      hours: config.quietHours?.enabled ? `${config.quietHours.startHour}:00 - ${config.quietHours.endHour}:00` : void 0
+    }
+  };
+}
+const THRESHOLD_OPTIONS = [
+  { value: 5, label: "5 minutes" },
+  { value: 10, label: "10 minutes" },
+  { value: 15, label: "15 minutes" },
+  { value: 30, label: "30 minutes" },
+  { value: 60, label: "1 hour" }
+];
+async function setThreshold(minutes) {
+  if (minutes < 1) {
+    throw new Error("Threshold must be at least 1 minute");
+  }
+  await updateNotificationConfig({ threshold: minutes });
+}
+async function enableNotifications() {
+  await updateNotificationConfig({ enabled: true });
+}
+async function disableNotifications() {
+  await updateNotificationConfig({ enabled: false });
+}
+
+const DEFAULT_CLOUD_ENDPOINT = "https://api.claudehome.cn";
+const REQUEST_TIMEOUT = 3e4;
+const POLL_TIMEOUT = 6e4;
+class CloudClient {
+  static instance = null;
+  endpoint = DEFAULT_CLOUD_ENDPOINT;
+  deviceToken = "";
+  isPolling = false;
+  pollAbortController = null;
+  constructor() {
+  }
+  /**
+   * Get the singleton instance
+   */
+  static getInstance() {
+    if (!CloudClient.instance) {
+      CloudClient.instance = new CloudClient();
+    }
+    return CloudClient.instance;
+  }
+  /**
+   * Initialize the cloud client
+   */
+  async initialize() {
+    const config = await loadNotificationConfig();
+    this.endpoint = config.cloudEndpoint || DEFAULT_CLOUD_ENDPOINT;
+    this.deviceToken = config.deviceToken;
+  }
+  /**
+   * Set the cloud endpoint
+   */
+  setEndpoint(endpoint) {
+    this.endpoint = endpoint;
+  }
+  /**
+   * Set the device token
+   */
+  setDeviceToken(token) {
+    this.deviceToken = token;
+  }
+  // ==========================================================================
+  // Device Registration
+  // ==========================================================================
+  /**
+   * Register this device with the cloud service
+   */
+  async registerDevice(name) {
+    const deviceInfo = getDeviceInfo();
+    const config = await loadNotificationConfig();
+    const channelsArray = this.convertChannelsToArray(config.channels);
+    const request = {
+      name: name || deviceInfo.name,
+      platform: deviceInfo.platform,
+      version: "1.0.0",
+      // TODO: Get from package.json
+      config: {
+        channels: channelsArray,
+        threshold: config.threshold
+      }
+    };
+    const response = await this.request(
+      "/device/register",
+      {
+        method: "POST",
+        body: JSON.stringify(request)
+      }
+    );
+    if (response.success && response.data) {
+      await updateNotificationConfig({
+        deviceToken: response.data.token
+      });
+      this.deviceToken = response.data.token;
+      return response.data;
+    }
+    throw new Error(response.error || "Failed to register device");
+  }
+  /**
+   * Get device info from cloud service
+   */
+  async getDeviceInfo() {
+    const response = await this.request(
+      "/device/info",
+      { method: "GET" }
+    );
+    if (response.success && response.data) {
+      return response.data;
+    }
+    throw new Error(response.error || "Failed to get device info");
+  }
+  /**
+   * Update device channels on cloud service
+   */
+  async updateChannels(channels) {
+    const channelsArray = this.convertChannelsToArray(channels);
+    const response = await this.request(
+      "/device/channels",
+      {
+        method: "PUT",
+        body: JSON.stringify({ channels: channelsArray })
+      }
+    );
+    if (!response.success) {
+      throw new Error(response.error || "Failed to update channels");
+    }
+  }
+  // ==========================================================================
+  // Notification Sending
+  // ==========================================================================
+  /**
+   * Send a notification through the cloud service
+   */
+  async sendNotification(message, channels) {
+    const config = await loadNotificationConfig();
+    const targetChannels = channels || this.getEnabledChannelsFromConfig(config.channels);
+    if (targetChannels.length === 0) {
+      return [];
+    }
+    const title = message.title || this.generateTitle(message.type);
+    const body = this.generateBody(message);
+    const response = await this.request(
+      "/notify",
+      {
+        method: "POST",
+        body: JSON.stringify({
+          type: message.type,
+          title,
+          body,
+          task: message.task,
+          channels: targetChannels,
+          actions: message.actions,
+          priority: message.priority
+        })
+      }
+    );
+    if (response.success && response.data) {
+      return response.data.results;
+    }
+    return targetChannels.map((channel) => ({
+      success: false,
+      channel,
+      sentAt: /* @__PURE__ */ new Date(),
+      error: response.error || "Failed to send notification"
+    }));
+  }
+  /**
+   * Send a test notification
+   */
+  async sendTestNotification() {
+    const response = await this.request(
+      "/notify/test",
+      { method: "POST" }
+    );
+    if (response.success && response.data) {
+      return response.data.results;
+    }
+    throw new Error(response.error || "Failed to send test notification");
+  }
+  // ==========================================================================
+  // Reply Polling
+  // ==========================================================================
+  /**
+   * Start polling for replies
+   *
+   * @param onReply - Callback when a reply is received
+   * @param onError - Callback when an error occurs
+   */
+  startPolling(onReply, onError) {
+    if (this.isPolling) {
+      return;
+    }
+    this.isPolling = true;
+    this.pollLoop(onReply, onError);
+  }
+  /**
+   * Stop polling for replies
+   */
+  stopPolling() {
+    this.isPolling = false;
+    if (this.pollAbortController) {
+      this.pollAbortController.abort();
+      this.pollAbortController = null;
+    }
+  }
+  /**
+   * Poll loop for replies
+   */
+  async pollLoop(onReply, onError) {
+    while (this.isPolling) {
+      try {
+        const reply = await this.pollForReply();
+        if (reply) {
+          onReply(reply);
+        }
+      } catch (error) {
+        if (error instanceof Error && error.name === "AbortError") {
+          break;
+        }
+        onError?.(error instanceof Error ? error : new Error(String(error)));
+        await this.sleep(5e3);
+      }
+    }
+  }
+  /**
+   * Poll for a single reply (long-polling)
+   */
+  async pollForReply() {
+    this.pollAbortController = new AbortController();
+    try {
+      const response = await this.request(
+        "/reply/poll",
+        {
+          method: "GET",
+          signal: this.pollAbortController.signal,
+          timeout: POLL_TIMEOUT
+        }
+      );
+      if (response.success && response.data?.reply) {
+        return {
+          ...response.data.reply,
+          timestamp: new Date(response.data.reply.timestamp)
+        };
+      }
+      return null;
+    } finally {
+      this.pollAbortController = null;
+    }
+  }
+  /**
+   * Get reply for a specific notification
+   */
+  async getReply(notificationId) {
+    const response = await this.request(
+      `/reply/${notificationId}`,
+      { method: "GET" }
+    );
+    if (response.success && response.data?.reply) {
+      return {
+        ...response.data.reply,
+        timestamp: new Date(response.data.reply.timestamp)
+      };
+    }
+    return null;
+  }
+  // ==========================================================================
+  // HTTP Request Helper
+  // ==========================================================================
+  /**
+   * Make an HTTP request to the cloud service
+   */
+  async request(path, options) {
+    const url = `${this.endpoint}${path}`;
+    const timeout = options.timeout || REQUEST_TIMEOUT;
+    const timeoutController = new AbortController();
+    const timeoutId = setTimeout(() => timeoutController.abort(), timeout);
+    try {
+      const response = await fetch(url, {
+        method: options.method,
+        headers: {
+          "Content-Type": "application/json",
+          "X-Device-Token": this.deviceToken
+        },
+        body: options.body,
+        signal: options.signal || timeoutController.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
+        };
+      }
+      return data;
+    } catch (error) {
+      clearTimeout(timeoutId);
+      if (error instanceof Error) {
+        if (error.name === "AbortError") {
+          throw error;
+        }
+        return {
+          success: false,
+          error: error.message,
+          code: "NETWORK_ERROR"
+        };
+      }
+      return {
+        success: false,
+        error: String(error),
+        code: "UNKNOWN_ERROR"
+      };
+    }
+  }
+  // ==========================================================================
+  // Utility Methods
+  // ==========================================================================
+  /**
+   * Get enabled channels from config
+   */
+  getEnabledChannelsFromConfig(channels) {
+    const enabledChannels = [];
+    for (const [name, channelConfig] of Object.entries(channels)) {
+      if (channelConfig?.enabled) {
+        enabledChannels.push(name);
+      }
+    }
+    return enabledChannels;
+  }
+  /**
+   * Sleep for a specified duration
+   */
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  /**
+   * Convert channels from object format to array format
+   *
+   * Converts from: { feishu: { enabled: true, webhookUrl: "..." } }
+   * To: [{ type: "feishu", enabled: true, config: { webhookUrl: "..." } }]
+   */
+  convertChannelsToArray(channels) {
+    const result = [];
+    for (const [channelType, channelData] of Object.entries(channels)) {
+      if (channelData && typeof channelData === "object") {
+        const { enabled, ...config } = channelData;
+        result.push({
+          type: channelType,
+          enabled: Boolean(enabled),
+          config
+        });
+      }
+    }
+    return result;
+  }
+  /**
+   * Generate notification title based on type
+   */
+  generateTitle(type) {
+    const titles = {
+      task_started: "Task Started",
+      task_progress: "Task Progress",
+      task_completed: "Task Completed",
+      task_failed: "Task Failed",
+      task_cancelled: "Task Cancelled",
+      system: "System Notification"
+    };
+    return titles[type] || "Notification";
+  }
+  /**
+   * Generate notification body from message
+   */
+  generateBody(message) {
+    const { task } = message;
+    const lines = [];
+    lines.push(`**Task**: ${task.description}`);
+    lines.push(`**Status**: ${task.status}`);
+    if (task.duration) {
+      const minutes = Math.floor(task.duration / 6e4);
+      const seconds = Math.floor(task.duration % 6e4 / 1e3);
+      lines.push(`**Duration**: ${minutes}m ${seconds}s`);
+    }
+    if (task.result) {
+      lines.push(`**Result**: ${task.result}`);
+    }
+    if (task.error) {
+      lines.push(`**Error**: ${task.error}`);
+    }
+    return lines.join("\n");
+  }
+  /**
+   * Reset the singleton instance (for testing)
+   */
+  static resetInstance() {
+    if (CloudClient.instance) {
+      CloudClient.instance.stopPolling();
+      CloudClient.instance = null;
+    }
+  }
+}
+
+async function notificationCommand(action = "menu") {
+  switch (action) {
+    case "config":
+    case "configure":
+      await runConfigWizard();
+      break;
+    case "status":
+      await showStatus();
+      break;
+    case "test":
+      await sendTestNotification();
+      break;
+    case "enable":
+      await enableNotifications();
+      console.log(ansis.green(`\u2705 ${i18n.t("notification:status.enabled")}`));
+      break;
+    case "disable":
+      await disableNotifications();
+      console.log(ansis.yellow(`\u23F8\uFE0F ${i18n.t("notification:status.disabled")}`));
+      break;
+    case "channels":
+      await manageChannels();
+      break;
+    case "threshold":
+      await configureThreshold();
+      break;
+    case "menu":
+    default:
+      await showNotificationMenu();
+      break;
+  }
+}
+async function showNotificationMenu() {
+  const config = await loadNotificationConfig();
+  const enabledChannels = await getEnabledChannels();
+  console.log("");
+  console.log(ansis.bold.cyan(i18n.t("notification:menu.title")));
+  console.log("");
+  const statusText = config.enabled ? ansis.green(i18n.t("notification:status.enabled")) : ansis.yellow(i18n.t("notification:status.disabled"));
+  console.log(`  ${ansis.dim("\u72B6\u6001:")} ${statusText}`);
+  if (enabledChannels.length > 0) {
+    const channelNames = enabledChannels.map((ch) => i18n.t(`notification:channels.${ch}`)).join(", ");
+    console.log(`  ${ansis.dim("\u6E20\u9053:")} ${channelNames}`);
+  } else {
+    console.log(`  ${ansis.dim("\u6E20\u9053:")} ${ansis.yellow(i18n.t("notification:channels.noChannels"))}`);
+  }
+  console.log(`  ${ansis.dim("\u9608\u503C:")} ${config.threshold} ${i18n.t("notification:config.threshold.minutes", { count: config.threshold })}`);
+  console.log("");
+  const { action } = await inquirer.prompt([{
+    type: "list",
+    name: "action",
+    message: "\u9009\u62E9\u64CD\u4F5C:",
+    choices: [
+      {
+        name: config.enabled ? "\u23F8\uFE0F  \u7981\u7528\u901A\u77E5" : "\u25B6\uFE0F  \u542F\u7528\u901A\u77E5",
+        value: config.enabled ? "disable" : "enable"
+      },
+      { name: "\u2699\uFE0F  \u914D\u7F6E\u5411\u5BFC", value: "config" },
+      { name: "\u{1F4F1} \u7BA1\u7406\u6E20\u9053", value: "channels" },
+      { name: "\u23F1\uFE0F  \u8BBE\u7F6E\u9608\u503C", value: "threshold" },
+      { name: "\u{1F4CA} \u67E5\u770B\u72B6\u6001", value: "status" },
+      { name: "\u{1F9EA} \u53D1\u9001\u6D4B\u8BD5", value: "test" },
+      { name: "\u2190 \u8FD4\u56DE", value: "back" }
+    ]
+  }]);
+  if (action === "back") {
+    return;
+  }
+  await notificationCommand(action);
+}
+async function runConfigWizard() {
+  console.log("");
+  console.log(ansis.bold.cyan(i18n.t("notification:config.wizard.title")));
+  console.log(ansis.dim(i18n.t("notification:config.wizard.welcome")));
+  console.log("");
+  console.log(ansis.yellow(i18n.t("notification:config.wizard.step1")));
+  const config = await initializeNotificationConfig();
+  console.log(ansis.green(i18n.t("notification:config.wizard.tokenGenerated", { token: maskToken(config.deviceToken) })));
+  console.log("");
+  console.log(ansis.yellow(i18n.t("notification:config.wizard.step2")));
+  const channels = await selectChannels();
+  console.log("");
+  if (channels.length > 0) {
+    console.log(ansis.yellow(i18n.t("notification:config.wizard.step3")));
+    for (const channel of channels) {
+      await configureChannel(channel);
+    }
+    console.log("");
+  }
+  console.log(ansis.yellow(i18n.t("notification:config.wizard.step4")));
+  await configureThreshold();
+  console.log("");
+  console.log(ansis.yellow(i18n.t("notification:config.wizard.step5")));
+  await updateNotificationConfig({ enabled: true });
+  const { shouldTest } = await inquirer.prompt([{
+    type: "confirm",
+    name: "shouldTest",
+    message: "\u662F\u5426\u53D1\u9001\u6D4B\u8BD5\u901A\u77E5?",
+    default: true
+  }]);
+  if (shouldTest) {
+    await sendTestNotification();
+  }
+  console.log("");
+  console.log(ansis.bold.green(i18n.t("notification:config.wizard.complete")));
+  console.log("");
+}
+async function selectChannels() {
+  const choices = [
+    { name: `\u{1F4F1} ${i18n.t("notification:channels.feishu")}`, value: "feishu" },
+    { name: `\u{1F4AC} ${i18n.t("notification:channels.wechat")}`, value: "wechat" },
+    { name: `\u{1F4E7} ${i18n.t("notification:channels.email")}`, value: "email" },
+    { name: `\u{1F4F2} ${i18n.t("notification:channels.sms")}`, value: "sms" }
+  ];
+  const selected = [];
+  for (const choice of choices) {
+    const { enable } = await inquirer.prompt([{
+      type: "confirm",
+      name: "enable",
+      message: `\u542F\u7528 ${choice.name}?`,
+      default: false
+    }]);
+    if (enable) {
+      selected.push(choice.value);
+    }
+  }
+  return selected;
+}
+async function configureChannel(channel) {
+  console.log("");
+  console.log(ansis.cyan(`\u914D\u7F6E ${i18n.t(`notification:channels.${channel}`)}:`));
+  switch (channel) {
+    case "feishu":
+      await configureFeishu();
+      break;
+    case "wechat":
+      await configureWechat();
+      break;
+    case "email":
+      await configureEmail();
+      break;
+    case "sms":
+      await configureSms();
+      break;
+  }
+}
+async function configureFeishu() {
+  const { webhookUrl } = await inquirer.prompt([{
+    type: "input",
+    name: "webhookUrl",
+    message: i18n.t("notification:feishu.webhookUrl"),
+    validate: (value) => {
+      if (!value.startsWith("https://")) {
+        return i18n.t("notification:errors.invalidWebhook");
+      }
+      return true;
+    }
+  }]);
+  const { secret } = await inquirer.prompt([{
+    type: "input",
+    name: "secret",
+    message: `${i18n.t("notification:feishu.secret")} (\u53EF\u9009\uFF0C\u76F4\u63A5\u56DE\u8F66\u8DF3\u8FC7):`
+  }]);
+  const config = {
+    enabled: true,
+    webhookUrl,
+    ...secret && { secret }
+  };
+  await enableChannel("feishu", config);
+  console.log(ansis.green(`\u2705 ${i18n.t("notification:channels.feishu")} ${i18n.t("notification:status.configured")}`));
+}
+async function configureWechat() {
+  const { corpId } = await inquirer.prompt([{
+    type: "input",
+    name: "corpId",
+    message: i18n.t("notification:wechat.corpId"),
+    validate: (value) => !!value || i18n.t("notification:errors.invalidWebhook")
+  }]);
+  const { agentId } = await inquirer.prompt([{
+    type: "input",
+    name: "agentId",
+    message: i18n.t("notification:wechat.agentId"),
+    validate: (value) => !!value || i18n.t("notification:errors.invalidWebhook")
+  }]);
+  const { secret } = await inquirer.prompt([{
+    type: "input",
+    name: "secret",
+    message: i18n.t("notification:wechat.secret"),
+    validate: (value) => !!value || i18n.t("notification:errors.invalidWebhook")
+  }]);
+  const config = {
+    enabled: true,
+    corpId,
+    agentId,
+    secret
+  };
+  await enableChannel("wechat", config);
+  console.log(ansis.green(`\u2705 ${i18n.t("notification:channels.wechat")} ${i18n.t("notification:status.configured")}`));
+}
+async function configureEmail() {
+  const { address } = await inquirer.prompt([{
+    type: "input",
+    name: "address",
+    message: i18n.t("notification:email.address"),
+    validate: (value) => {
+      if (!/^[^\s@]+@[^\s@][^\s.@]*\.[^\s@]+$/.test(value)) {
+        return i18n.t("notification:errors.invalidEmail");
+      }
+      return true;
+    }
+  }]);
+  const config = {
+    enabled: true,
+    address
+  };
+  await enableChannel("email", config);
+  console.log(ansis.green(`\u2705 ${i18n.t("notification:channels.email")} ${i18n.t("notification:status.configured")}`));
+}
+async function configureSms() {
+  const { phone } = await inquirer.prompt([{
+    type: "input",
+    name: "phone",
+    message: i18n.t("notification:sms.phone"),
+    validate: (value) => {
+      if (!/^\d{10,15}$/.test(value.replace(/\D/g, ""))) {
+        return i18n.t("notification:errors.invalidPhone");
+      }
+      return true;
+    }
+  }]);
+  const { countryCode } = await inquirer.prompt([{
+    type: "input",
+    name: "countryCode",
+    message: i18n.t("notification:sms.countryCode"),
+    default: "+86"
+  }]);
+  const config = {
+    enabled: true,
+    phone,
+    countryCode
+  };
+  await enableChannel("sms", config);
+  console.log(ansis.green(`\u2705 ${i18n.t("notification:channels.sms")} ${i18n.t("notification:status.configured")}`));
+}
+async function manageChannels() {
+  const enabledChannels = await getEnabledChannels();
+  console.log("");
+  console.log(ansis.bold.cyan(i18n.t("notification:channels.title")));
+  console.log("");
+  if (enabledChannels.length === 0) {
+    console.log(ansis.yellow(i18n.t("notification:channels.noChannels")));
+  } else {
+    console.log(i18n.t("notification:channels.enabledCount", { count: enabledChannels.length }));
+    for (const channel of enabledChannels) {
+      console.log(`  \u2705 ${i18n.t(`notification:channels.${channel}`)}`);
+    }
+  }
+  console.log("");
+  const { action } = await inquirer.prompt([{
+    type: "list",
+    name: "action",
+    message: "\u9009\u62E9\u64CD\u4F5C:",
+    choices: [
+      { name: "\u2795 \u6DFB\u52A0\u6E20\u9053", value: "add" },
+      { name: "\u2796 \u79FB\u9664\u6E20\u9053", value: "remove" },
+      { name: "\u2190 \u8FD4\u56DE", value: "back" }
+    ]
+  }]);
+  if (action === "back") {
+    return;
+  }
+  if (action === "add") {
+    const allChannels = ["feishu", "wechat", "email", "sms"];
+    const availableChannels = allChannels.filter((ch) => !enabledChannels.includes(ch));
+    if (availableChannels.length === 0) {
+      console.log(ansis.yellow("\u6240\u6709\u6E20\u9053\u90FD\u5DF2\u542F\u7528"));
+      return;
+    }
+    const { channel } = await inquirer.prompt([{
+      type: "list",
+      name: "channel",
+      message: "\u9009\u62E9\u8981\u6DFB\u52A0\u7684\u6E20\u9053:",
+      choices: availableChannels.map((ch) => ({
+        name: i18n.t(`notification:channels.${ch}`),
+        value: ch
+      }))
+    }]);
+    await configureChannel(channel);
+  } else if (action === "remove") {
+    if (enabledChannels.length === 0) {
+      console.log(ansis.yellow("\u6CA1\u6709\u5DF2\u542F\u7528\u7684\u6E20\u9053"));
+      return;
+    }
+    const { channel } = await inquirer.prompt([{
+      type: "list",
+      name: "channel",
+      message: "\u9009\u62E9\u8981\u79FB\u9664\u7684\u6E20\u9053:",
+      choices: enabledChannels.map((ch) => ({
+        name: i18n.t(`notification:channels.${ch}`),
+        value: ch
+      }))
+    }]);
+    await disableChannel(channel);
+    console.log(ansis.green(`\u2705 \u5DF2\u79FB\u9664 ${i18n.t(`notification:channels.${channel}`)}`));
+  }
+}
+async function configureThreshold() {
+  const config = await loadNotificationConfig();
+  console.log("");
+  console.log(ansis.dim(i18n.t("notification:config.threshold.description")));
+  console.log("");
+  const { threshold } = await inquirer.prompt([{
+    type: "list",
+    name: "threshold",
+    message: i18n.t("notification:config.threshold.title"),
+    choices: [
+      ...THRESHOLD_OPTIONS.map((opt) => ({
+        name: opt.label,
+        value: opt.value
+      })),
+      { name: i18n.t("notification:config.threshold.custom"), value: -1 }
+    ],
+    default: config.threshold
+  }]);
+  let finalThreshold = threshold;
+  if (threshold === -1) {
+    const { customValue } = await inquirer.prompt([{
+      type: "input",
+      name: "customValue",
+      message: "\u8F93\u5165\u81EA\u5B9A\u4E49\u9608\u503C\uFF08\u5206\u949F\uFF09:",
+      validate: (value) => {
+        const num = Number.parseInt(value, 10);
+        if (Number.isNaN(num) || num < 1) {
+          return "\u8BF7\u8F93\u5165\u5927\u4E8E 0 \u7684\u6570\u5B57";
+        }
+        return true;
+      }
+    }]);
+    finalThreshold = Number.parseInt(customValue, 10);
+  }
+  await setThreshold(finalThreshold);
+  console.log(ansis.green(`\u2705 \u9608\u503C\u5DF2\u8BBE\u7F6E\u4E3A ${finalThreshold} \u5206\u949F`));
+}
+async function showStatus() {
+  const summary = await getConfigSummary();
+  const validation = await validateCurrentConfig();
+  console.log("");
+  console.log(ansis.bold.cyan("\u{1F4CA} \u901A\u77E5\u7CFB\u7EDF\u72B6\u6001"));
+  console.log("");
+  const statusIcon = summary.enabled ? "\u2705" : "\u23F8\uFE0F";
+  const statusText = summary.enabled ? ansis.green(i18n.t("notification:status.enabled")) : ansis.yellow(i18n.t("notification:status.disabled"));
+  console.log(`  ${statusIcon} \u72B6\u6001: ${statusText}`);
+  console.log(`  \u{1F511} \u8BBE\u5907\u4EE4\u724C: ${ansis.dim(summary.deviceToken)}`);
+  console.log(`  \u23F1\uFE0F  \u9608\u503C: ${summary.threshold} \u5206\u949F`);
+  console.log("");
+  console.log(ansis.bold("  \u{1F4F1} \u901A\u77E5\u6E20\u9053:"));
+  if (summary.enabledChannels.length === 0) {
+    console.log(`     ${ansis.yellow(i18n.t("notification:channels.noChannels"))}`);
+  } else {
+    for (const channel of summary.enabledChannels) {
+      console.log(`     \u2705 ${i18n.t(`notification:channels.${channel}`)}`);
+    }
+  }
+  if (summary.quietHours.enabled) {
+    console.log("");
+    console.log(`  \u{1F319} \u514D\u6253\u6270: ${summary.quietHours.hours}`);
+  }
+  if (!validation.valid) {
+    console.log("");
+    console.log(ansis.bold.red("  \u26A0\uFE0F \u914D\u7F6E\u95EE\u9898:"));
+    for (const error of validation.errors) {
+      console.log(`     \u274C ${error.message}`);
+    }
+  }
+  if (validation.warnings.length > 0) {
+    console.log("");
+    console.log(ansis.bold.yellow("  \u26A0\uFE0F \u8B66\u544A:"));
+    for (const warning of validation.warnings) {
+      console.log(`     \u26A0\uFE0F ${warning}`);
+    }
+  }
+  console.log("");
+}
+async function sendTestNotification() {
+  const enabledChannels = await getEnabledChannels();
+  if (enabledChannels.length === 0) {
+    console.log(ansis.yellow(i18n.t("notification:errors.noChannels")));
+    return;
+  }
+  console.log("");
+  console.log(ansis.cyan(i18n.t("notification:test.sending")));
+  try {
+    const client = CloudClient.getInstance();
+    await client.initialize();
+    const results = await client.sendTestNotification();
+    console.log("");
+    let hasSuccess = false;
+    let hasFailure = false;
+    for (const result of results) {
+      const channelName = i18n.t(`notification:channels.${result.channel}`);
+      if (result.success) {
+        console.log(ansis.green(`\u2705 ${channelName}: ${i18n.t("notification:test.success")}`));
+        hasSuccess = true;
+      } else {
+        console.log(ansis.red(`\u274C ${channelName}: ${result.error || i18n.t("notification:test.failed")}`));
+        hasFailure = true;
+      }
+    }
+    console.log("");
+    if (hasSuccess) {
+      console.log(ansis.dim(i18n.t("notification:test.checkDevice")));
+    }
+    if (hasFailure) {
+      console.log(ansis.yellow(i18n.t("notification:test.partialFailure")));
+    }
+  } catch (error) {
+    console.log("");
+    console.log(ansis.red(`\u274C ${i18n.t("notification:errors.sendFailed")}`));
+    if (error instanceof Error) {
+      console.log(ansis.dim(error.message));
+    }
+    console.log("");
+    console.log(ansis.yellow(i18n.t("notification:test.troubleshooting")));
+    console.log(ansis.dim(`  1. ${i18n.t("notification:test.checkConnection")}`));
+    console.log(ansis.dim(`  2. ${i18n.t("notification:test.checkConfig")}`));
+    console.log(ansis.dim(`  3. ${i18n.t("notification:test.checkToken")}`));
+  }
+  console.log("");
+}
+
 const SESSIONS_DIR = join$1(homedir(), ".ccjk", "sessions");
 async function saveSession() {
   try {
@@ -7330,6 +8565,9 @@ async function setupCommands(cli) {
   cli.command("workflows", "Manage installed workflows").alias("wf").option("--lang, -l <lang>", "Display language (zh-CN, en)").action(await withLanguageResolution(async () => {
     await showWorkflows();
   }));
+  cli.command("notification [action]", "Manage task completion notifications (config, status, test, enable, disable, channels)").alias("notify").option("--lang, -l <lang>", "Display language (zh-CN, en)").action(await withLanguageResolution(async (action) => {
+    await notificationCommand(action);
+  }));
   cli.help((sections) => customizeHelp(sections));
   cli.version(version);
 }