ccjk 11.1.0 → 11.1.1

package/README.md

@@ -171,6 +171,12 @@ ccjk at --status          # Check status
 ccjk cloud enable --provider github-gist
 ccjk cloud sync
 
+# Remote Control (Web/App)
+ccjk remote setup                       # One-command setup (interactive)
+ccjk remote setup --non-interactive --server-url <url> --auth-token <token> --binding-code <code>
+ccjk remote doctor                      # Diagnose remote readiness
+ccjk remote status                      # Quick runtime status
+
 # MCP Services
 ccjk mcp install <service>
 ccjk mcp list

package/README.zh-CN.md

@@ -98,6 +98,9 @@ npx ccjk cloud enable --provider github-gist
 ```bash
 npx ccjk           # 交互式设置
 npx ccjk i         # 完整初始化
+npx ccjk remote setup   # 一键远程初始化（推荐）
+npx ccjk remote doctor  # 远程体检
+npx ccjk remote status  # 远程状态
 npx ccjk u         # 更新工作流
 npx ccjk sync      # 云端同步
 npx ccjk doctor    # 健康检查

package/dist/chunks/notification.mjs

@@ -1,512 +1,26 @@
 import ansis from 'ansis';
 import inquirer from 'inquirer';
 import { i18n } from './index2.mjs';
+import { m as maskToken, a as isValidTokenFormat, c as generateDeviceToken, d as decryptToken, e as encryptToken, f as getDeviceInfo, i as isDeviceBound, g as getBindingStatus, u as unbindDevice, b as bindDevice, s as sendNotification } from '../shared/ccjk.CGcy7cNM.mjs';
+import { exec } from 'node:child_process';
 import * as nodeFs from 'node:fs';
-import nodeFs__default, { existsSync, readFileSync, mkdirSync, unlinkSync } from 'node:fs';
+import nodeFs__default from 'node:fs';
 import * as os from 'node:os';
-import os__default, { homedir } from 'node:os';
-import { join } from 'pathe';
-import { writeFileAtomic } from './fs-operations.mjs';
-import { Buffer } from 'node:buffer';
-import crypto from 'node:crypto';
-import { exec } from 'node:child_process';
+import os__default from 'node:os';
 import * as path from 'node:path';
 import path__default from 'node:path';
 import process__default from 'node:process';
 import { promisify } from 'node:util';
+import { writeFileAtomic } from './fs-operations.mjs';
 import { parse, stringify } from 'smol-toml';
 import 'node:url';
 import 'i18next';
 import 'i18next-fs-backend';
+import 'pathe';
+import 'node:buffer';
+import 'node:crypto';
 import 'node:fs/promises';
 
-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__default.hostname(),
-    platform: os__default.platform(),
-    osVersion: os__default.release(),
-    arch: os__default.arch(),
-    username: os__default.userInfo().username,
-    machineId: generateMachineId()
-  };
-}
-function generateMachineId() {
-  const components = [
-    os__default.hostname(),
-    os__default.platform(),
-    os__default.arch(),
-    os__default.cpus()[0]?.model || "unknown",
-    os__default.userInfo().username,
-    // Add network interface MAC addresses for uniqueness
-    ...Object.values(os__default.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 CLOUD_API_BASE_URL = "https://api.claudehome.cn";
-const DEFAULT_TIMEOUT = 3e4;
-const POLL_TIMEOUT$1 = 6e4;
-const TOKEN_FILE_PATH = join(homedir(), ".ccjk", "cloud-token.json");
-class CCJKCloudClient {
-  baseUrl;
-  deviceToken = null;
-  deviceId = null;
-  /**
-   * Create a new CCJKCloudClient instance
-   *
-   * @param baseUrl - Cloud API base URL (default: https://api.claudehome.cn)
-   */
-  constructor(baseUrl = CLOUD_API_BASE_URL) {
-    this.baseUrl = baseUrl;
-    this.loadToken();
-  }
-  // ==========================================================================
-  // Token Management
-  // ==========================================================================
-  /**
-   * Load token from storage file
-   */
-  loadToken() {
-    try {
-      if (existsSync(TOKEN_FILE_PATH)) {
-        const data = readFileSync(TOKEN_FILE_PATH, "utf-8");
-        const storage = JSON.parse(data);
-        this.deviceToken = storage.deviceToken;
-        this.deviceId = storage.deviceId || null;
-      }
-    } catch {
-      this.deviceToken = null;
-      this.deviceId = null;
-    }
-  }
-  /**
-   * Save token to storage file
-   */
-  saveToken(storage) {
-    try {
-      const dir = join(homedir(), ".ccjk");
-      if (!existsSync(dir)) {
-        mkdirSync(dir, { recursive: true });
-      }
-      writeFileAtomic(TOKEN_FILE_PATH, JSON.stringify(storage, null, 2));
-    } catch (error) {
-      throw new Error(`Failed to save token: ${error instanceof Error ? error.message : String(error)}`);
-    }
-  }
-  /**
-   * Check if device is bound
-   */
-  isBound() {
-    return this.deviceToken !== null && this.deviceToken.length > 0;
-  }
-  /**
-   * Get current device token
-   */
-  getDeviceToken() {
-    return this.deviceToken;
-  }
-  /**
-   * Get current device ID
-   */
-  getDeviceId() {
-    return this.deviceId;
-  }
-  /**
-   * Clear stored token (unbind device)
-   */
-  clearToken() {
-    this.deviceToken = null;
-    this.deviceId = null;
-    try {
-      if (existsSync(TOKEN_FILE_PATH)) {
-        unlinkSync(TOKEN_FILE_PATH);
-      }
-    } catch {
-    }
-  }
-  // ==========================================================================
-  // Device Binding
-  // ==========================================================================
-  /**
-   * Bind device using a binding code
-   *
-   * The binding code is obtained from the CCJK mobile app or web dashboard.
-   * Once bound, the device can send and receive notifications.
-   *
-   * @param code - Binding code from mobile app
-   * @param deviceInfo - Optional device information (auto-detected if not provided)
-   * @returns Bind response with device token
-   *
-   * @example
-   * ```typescript
-   * const client = new CCJKCloudClient()
-   * const result = await client.bind('ABC123')
-   * if (result.success) {
-   *   console.log('Device bound successfully!')
-   * }
-   * ```
-   */
-  async bind(code, deviceInfo) {
-    const info = deviceInfo ? { ...getDeviceInfo(), ...deviceInfo } : getDeviceInfo();
-    const response = await this.request("/bind/use", {
-      method: "POST",
-      body: JSON.stringify({
-        code,
-        deviceInfo: info
-      })
-    });
-    if (response.success && response.data) {
-      this.deviceToken = response.data.deviceToken;
-      this.deviceId = response.data.deviceId;
-      this.saveToken({
-        deviceToken: response.data.deviceToken,
-        deviceId: response.data.deviceId,
-        bindingCode: code,
-        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-        deviceInfo: info
-      });
-      return {
-        success: true,
-        deviceToken: response.data.deviceToken,
-        deviceId: response.data.deviceId
-      };
-    }
-    return {
-      success: false,
-      error: response.error || "Failed to bind device",
-      code: response.code
-    };
-  }
-  // ==========================================================================
-  // Notification Sending
-  // ==========================================================================
-  /**
-   * Send a notification to the user
-   *
-   * @param options - Notification options
-   * @returns Notification response
-   *
-   * @example
-   * ```typescript
-   * const client = new CCJKCloudClient()
-   * await client.notify({
-   *   title: 'Build Complete',
-   *   body: 'Your project has been built successfully!',
-   *   type: 'success'
-   * })
-   * ```
-   */
-  async notify(options) {
-    if (!this.deviceToken) {
-      return {
-        success: false,
-        error: 'Device not bound. Please run "ccjk notification bind <code>" first.',
-        code: "NOT_BOUND"
-      };
-    }
-    const response = await this.request("/notify", {
-      method: "POST",
-      body: JSON.stringify({
-        title: options.title,
-        body: options.body,
-        type: options.type || "info",
-        taskId: options.taskId,
-        metadata: options.metadata,
-        actions: options.actions
-      })
-    });
-    if (response.success && response.data) {
-      return {
-        success: true,
-        notificationId: response.data.notificationId
-      };
-    }
-    return {
-      success: false,
-      error: response.error || "Failed to send notification",
-      code: response.code
-    };
-  }
-  // ==========================================================================
-  // Reply Polling
-  // ==========================================================================
-  /**
-   * Wait for a reply from the user
-   *
-   * Uses long-polling to wait for a user reply. The timeout parameter
-   * controls how long to wait before returning null.
-   *
-   * @param timeout - Timeout in milliseconds (default: 30000)
-   * @returns User reply or null if timeout
-   *
-   * @example
-   * ```typescript
-   * const client = new CCJKCloudClient()
-   * const reply = await client.waitForReply(60000) // Wait up to 60 seconds
-   * if (reply) {
-   *   console.log('User replied:', reply.content)
-   * }
-   * ```
-   */
-  async waitForReply(timeout = POLL_TIMEOUT$1) {
-    if (!this.deviceToken) {
-      throw new Error('Device not bound. Please run "ccjk notification bind <code>" first.');
-    }
-    const response = await this.request(`/reply/poll?timeout=${timeout}`, {
-      method: "GET",
-      timeout
-    });
-    if (response.success && response.data?.reply) {
-      return {
-        content: response.data.reply.content,
-        timestamp: new Date(response.data.reply.timestamp),
-        notificationId: response.data.reply.notificationId,
-        actionId: response.data.reply.actionId
-      };
-    }
-    return null;
-  }
-  // ==========================================================================
-  // Ask and Wait
-  // ==========================================================================
-  /**
-   * Ask the user a question and wait for their reply
-   *
-   * This is a convenience method that combines notify() and waitForReply().
-   * It sends a notification with the question and waits for the user to respond.
-   *
-   * @param question - Question to ask the user
-   * @param options - Additional notification options
-   * @param timeout - Timeout in milliseconds (default: 60000)
-   * @returns User reply
-   *
-   * @example
-   * ```typescript
-   * const client = new CCJKCloudClient()
-   * const reply = await client.ask('Deploy to production?', {
-   *   actions: [
-   *     { id: 'yes', label: 'Yes', value: 'yes' },
-   *     { id: 'no', label: 'No', value: 'no' }
-   *   ]
-   * })
-   * if (reply.actionId === 'yes') {
-   *   // Proceed with deployment
-   * }
-   * ```
-   */
-  async ask(question, options, timeout = POLL_TIMEOUT$1) {
-    const notifyResult = await this.notify({
-      title: options?.title || "CCJK Question",
-      body: question,
-      type: "info",
-      ...options
-    });
-    if (!notifyResult.success) {
-      throw new Error(notifyResult.error || "Failed to send question");
-    }
-    const reply = await this.waitForReply(timeout);
-    if (!reply) {
-      throw new Error("No reply received within timeout");
-    }
-    return reply;
-  }
-  // ==========================================================================
-  // Status Check
-  // ==========================================================================
-  /**
-   * Get binding status and device information
-   *
-   * @returns Binding status information
-   */
-  async getStatus() {
-    if (!this.deviceToken) {
-      return { bound: false };
-    }
-    try {
-      if (existsSync(TOKEN_FILE_PATH)) {
-        const data = readFileSync(TOKEN_FILE_PATH, "utf-8");
-        const storage = JSON.parse(data);
-        return {
-          bound: true,
-          deviceId: storage.deviceId,
-          deviceInfo: storage.deviceInfo,
-          lastUsed: storage.lastUsedAt
-        };
-      }
-    } catch {
-    }
-    return {
-      bound: true,
-      deviceId: this.deviceId || void 0
-    };
-  }
-  // ==========================================================================
-  // HTTP Request Helper
-  // ==========================================================================
-  /**
-   * Make an HTTP request to the cloud service
-   */
-  async request(path, options) {
-    const url = `${this.baseUrl}${path}`;
-    const timeout = options.timeout || DEFAULT_TIMEOUT;
-    const controller = new AbortController();
-    const timeoutId = setTimeout(() => controller.abort(), timeout);
-    try {
-      const headers = {
-        "Content-Type": "application/json"
-      };
-      if (this.deviceToken) {
-        headers["X-Device-Token"] = this.deviceToken;
-      }
-      const response = await fetch(url, {
-        method: options.method,
-        headers,
-        body: options.body,
-        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}`
-        };
-      }
-      if (this.deviceToken && existsSync(TOKEN_FILE_PATH)) {
-        try {
-          const storageData = readFileSync(TOKEN_FILE_PATH, "utf-8");
-          const storage = JSON.parse(storageData);
-          storage.lastUsedAt = (/* @__PURE__ */ new Date()).toISOString();
-          writeFileAtomic(TOKEN_FILE_PATH, JSON.stringify(storage, null, 2));
-        } catch {
-        }
-      }
-      return data;
-    } 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"
-      };
-    }
-  }
-}
-let cloudClientInstance = null;
-function getCloudNotificationClient() {
-  if (!cloudClientInstance) {
-    cloudClientInstance = new CCJKCloudClient();
-  }
-  return cloudClientInstance;
-}
-async function bindDevice(code, deviceInfo) {
-  const client = getCloudNotificationClient();
-  return client.bind(code, deviceInfo);
-}
-async function sendNotification(options) {
-  const client = getCloudNotificationClient();
-  return client.notify(options);
-}
-function isDeviceBound() {
-  const client = getCloudNotificationClient();
-  return client.isBound();
-}
-async function getBindingStatus() {
-  const client = getCloudNotificationClient();
-  return client.getStatus();
-}
-function unbindDevice() {
-  const client = getCloudNotificationClient();
-  client.clearToken();
-}
-
 const execAsync = promisify(exec);
 const DEFAULT_CONFIG = {
   shortcutName: "ClaudeNotify",
@@ -1547,6 +1061,7 @@ async function notificationCommand(action = "menu", args) {
       await configureThreshold();
       break;
     case "bind":
+      console.log(ansis.yellow(i18n.t("notification:cloud.migrateToRemoteSetup")));
       await handleBind(args?.[0]);
       break;
     case "unbind":

package/dist/chunks/package.mjs

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