ccjk 11.1.0 → 11.1.2

package/dist/shared/ccjk.CGcy7cNM.mjs

@@ -0,0 +1,495 @@
+import { existsSync, readFileSync, mkdirSync, unlinkSync } from 'node:fs';
+import os__default, { homedir } from 'node:os';
+import { join } from 'pathe';
+import { writeFileAtomic } from '../chunks/fs-operations.mjs';
+import { Buffer } from 'node:buffer';
+import crypto from 'node:crypto';
+
+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 = 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) {
+    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) {
+    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();
+}
+
+export { isValidTokenFormat as a, bindDevice as b, generateDeviceToken as c, decryptToken as d, encryptToken as e, getDeviceInfo as f, getBindingStatus as g, isDeviceBound as i, maskToken as m, sendNotification as s, unbindDevice as u };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "ccjk",
   "type": "module",
-  "version": "11.1.0",
+  "version": "11.1.2",
   "packageManager": "pnpm@10.17.1",
   "description": "CLI toolkit for Claude Code and Codex setup. Simplifies MCP service installation, API configuration, workflow management, and multi-provider support with guided interactive setup.",
   "author": {
@@ -86,7 +86,7 @@
     "build": "unbuild",
     "start": "node bin/ccjk.mjs",
     "typecheck": "tsc --noEmit",
-    "prepublishOnly": "node scripts/validate-prepublish.mjs && pnpm build && pnpm test:run",
+    "prepublishOnly": "node scripts/validate-prepublish.mjs && pnpm contract:check && pnpm build && pnpm test:run",
     "lint": "eslint",
     "lint:fix": "eslint --fix",
     "test": "vitest",
@@ -137,7 +137,8 @@
     "benchmark:server": "npx http-server docs/v2 -p 8080 -o dashboard.html",
     "benchmark:open": "open docs/v2/dashboard.html || xdg-open docs/v2/dashboard.html || start docs/v2/dashboard.html",
     "i18n:check": "tsx scripts/check-i18n.ts",
-    "i18n:report": "tsx scripts/check-i18n.ts --report"
+    "i18n:report": "tsx scripts/check-i18n.ts --report",
+    "contract:check": "node scripts/check-remote-contract.mjs"
   },
   "dependencies": {
     "@anthropic-ai/sdk": "^0.52.0",

package/templates/claude-code/common/settings.json

@@ -1,53 +1,37 @@
 {
   "$schema": "https://json.schemastore.org/claude-code-settings.json",
   "description": "CCJK settings template — auto-migrated on upgrade",
-
   "model": "default",
-
   "env": {
     "ANTHROPIC_MODEL": "",
     "ANTHROPIC_DEFAULT_HAIKU_MODEL": "",
     "ANTHROPIC_DEFAULT_SONNET_MODEL": "",
     "ANTHROPIC_DEFAULT_OPUS_MODEL": ""
   },
-
   "language": "",
-
   "showTurnDuration": false,
-
   "respectGitignore": true,
-
   "auto": {
     "mcp": 0
   },
-
   "agent": "",
-
   "thinking": {
     "enabled": false,
     "budgetTokens": 10240
   },
-
   "fileSuggestion": {
     "type": "command",
     "command": "git"
   },
-
   "allowUnsandboxedCommands": false,
-
   "disallowedTools": [],
-
   "attribution": {},
-
   "index": {
     "maxFiles": 10000,
     "maxFileSize": 2097152
   },
-
   "allowBrowser": false,
-
   "statusLine": {},
-
   "plansDirectory": ".claude/plans",
   "hooks": {
     "PreToolUse": [],
@@ -85,13 +69,37 @@
       "Read(*)",
       "Edit(*)",
       "Write(*)",
-      "NotebookEdit(*)"
+      "NotebookEdit(*)",
+      "Bash(cd *)",
+      "Bash(for *)",
+      "Bash(while *)",
+      "Bash(if *)",
+      "Bash(source *)",
+      "Bash(export *)",
+      "Bash(unset *)",
+      "Bash(rm *)",
+      "Bash(rmdir *)",
+      "Bash(tee *)",
+      "Bash(env *)",
+      "Bash(time *)",
+      "Bash(printf *)",
+      "Bash(sed *)",
+      "Bash(awk *)",
+      "Bash(tr *)",
+      "Bash(xargs *)",
+      "Bash(cut *)",
+      "Bash(curl *)",
+      "Bash(node *)",
+      "Bash(python *)",
+      "Bash(python3 *)",
+      "Bash(pip *)",
+      "Bash(pip3 *)",
+      "WebFetch(*)",
+      "MCP(*)"
     ]
   },
-
   "chat": {
     "alwaysApprove": []
   },
-
   "experimental": {}
-}
+}