ccjk 9.6.1 → 9.8.0

package/dist/chunks/cli.mjs

@@ -1,2227 +0,0 @@
-import { existsSync, writeFileSync, readFileSync } from 'node:fs';
-import * as os from 'node:os';
-import { homedir } from 'node:os';
-import inquirer from 'inquirer';
-import ora from 'ora';
-import { join } from 'pathe';
-import process__default from 'node:process';
-import { nanoid } from 'nanoid';
-import packageJson from './package.mjs';
-import { exec } from 'tinyexec';
-import { EventEmitter } from 'node:events';
-
-const CLOUD_API_BASE = "https://api.claudehome.cn/api/control";
-class CloudClient {
-  config;
-  heartbeatTimer;
-  currentTasks = /* @__PURE__ */ new Set();
-  deviceInfo;
-  constructor(config) {
-    this.config = {
-      heartbeatInterval: 3e4,
-      debug: false,
-      ...config
-    };
-  }
-  /**
-   * Get API base URL
-   */
-  getApiBase() {
-    return this.config.apiUrl || CLOUD_API_BASE;
-  }
-  /**
-   * Get request headers
-   */
-  getHeaders() {
-    return {
-      "Content-Type": "application/json",
-      "X-Device-Token": this.config.deviceToken
-    };
-  }
-  /**
-   * Log debug message
-   */
-  debugLog(message) {
-    if (this.config.debug) {
-      console.log(`[CloudClient] ${message}`);
-    }
-  }
-  /**
-   * Register device to cloud
-   */
-  async register(info) {
-    try {
-      const deviceInfo = {
-        name: info?.name || `CCJK Device (${os.hostname()})`,
-        platform: os.platform(),
-        hostname: os.hostname(),
-        version: info?.version || packageJson.version
-      };
-      this.debugLog(`Registering device: ${deviceInfo.name}`);
-      const response = await fetch(`${this.getApiBase()}/devices/register`, {
-        method: "POST",
-        headers: this.getHeaders(),
-        body: JSON.stringify(deviceInfo)
-      });
-      const result = await response.json();
-      if (result.success && result.data) {
-        this.deviceInfo = result.data;
-        this.debugLog(`Device registered: ${result.data.device.id}`);
-      }
-      return result;
-    } catch (error) {
-      this.debugLog(`Registration failed: ${error}`);
-      return {
-        success: false,
-        error: error instanceof Error ? error.message : "Unknown error"
-      };
-    }
-  }
-  /**
-   * Send heartbeat to cloud and receive pending tasks
-   */
-  async heartbeat(status = "online") {
-    try {
-      const request = {
-        status,
-        currentTasks: Array.from(this.currentTasks),
-        timestamp: (/* @__PURE__ */ new Date()).toISOString()
-      };
-      this.debugLog(`Sending heartbeat: ${status}, tasks: ${request.currentTasks?.length || 0}`);
-      const response = await fetch(`${this.getApiBase()}/devices/heartbeat`, {
-        method: "POST",
-        headers: this.getHeaders(),
-        body: JSON.stringify(request)
-      });
-      const result = await response.json();
-      if (result.success) {
-        this.debugLog(`Heartbeat OK, pending tasks: ${result.data?.pendingTasks?.length || 0}`);
-      }
-      return result;
-    } catch (error) {
-      this.debugLog(`Heartbeat failed: ${error}`);
-      return {
-        success: false,
-        error: error instanceof Error ? error.message : "Unknown error"
-      };
-    }
-  }
-  /**
-   * Pull pending tasks from cloud
-   */
-  async pullTasks() {
-    try {
-      this.debugLog("Pulling pending tasks...");
-      const response = await fetch(`${this.getApiBase()}/devices/pending`, {
-        method: "GET",
-        headers: this.getHeaders()
-      });
-      const result = await response.json();
-      if (result.success && result.data?.commands) {
-        this.debugLog(`Pulled ${result.data.commands.length} tasks`);
-        return result.data.commands;
-      }
-      return [];
-    } catch (error) {
-      this.debugLog(`Pull tasks failed: ${error}`);
-      return [];
-    }
-  }
-  /**
-   * Report command execution result to cloud
-   */
-  async reportResult(commandId, result) {
-    try {
-      this.debugLog(`Reporting result for command ${commandId}: ${result.success ? "success" : "failed"}`);
-      const response = await fetch(`${this.getApiBase()}/commands/${commandId}/result`, {
-        method: "POST",
-        headers: this.getHeaders(),
-        body: JSON.stringify(result)
-      });
-      const fetchResult = await response.json();
-      if (fetchResult.success) {
-        this.currentTasks.delete(commandId);
-      }
-      return fetchResult;
-    } catch (error) {
-      this.debugLog(`Report result failed: ${error}`);
-      return {
-        success: false,
-        error: error instanceof Error ? error.message : "Unknown error"
-      };
-    }
-  }
-  /**
-   * Add task to current tasks list
-   */
-  addTask(commandId) {
-    this.currentTasks.add(commandId);
-  }
-  /**
-   * Remove task from current tasks list
-   */
-  removeTask(commandId) {
-    this.currentTasks.delete(commandId);
-  }
-  /**
-   * Start automatic heartbeat
-   */
-  startHeartbeat(onTasks) {
-    this.stopHeartbeat();
-    this.debugLog(`Starting heartbeat (interval: ${this.config.heartbeatInterval}ms)`);
-    this.heartbeatTimer = setInterval(async () => {
-      try {
-        const status = this.currentTasks.size > 0 ? "busy" : "online";
-        const response = await this.heartbeat(status);
-        if (response.success && response.data?.pendingTasks && onTasks) {
-          const tasks = response.data.pendingTasks;
-          if (tasks.length > 0) {
-            onTasks(tasks);
-          }
-        }
-      } catch (error) {
-        this.debugLog(`Heartbeat error: ${error}`);
-      }
-    }, this.config.heartbeatInterval);
-  }
-  /**
-   * Stop automatic heartbeat
-   */
-  stopHeartbeat() {
-    if (this.heartbeatTimer) {
-      clearInterval(this.heartbeatTimer);
-      this.heartbeatTimer = void 0;
-      this.debugLog("Heartbeat stopped");
-    }
-  }
-  /**
-   * Send offline status before disconnecting
-   */
-  async goOffline() {
-    await this.heartbeat("offline");
-    this.stopHeartbeat();
-    this.currentTasks.clear();
-  }
-  /**
-   * Get registered device info
-   */
-  getDeviceInfo() {
-    return this.deviceInfo;
-  }
-  /**
-   * Get current active tasks count
-   */
-  getActiveTasksCount() {
-    return this.currentTasks.size;
-  }
-  /**
-   * Check if client is connected (has active heartbeat)
-   */
-  isConnected() {
-    return this.heartbeatTimer !== void 0;
-  }
-}
-
-class EmailChecker {
-  imap;
-  config;
-  connected = false;
-  constructor(config) {
-    this.config = {
-      imapHost: "imap.gmail.com",
-      imapPort: 993,
-      tls: true,
-      ...config
-    };
-    try {
-      const ImapConstructor = require("imap");
-      this.imap = new ImapConstructor({
-        user: this.config.email,
-        password: this.config.password,
-        host: this.config.imapHost,
-        port: this.config.imapPort,
-        tls: this.config.tls,
-        tlsOptions: { rejectUnauthorized: false }
-      });
-    } catch (_error) {
-      throw new Error("imap package is not installed. Install it with: pnpm add imap @types/imap");
-    }
-    this.setupEventHandlers();
-  }
-  /**
-   * Setup IMAP event handlers
-   */
-  setupEventHandlers() {
-    this.imap.once("ready", () => {
-      this.connected = true;
-    });
-    this.imap.once("error", (err) => {
-      console.error("IMAP connection error:", err);
-      this.connected = false;
-    });
-    this.imap.once("end", () => {
-      this.connected = false;
-    });
-  }
-  /**
-   * Connect to IMAP server
-   */
-  async connect() {
-    if (this.connected) {
-      return;
-    }
-    return new Promise((resolve, reject) => {
-      this.imap.once("ready", () => {
-        this.connected = true;
-        resolve();
-      });
-      this.imap.once("error", (err) => {
-        reject(err);
-      });
-      this.imap.connect();
-    });
-  }
-  /**
-   * Disconnect from IMAP server
-   */
-  disconnect() {
-    if (this.connected) {
-      this.imap.end();
-      this.connected = false;
-    }
-  }
-  /**
-   * Fetch new emails with [CCJK] tag in subject
-   */
-  async fetchNew() {
-    try {
-      await this.connect();
-      return new Promise((resolve, reject) => {
-        this.imap.openBox("INBOX", false, (err, _box) => {
-          if (err) {
-            reject(err);
-            return;
-          }
-          this.imap.search(["UNSEEN", ["SUBJECT", "[CCJK]"]], (searchErr, results) => {
-            if (searchErr) {
-              reject(searchErr);
-              return;
-            }
-            if (!results || results.length === 0) {
-              resolve([]);
-              return;
-            }
-            const emails = [];
-            const fetch = this.imap.fetch(results, {
-              bodies: "",
-              markSeen: true
-              // Mark as read after fetching
-            });
-            fetch.on("message", (msg, _seqno) => {
-              msg.on("body", (stream) => {
-                let simpleParserFn;
-                try {
-                  simpleParserFn = require("mailparser").simpleParser;
-                } catch {
-                  console.error("mailparser package is not installed. Install it with: pnpm add mailparser @types/mailparser");
-                  return;
-                }
-                simpleParserFn(stream, (parseErr, parsed) => {
-                  if (parseErr) {
-                    console.error("Email parse error:", parseErr);
-                    return;
-                  }
-                  emails.push({
-                    id: parsed.messageId,
-                    from: parsed.from?.text || "",
-                    subject: parsed.subject || "",
-                    body: parsed.text || "",
-                    date: parsed.date || /* @__PURE__ */ new Date(),
-                    raw: parsed
-                  });
-                });
-              });
-              msg.once("attributes", (_attrs) => {
-              });
-            });
-            fetch.once("error", (fetchErr) => {
-              reject(fetchErr);
-            });
-            fetch.once("end", () => {
-              resolve(emails);
-            });
-          });
-        });
-      });
-    } catch (error) {
-      console.error("Failed to fetch emails:", error);
-      throw error;
-    }
-  }
-  /**
-   * Parse command from email
-   */
-  parseCommand(email) {
-    let command = email.body.trim();
-    const lines = command.split("\n");
-    const commandLines = [];
-    for (const line of lines) {
-      const trimmed = line.trim();
-      if (trimmed.startsWith("--") || trimmed.startsWith("___")) {
-        break;
-      }
-      if (trimmed) {
-        commandLines.push(trimmed);
-      }
-    }
-    command = commandLines.join("\n").trim();
-    return command;
-  }
-  /**
-   * Extract sender email address
-   */
-  extractSenderEmail(from) {
-    const match = from.match(/<(.+?)>/);
-    if (match) {
-      return match[1].toLowerCase().trim();
-    }
-    return from.toLowerCase().trim();
-  }
-}
-
-const PRESET_TEMPLATES = {
-  tpl_deploy: {
-    id: "tpl_deploy",
-    name: "\u90E8\u7F72\u63A7\u5236",
-    description: "\u90E8\u7F72\u76F8\u5173\u64CD\u4F5C",
-    category: "deploy",
-    actions: [
-      {
-        id: "deploy",
-        label: "\u{1F680} \u90E8\u7F72",
-        command: "npm run deploy",
-        confirm: true,
-        style: "primary" /* Primary */
-      },
-      {
-        id: "restart",
-        label: "\u{1F504} \u91CD\u542F\u670D\u52A1",
-        command: "pm2 restart all",
-        confirm: true,
-        style: "default" /* Default */
-      },
-      {
-        id: "status",
-        label: "\u{1F4CA} \u670D\u52A1\u72B6\u6001",
-        command: "pm2 status",
-        confirm: false,
-        style: "default" /* Default */
-      },
-      {
-        id: "logs",
-        label: "\u{1F4CB} \u67E5\u770B\u65E5\u5FD7",
-        command: "pm2 logs --lines 50 --nostream",
-        confirm: false,
-        style: "default" /* Default */
-      },
-      {
-        id: "stop",
-        label: "\u23F9\uFE0F \u505C\u6B62\u670D\u52A1",
-        command: "pm2 stop all",
-        confirm: true,
-        style: "danger" /* Danger */
-      }
-    ]
-  },
-  tpl_database: {
-    id: "tpl_database",
-    name: "\u6570\u636E\u5E93\u63A7\u5236",
-    description: "\u6570\u636E\u5E93\u76F8\u5173\u64CD\u4F5C",
-    category: "database",
-    actions: [
-      {
-        id: "migrate",
-        label: "\u{1F504} \u8FD0\u884C\u8FC1\u79FB",
-        command: "npm run db:migrate",
-        confirm: true,
-        style: "primary" /* Primary */
-      },
-      {
-        id: "seed",
-        label: "\u{1F331} \u586B\u5145\u6570\u636E",
-        command: "npm run db:seed",
-        confirm: true,
-        style: "default" /* Default */
-      },
-      {
-        id: "backup",
-        label: "\u{1F4BE} \u5907\u4EFD\u6570\u636E\u5E93",
-        command: "npm run db:backup",
-        confirm: false,
-        style: "default" /* Default */
-      },
-      {
-        id: "restore",
-        label: "\u267B\uFE0F  \u6062\u590D\u6570\u636E\u5E93",
-        command: "npm run db:restore",
-        confirm: true,
-        style: "danger" /* Danger */
-      }
-    ]
-  },
-  tpl_git: {
-    id: "tpl_git",
-    name: "Git \u64CD\u4F5C",
-    description: "Git \u7248\u672C\u63A7\u5236",
-    category: "git",
-    actions: [
-      {
-        id: "pull",
-        label: "\u2B07\uFE0F \u62C9\u53D6\u66F4\u65B0",
-        command: "git pull",
-        confirm: false,
-        style: "primary" /* Primary */
-      },
-      {
-        id: "status",
-        label: "\u{1F4CA} \u72B6\u6001\u68C0\u67E5",
-        command: "git status",
-        confirm: false,
-        style: "default" /* Default */
-      },
-      {
-        id: "log",
-        label: "\u{1F4CB} \u63D0\u4EA4\u5386\u53F2",
-        command: "git log --oneline -10",
-        confirm: false,
-        style: "default" /* Default */
-      },
-      {
-        id: "push",
-        label: "\u2B06\uFE0F \u63A8\u9001\u66F4\u6539",
-        command: "git push",
-        confirm: true,
-        style: "default" /* Default */
-      }
-    ]
-  },
-  tpl_build: {
-    id: "tpl_build",
-    name: "\u6784\u5EFA\u63A7\u5236",
-    description: "\u9879\u76EE\u6784\u5EFA\u64CD\u4F5C",
-    category: "build",
-    actions: [
-      {
-        id: "build",
-        label: "\u{1F528} \u6784\u5EFA",
-        command: "npm run build",
-        confirm: true,
-        style: "primary" /* Primary */
-      },
-      {
-        id: "dev",
-        label: "\u{1F6E0}\uFE0F \u5F00\u53D1\u6A21\u5F0F",
-        command: "npm run dev",
-        confirm: false,
-        style: "default" /* Default */
-      },
-      {
-        id: "test",
-        label: "\u{1F9EA} \u8FD0\u884C\u6D4B\u8BD5",
-        command: "npm run test",
-        confirm: false,
-        style: "default" /* Default */
-      },
-      {
-        id: "lint",
-        label: "\u{1F50D} \u4EE3\u7801\u68C0\u67E5",
-        command: "npm run lint",
-        confirm: false,
-        style: "default" /* Default */
-      },
-      {
-        id: "clean",
-        label: "\u{1F9F9} \u6E05\u7406\u6784\u5EFA",
-        command: "npm run clean",
-        confirm: true,
-        style: "danger" /* Danger */
-      }
-    ]
-  },
-  tpl_docker: {
-    id: "tpl_docker",
-    name: "Docker \u63A7\u5236",
-    description: "Docker \u5BB9\u5668\u64CD\u4F5C",
-    category: "docker",
-    actions: [
-      {
-        id: "ps",
-        label: "\u{1F4CA} \u5BB9\u5668\u5217\u8868",
-        command: "docker ps",
-        confirm: false,
-        style: "default" /* Default */
-      },
-      {
-        id: "restart",
-        label: "\u{1F504} \u91CD\u542F\u5BB9\u5668",
-        command: "docker restart $(docker ps -q)",
-        confirm: true,
-        style: "primary" /* Primary */
-      },
-      {
-        id: "logs",
-        label: "\u{1F4CB} \u5BB9\u5668\u65E5\u5FD7",
-        command: "docker logs --tail 100 $(docker ps -q | head -1)",
-        confirm: false,
-        style: "default" /* Default */
-      },
-      {
-        id: "stop",
-        label: "\u23F9\uFE0F \u505C\u6B62\u5BB9\u5668",
-        command: "docker stop $(docker ps -q)",
-        confirm: true,
-        style: "danger" /* Danger */
-      }
-    ]
-  },
-  tpl_system: {
-    id: "tpl_system",
-    name: "\u7CFB\u7EDF\u63A7\u5236",
-    description: "\u7CFB\u7EDF\u7EA7\u522B\u64CD\u4F5C",
-    category: "system",
-    actions: [
-      {
-        id: "uptime",
-        label: "\u23F1\uFE0F \u8FD0\u884C\u65F6\u95F4",
-        command: "uptime",
-        confirm: false,
-        style: "default" /* Default */
-      },
-      {
-        id: "disk",
-        label: "\u{1F4BE} \u78C1\u76D8\u4F7F\u7528",
-        command: "df -h",
-        confirm: false,
-        style: "default" /* Default */
-      },
-      {
-        id: "memory",
-        label: "\u{1F9E0} \u5185\u5B58\u4F7F\u7528",
-        command: "free -h",
-        confirm: false,
-        style: "default" /* Default */
-      },
-      {
-        id: "top",
-        label: "\u{1F4CA} \u8FDB\u7A0B\u76D1\u63A7",
-        command: "top -b -n 1 | head -20",
-        confirm: false,
-        style: "default" /* Default */
-      }
-    ]
-  }
-};
-class MobileControlClient {
-  config;
-  customTemplates = /* @__PURE__ */ new Map();
-  constructor(config) {
-    this.config = {
-      apiUrl: "https://api.claudehome.cn/api/control",
-      debug: false,
-      ...config
-    };
-  }
-  /**
-   * Get API base URL
-   */
-  getApiBase() {
-    return this.config.apiUrl || "https://api.claudehome.cn/api/control";
-  }
-  /**
-   * Get request headers
-   */
-  getHeaders() {
-    return {
-      "Content-Type": "application/json",
-      "Authorization": `Bearer ${this.config.userToken}`
-    };
-  }
-  /**
-   * Debug log
-   */
-  debugLog(message) {
-    if (this.config.debug) {
-      console.log(`[MobileControl] ${message}`);
-    }
-  }
-  /**
-   * Get all available templates (presets + custom)
-   */
-  getTemplates() {
-    return [
-      ...Object.values(PRESET_TEMPLATES),
-      ...Array.from(this.customTemplates.values())
-    ];
-  }
-  /**
-   * Get template by ID
-   */
-  getTemplate(id) {
-    return PRESET_TEMPLATES[id] || this.customTemplates.get(id);
-  }
-  /**
-   * Register custom template
-   */
-  registerTemplate(template) {
-    this.customTemplates.set(template.id, template);
-    this.debugLog(`Registered custom template: ${template.id}`);
-  }
-  /**
-   * Unregister custom template
-   */
-  unregisterTemplate(id) {
-    this.customTemplates.delete(id);
-    this.debugLog(`Unregistered custom template: ${id}`);
-  }
-  /**
-   * Send control card to mobile
-   */
-  async sendCard(request) {
-    try {
-      const template = this.getTemplate(request.templateId);
-      if (!template) {
-        return {
-          success: false,
-          error: `Template not found: ${request.templateId}`
-        };
-      }
-      this.debugLog(`Sending card: ${request.templateId} to ${request.channel}`);
-      const response = await fetch(`${this.getApiBase()}/mobile/send-card`, {
-        method: "POST",
-        headers: this.getHeaders(),
-        body: JSON.stringify({
-          ...request,
-          template: {
-            ...template,
-            message: request.message
-          }
-        })
-      });
-      const result = await response.json();
-      if (result.success) {
-        this.debugLog(`Card sent: ${result.data?.cardId}`);
-      }
-      return result;
-    } catch (error) {
-      this.debugLog(`Send card failed: ${error}`);
-      return {
-        success: false,
-        error: error instanceof Error ? error.message : "Unknown error"
-      };
-    }
-  }
-  /**
-   * Send quick action (single action card)
-   */
-  async sendQuickAction(deviceId, channel, action, message) {
-    const tempTemplate = {
-      id: `temp_${Date.now()}`,
-      name: action.label,
-      description: message || action.label};
-    return this.sendCard({
-      deviceId,
-      channel,
-      templateId: tempTemplate.id,
-      message
-    });
-  }
-  /**
-   * List available templates by category
-   */
-  listTemplatesByCategory(category) {
-    const all = this.getTemplates();
-    return all.filter((t) => t.category === category);
-  }
-  /**
-   * Search templates
-   */
-  searchTemplates(query) {
-    const all = this.getTemplates();
-    const lowerQuery = query.toLowerCase();
-    return all.filter(
-      (t) => t.name.toLowerCase().includes(lowerQuery) || t.description.toLowerCase().includes(lowerQuery) || t.actions.some((a) => a.label.toLowerCase().includes(lowerQuery))
-    );
-  }
-  /**
-   * Get all categories
-   */
-  getCategories() {
-    const all = this.getTemplates();
-    return Array.from(new Set(all.map((t) => t.category))).sort();
-  }
-}
-
-class ResultSender {
-  transporter;
-  config;
-  constructor(config) {
-    this.config = {
-      smtpHost: "smtp.gmail.com",
-      smtpPort: 587,
-      tls: true,
-      ...config
-    };
-    try {
-      const nodemailer = require("nodemailer");
-      this.transporter = nodemailer.createTransport({
-        host: this.config.smtpHost,
-        port: this.config.smtpPort,
-        secure: false,
-        // Use STARTTLS
-        auth: {
-          user: this.config.email,
-          pass: this.config.password
-        }
-      });
-    } catch (_error) {
-      throw new Error("nodemailer package is not installed. Install it with: pnpm add nodemailer @types/nodemailer");
-    }
-  }
-  /**
-   * Send task result email
-   */
-  async send(to, result, command) {
-    try {
-      const subject = result.success ? `\u2705 Task Completed: ${this.truncate(command, 50)}` : `\u274C Task Failed: ${this.truncate(command, 50)}`;
-      const html = this.generateHtml(result, command);
-      const text = this.generateText(result, command);
-      await this.transporter.sendMail({
-        from: `CCJK Daemon <${this.config.email}>`,
-        to,
-        subject,
-        text,
-        html
-      });
-      console.log(`\u{1F4E7} Result email sent to ${to}`);
-    } catch (error) {
-      console.error("Failed to send result email:", error);
-      throw error;
-    }
-  }
-  /**
-   * Generate HTML email content
-   */
-  generateHtml(result, command) {
-    const statusIcon = result.success ? "\u2705" : "\u274C";
-    const statusText = result.success ? "Completed" : "Failed";
-    const statusColor = result.success ? "#10b981" : "#ef4444";
-    return `
-<!DOCTYPE html>
-<html>
-<head>
-  <meta charset="utf-8">
-  <style>
-    body {
-      font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
-      line-height: 1.6;
-      color: #333;
-      max-width: 600px;
-      margin: 0 auto;
-      padding: 20px;
-    }
-    .header {
-      background: ${statusColor};
-      color: white;
-      padding: 20px;
-      border-radius: 8px 8px 0 0;
-      text-align: center;
-    }
-    .content {
-      background: #f9fafb;
-      padding: 20px;
-      border: 1px solid #e5e7eb;
-      border-top: none;
-      border-radius: 0 0 8px 8px;
-    }
-    .section {
-      margin-bottom: 20px;
-    }
-    .label {
-      font-weight: 600;
-      color: #6b7280;
-      font-size: 12px;
-      text-transform: uppercase;
-      margin-bottom: 5px;
-    }
-    .value {
-      background: white;
-      padding: 12px;
-      border-radius: 4px;
-      border: 1px solid #e5e7eb;
-      font-family: 'Monaco', 'Courier New', monospace;
-      font-size: 13px;
-      white-space: pre-wrap;
-      word-break: break-all;
-    }
-    .meta {
-      display: flex;
-      justify-content: space-between;
-      font-size: 12px;
-      color: #6b7280;
-      margin-top: 20px;
-      padding-top: 20px;
-      border-top: 1px solid #e5e7eb;
-    }
-    .error {
-      color: #ef4444;
-    }
-  </style>
-</head>
-<body>
-  <div class="header">
-    <h1>${statusIcon} Task ${statusText}</h1>
-  </div>
-  <div class="content">
-    <div class="section">
-      <div class="label">Command</div>
-      <div class="value">${this.escapeHtml(command)}</div>
-    </div>
-
-    ${result.output ? `
-    <div class="section">
-      <div class="label">Output</div>
-      <div class="value">${this.escapeHtml(result.output)}</div>
-    </div>
-    ` : ""}
-
-    ${result.error ? `
-    <div class="section">
-      <div class="label error">Error</div>
-      <div class="value error">${this.escapeHtml(result.error)}</div>
-    </div>
-    ` : ""}
-
-    <div class="meta">
-      <span>Duration: ${this.formatDuration(result.duration)}</span>
-      <span>Exit Code: ${result.exitCode || 0}</span>
-      <span>Task ID: ${result.taskId}</span>
-    </div>
-  </div>
-</body>
-</html>
-    `.trim();
-  }
-  /**
-   * Generate plain text email content
-   */
-  generateText(result, command) {
-    const statusIcon = result.success ? "\u2705" : "\u274C";
-    const statusText = result.success ? "Completed" : "Failed";
-    let text = `${statusIcon} Task ${statusText}
-
-`;
-    text += `Command:
-${command}
-
-`;
-    if (result.output) {
-      text += `Output:
-${result.output}
-
-`;
-    }
-    if (result.error) {
-      text += `Error:
-${result.error}
-
-`;
-    }
-    text += `---
-`;
-    text += `Duration: ${this.formatDuration(result.duration)}
-`;
-    text += `Exit Code: ${result.exitCode || 0}
-`;
-    text += `Task ID: ${result.taskId}
-`;
-    return text;
-  }
-  /**
-   * Truncate string
-   */
-  truncate(str, maxLength) {
-    if (str.length <= maxLength) {
-      return str;
-    }
-    return `${str.substring(0, maxLength)}...`;
-  }
-  /**
-   * Format duration
-   */
-  formatDuration(ms) {
-    if (ms < 1e3) {
-      return `${ms}ms`;
-    }
-    if (ms < 6e4) {
-      return `${(ms / 1e3).toFixed(1)}s`;
-    }
-    const minutes = Math.floor(ms / 6e4);
-    const seconds = (ms % 6e4 / 1e3).toFixed(0);
-    return `${minutes}m ${seconds}s`;
-  }
-  /**
-   * Escape HTML
-   */
-  escapeHtml(text) {
-    const map = {
-      "&": "&amp;",
-      "<": "&lt;",
-      ">": "&gt;",
-      '"': "&quot;",
-      "'": "&#039;"
-    };
-    return text.replace(/[&<>"']/g, (m) => map[m]);
-  }
-  /**
-   * Test email connection
-   */
-  async testConnection() {
-    try {
-      await this.transporter.verify();
-      return true;
-    } catch (error) {
-      console.error("Email connection test failed:", error);
-      return false;
-    }
-  }
-}
-
-class TaskExecutor {
-  timeout;
-  constructor(timeout = 3e5) {
-    this.timeout = timeout;
-  }
-  /**
-   * Execute a task
-   */
-  async execute(task) {
-    const startTime = Date.now();
-    try {
-      console.log(`\u{1F504} Executing task ${task.id}: ${task.command}`);
-      const parts = task.command.trim().split(/\s+/);
-      const command = parts[0];
-      const args = parts.slice(1);
-      const result = await exec(command, args, {
-        nodeOptions: {
-          cwd: task.projectPath
-        },
-        timeout: this.timeout
-      });
-      const duration = Date.now() - startTime;
-      console.log(`\u2705 Task ${task.id} completed in ${duration}ms`);
-      return {
-        taskId: task.id,
-        success: true,
-        output: result.stdout || "",
-        error: null,
-        duration,
-        exitCode: 0
-      };
-    } catch (error) {
-      const duration = Date.now() - startTime;
-      console.error(`\u274C Task ${task.id} failed:`, error.message);
-      return {
-        taskId: task.id,
-        success: false,
-        output: error.stdout || null,
-        error: error.stderr || error.message,
-        duration,
-        exitCode: error.exitCode || 1
-      };
-    }
-  }
-  /**
-   * Execute multiple tasks sequentially
-   */
-  async executeSequential(tasks) {
-    const results = [];
-    for (const task of tasks) {
-      const result = await this.execute(task);
-      results.push(result);
-      if (!result.success) {
-        break;
-      }
-    }
-    return results;
-  }
-  /**
-   * Execute multiple tasks in parallel
-   */
-  async executeParallel(tasks) {
-    const promises = tasks.map((task) => this.execute(task));
-    return Promise.all(promises);
-  }
-}
-
-class SecurityManager {
-  allowedSenders;
-  allowedCommands;
-  blockedCommands;
-  constructor(config) {
-    this.allowedSenders = new Set(config.allowedSenders);
-    this.allowedCommands = new Set(config.allowedCommands || this.getDefaultAllowedCommands());
-    this.blockedCommands = new Set(config.blockedCommands || this.getDefaultBlockedCommands());
-  }
-  /**
-   * Check if sender is allowed
-   */
-  checkSender(email) {
-    const normalizedEmail = email.toLowerCase().trim();
-    if (this.allowedSenders.has(normalizedEmail)) {
-      return { allowed: true };
-    }
-    return {
-      allowed: false,
-      reason: `Sender ${email} is not in the whitelist`
-    };
-  }
-  /**
-   * Check if command is allowed
-   */
-  checkCommand(command) {
-    const normalizedCommand = command.trim();
-    for (const blocked of this.blockedCommands) {
-      if (normalizedCommand.includes(blocked)) {
-        return {
-          allowed: false,
-          reason: `Command contains blocked pattern: ${blocked}`
-        };
-      }
-    }
-    if (this.allowedCommands.size === 0) {
-      return { allowed: true };
-    }
-    for (const allowed of this.allowedCommands) {
-      if (normalizedCommand.startsWith(allowed)) {
-        return { allowed: true };
-      }
-    }
-    return {
-      allowed: false,
-      reason: `Command does not match any allowed pattern`
-    };
-  }
-  /**
-   * Perform full security check
-   */
-  performSecurityCheck(sender, command) {
-    const senderCheck = this.checkSender(sender);
-    if (!senderCheck.allowed) {
-      return senderCheck;
-    }
-    const commandCheck = this.checkCommand(command);
-    if (!commandCheck.allowed) {
-      return commandCheck;
-    }
-    return { allowed: true };
-  }
-  /**
-   * Add allowed sender
-   */
-  addAllowedSender(email) {
-    this.allowedSenders.add(email.toLowerCase().trim());
-  }
-  /**
-   * Remove allowed sender
-   */
-  removeAllowedSender(email) {
-    this.allowedSenders.delete(email.toLowerCase().trim());
-  }
-  /**
-   * Get default allowed commands
-   */
-  getDefaultAllowedCommands() {
-    return [
-      "npm test",
-      "npm run",
-      "pnpm test",
-      "pnpm run",
-      "yarn test",
-      "yarn run",
-      "git status",
-      "git log",
-      "git diff",
-      "claude",
-      "ccjk",
-      "status",
-      "echo",
-      "ls",
-      "pwd"
-    ];
-  }
-  /**
-   * Get default blocked commands
-   */
-  getDefaultBlockedCommands() {
-    return [
-      "rm -rf",
-      "rm -fr",
-      "sudo",
-      "su",
-      "chmod 777",
-      "chown",
-      "git push --force",
-      "git push -f",
-      "dd if=",
-      "mkfs",
-      "format",
-      ":(){:|:&};:",
-      "curl | sh",
-      "wget | sh",
-      "eval",
-      "exec"
-    ];
-  }
-}
-
-class WSLogStreamer extends EventEmitter {
-  config;
-  ws = null;
-  state = "disconnected" /* Disconnected */;
-  reconnectTimer = null;
-  reconnectAttempts = 0;
-  pingTimer = null;
-  activeStreams = /* @__PURE__ */ new Set();
-  // Default WebSocket base URL
-  static DEFAULT_WS_URL = "wss://api.claudehome.cn/api/control/logs";
-  constructor(config) {
-    super();
-    this.config = {
-      wsUrl: WSLogStreamer.DEFAULT_WS_URL,
-      autoReconnect: true,
-      reconnectDelay: 5e3,
-      maxReconnectAttempts: 10,
-      pingInterval: 3e4,
-      debug: false,
-      ...config
-    };
-  }
-  /**
-   * Get WebSocket URL with auth token
-   */
-  getUrl() {
-    return `${this.config.wsUrl}/${this.config.deviceId}?token=${this.config.token}`;
-  }
-  /**
-   * Debug log
-   */
-  debugLog(message) {
-    if (this.config.debug) {
-      console.log(`[WSLogStreamer] ${message}`);
-    }
-  }
-  /**
-   * Update state and emit event
-   */
-  setState(newState) {
-    const oldState = this.state;
-    this.state = newState;
-    this.emit("stateChange", { oldState, newState });
-    this.debugLog(`State: ${oldState} -> ${newState}`);
-  }
-  /**
-   * Connect to WebSocket server
-   */
-  async connect() {
-    if (this.ws && (this.ws.readyState === WebSocket.OPEN || this.ws.readyState === WebSocket.CONNECTING)) {
-      this.debugLog("Already connected or connecting");
-      return;
-    }
-    this.setState("connecting" /* Connecting */);
-    this.reconnectAttempts = 0;
-    return new Promise((resolve, reject) => {
-      try {
-        const url = this.getUrl();
-        this.debugLog(`Connecting to: ${url.replace(this.config.token, "***")}`);
-        this.connectWithFetch(url).then(() => {
-          this.onConnected();
-          resolve();
-        }).catch((err) => {
-          this.setState("error" /* Error */);
-          this.handleConnectError(err);
-          reject(err);
-        });
-      } catch (error) {
-        this.setState("error" /* Error */);
-        reject(error);
-      }
-    });
-  }
-  /**
-   * Connect using fetch with Server-Sent Events fallback
-   * This is needed for Node.js environments without native WebSocket
-   */
-  async connectWithFetch(_url) {
-    this.debugLog("Creating simulated WebSocket connection");
-    this.ws = {
-      readyState: WebSocket.OPEN,
-      send: (data) => {
-        this.debugLog(`Sent: ${typeof data === "string" ? data : "[binary]"}`);
-      },
-      close: () => {
-        this.debugLog("Connection closed");
-        this.cleanup();
-      },
-      addEventListener: (_event, _listener) => {
-      },
-      removeEventListener: (_event, _listener) => {
-      }
-    };
-    this.debugLog("Connected (simulated)");
-  }
-  /**
-   * Handle successful connection
-   */
-  onConnected() {
-    this.setState("connected" /* Connected */);
-    this.reconnectAttempts = 0;
-    this.emit("connected");
-    this.startPing();
-    this.subscribe(this.config.deviceId);
-  }
-  /**
-   * Handle connection error
-   */
-  handleConnectError(error) {
-    this.debugLog(`Connection error: ${error.message}`);
-    this.emit("error", error);
-    if (this.config.autoReconnect && this.reconnectAttempts < (this.config.maxReconnectAttempts || 10)) {
-      this.scheduleReconnect();
-    }
-  }
-  /**
-   * Schedule reconnection attempt
-   */
-  scheduleReconnect() {
-    if (this.reconnectTimer) {
-      return;
-    }
-    this.setState("reconnecting" /* Reconnecting */);
-    this.reconnectAttempts++;
-    const delay = (this.config.reconnectDelay || 5e3) * Math.min(this.reconnectAttempts, 5);
-    this.debugLog(`Reconnecting in ${delay}ms (attempt ${this.reconnectAttempts})`);
-    this.reconnectTimer = setTimeout(() => {
-      this.reconnectTimer = null;
-      this.connect().catch((err) => {
-        this.debugLog(`Reconnect failed: ${err.message}`);
-      });
-    }, delay);
-  }
-  /**
-   * Start ping interval
-   */
-  startPing() {
-    this.stopPing();
-    this.pingTimer = setInterval(() => {
-      if (this.isConnected()) {
-        this.ping();
-      }
-    }, this.config.pingInterval || 3e4);
-  }
-  /**
-   * Stop ping interval
-   */
-  stopPing() {
-    if (this.pingTimer) {
-      clearInterval(this.pingTimer);
-      this.pingTimer = null;
-    }
-  }
-  /**
-   * Subscribe to log stream
-   */
-  subscribe(deviceId, commandId) {
-    const message = {
-      type: "subscribe" /* Subscribe */,
-      deviceId,
-      commandId
-    };
-    this.send(message);
-    const streamKey = commandId ? `${deviceId}:${commandId}` : deviceId;
-    this.activeStreams.add(streamKey);
-    this.debugLog(`Subscribed to: ${streamKey}`);
-    this.emit("subscribed", { deviceId, commandId });
-  }
-  /**
-   * Unsubscribe from log stream
-   */
-  unsubscribe(streamId) {
-    const message = {
-      type: "unsubscribe" /* Unsubscribe */,
-      streamId
-    };
-    this.send(message);
-    this.activeStreams.delete(streamId);
-    this.debugLog(`Unsubscribed from: ${streamId}`);
-    this.emit("unsubscribed", { streamId });
-  }
-  /**
-   * Send ping to server
-   */
-  ping() {
-    const message = {
-      type: "ping" /* Ping */
-    };
-    this.send(message);
-  }
-  /**
-   * Send message to server
-   */
-  send(message) {
-    if (!this.isConnected()) {
-      this.debugLog("Cannot send: not connected");
-      return;
-    }
-    try {
-      this.ws?.send(JSON.stringify(message));
-    } catch (error) {
-      this.debugLog(`Send error: ${error}`);
-    }
-  }
-  /**
-   * Stream log entry to server
-   */
-  streamLog(entry) {
-    if (!this.isConnected()) {
-      this.debugLog("Cannot stream log: not connected");
-      return;
-    }
-    const message = {
-      type: "log" /* Log */,
-      data: entry
-    };
-    this.send(message);
-    this.emit("logSent", entry);
-  }
-  /**
-   * Check if connected
-   */
-  isConnected() {
-    return this.state === "connected" /* Connected */ && this.ws?.readyState === WebSocket.OPEN;
-  }
-  /**
-   * Get current state
-   */
-  getState() {
-    return this.state;
-  }
-  /**
-   * Disconnect from server
-   */
-  disconnect() {
-    this.debugLog("Disconnecting...");
-    if (this.reconnectTimer) {
-      clearTimeout(this.reconnectTimer);
-      this.reconnectTimer = null;
-    }
-    this.stopPing();
-    if (this.ws) {
-      this.ws.close();
-      this.ws = null;
-    }
-    this.activeStreams.clear();
-    this.setState("disconnected" /* Disconnected */);
-    this.emit("disconnected");
-  }
-  /**
-   * Cleanup resources
-   */
-  cleanup() {
-    this.stopPing();
-    if (this.reconnectTimer) {
-      clearTimeout(this.reconnectTimer);
-      this.reconnectTimer = null;
-    }
-    this.activeStreams.clear();
-  }
-  /**
-   * Get active streams count
-   */
-  getActiveStreamsCount() {
-    return this.activeStreams.size;
-  }
-  /**
-   * Get device ID
-   */
-  getDeviceId() {
-    return this.config.deviceId;
-  }
-}
-function createLogEntry(level, source, message, commandId) {
-  return {
-    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-    level,
-    source,
-    message,
-    commandId
-  };
-}
-class DaemonLogStreamer {
-  streamer;
-  originalConsole;
-  consoleInterceptEnabled = false;
-  constructor(config) {
-    this.streamer = new WSLogStreamer(config);
-    this.originalConsole = {
-      log: console.log.bind(console),
-      warn: console.warn.bind(console),
-      error: console.error.bind(console),
-      debug: console.debug.bind(console)
-    };
-  }
-  /**
-   * Start log streaming
-   */
-  async start() {
-    await this.streamer.connect();
-    this.enableConsoleInterception();
-  }
-  /**
-   * Stop log streaming
-   */
-  stop() {
-    this.disableConsoleInterception();
-    this.streamer.disconnect();
-  }
-  /**
-   * Enable console interception
-   */
-  enableConsoleInterception() {
-    if (this.consoleInterceptEnabled) {
-      return;
-    }
-    const self = this;
-    console.log = function(...args) {
-      self.originalConsole.log(...args);
-      self.streamLog("info" /* Info */, "console", args.join(" "));
-    };
-    console.warn = function(...args) {
-      self.originalConsole.warn(...args);
-      self.streamLog("warn" /* Warn */, "console", args.join(" "));
-    };
-    console.error = function(...args) {
-      self.originalConsole.error(...args);
-      self.streamLog("error" /* Error */, "console", args.join(" "));
-    };
-    console.debug = function(...args) {
-      self.originalConsole.debug(...args);
-      self.streamLog("debug" /* Debug */, "console", args.join(" "));
-    };
-    this.consoleInterceptEnabled = true;
-  }
-  /**
-   * Disable console interception
-   */
-  disableConsoleInterception() {
-    if (!this.consoleInterceptEnabled) {
-      return;
-    }
-    console.log = this.originalConsole.log;
-    console.warn = this.originalConsole.warn;
-    console.error = this.originalConsole.error;
-    console.debug = this.originalConsole.debug;
-    this.consoleInterceptEnabled = false;
-  }
-  /**
-   * Stream log entry
-   */
-  streamLog(level, source, message) {
-    if (this.streamer.isConnected()) {
-      this.streamer.streamLog(createLogEntry(level, source, message));
-    }
-  }
-  /**
-   * Stream a custom log entry
-   */
-  log(entry) {
-    if (this.streamer.isConnected()) {
-      this.streamer.streamLog(entry);
-    }
-  }
-  /**
-   * Subscribe to command-specific logs
-   */
-  subscribeToCommand(commandId) {
-    this.streamer.subscribe(this.streamer.getDeviceId(), commandId);
-  }
-  /**
-   * Unsubscribe from command logs
-   */
-  unsubscribeFromCommand(commandId) {
-    const streamId = `${this.streamer.getDeviceId()}:${commandId}`;
-    this.streamer.unsubscribe(streamId);
-  }
-  /**
-   * Get streamer state
-   */
-  getState() {
-    return this.streamer.getState();
-  }
-  /**
-   * Check if streaming
-   */
-  isStreaming() {
-    return this.streamer.isConnected();
-  }
-  /**
-   * Listen to streamer events
-   */
-  on(event, listener) {
-    this.streamer.on(event, listener);
-  }
-  /**
-   * Remove event listener
-   */
-  off(event, listener) {
-    this.streamer.off(event, listener);
-  }
-}
-
-class CcjkDaemon {
-  config;
-  emailChecker;
-  taskExecutor;
-  resultSender;
-  securityManager;
-  cloudClient;
-  logStreamer;
-  mobileControl;
-  mode;
-  running = false;
-  checkInterval = null;
-  startTime = null;
-  tasksExecuted = 0;
-  lastCheckTime = null;
-  constructor(config) {
-    this.config = {
-      checkInterval: 3e4,
-      // 30 seconds
-      commandTimeout: 3e5,
-      // 5 minutes
-      projectPath: process__default.cwd(),
-      debug: false,
-      mode: "email",
-      ...config
-    };
-    this.mode = this.config.mode || (this.config.cloudToken ? "cloud" : "email");
-    this.emailChecker = new EmailChecker(this.config.email);
-    this.taskExecutor = new TaskExecutor(this.config.commandTimeout);
-    this.resultSender = new ResultSender(this.config.email);
-    this.securityManager = new SecurityManager(this.config);
-    if (this.config.cloudToken && (this.mode === "cloud" || this.mode === "hybrid")) {
-      this.cloudClient = new CloudClient({
-        deviceToken: this.config.cloudToken,
-        apiUrl: this.config.cloudApiUrl,
-        heartbeatInterval: this.config.heartbeatInterval || 3e4,
-        debug: this.config.debug
-      });
-      const deviceInfo = this.cloudClient.getDeviceInfo();
-      if (deviceInfo) {
-        this.logStreamer = new DaemonLogStreamer({
-          deviceId: deviceInfo.device.id,
-          token: this.config.cloudToken,
-          debug: this.config.debug
-        });
-      }
-      this.mobileControl = new MobileControlClient({
-        userToken: this.config.cloudToken,
-        debug: this.config.debug
-      });
-    }
-  }
-  /**
-   * Start the daemon
-   */
-  async start() {
-    if (this.running) {
-      console.log("\u26A0\uFE0F  Daemon is already running");
-      return;
-    }
-    console.log("\u{1F680} CCJK Daemon starting...");
-    console.log(`\u{1F4E1} Mode: ${this.mode.toUpperCase()}`);
-    if (this.cloudClient && (this.mode === "cloud" || this.mode === "hybrid")) {
-      console.log("\u2601\uFE0F  Connecting to cloud API...");
-      const registrationResult = await this.cloudClient.register({
-        name: this.config.deviceName
-      });
-      if (registrationResult.success) {
-        const deviceInfo = this.cloudClient.getDeviceInfo();
-        console.log(`\u2705 Cloud connected - Device ID: ${deviceInfo?.device.id}`);
-        console.log(`   Device name: ${deviceInfo?.device.name}`);
-        if (!this.logStreamer && deviceInfo) {
-          this.logStreamer = new DaemonLogStreamer({
-            deviceId: deviceInfo.device.id,
-            token: this.config.cloudToken,
-            debug: this.config.debug
-          });
-        }
-        if (this.logStreamer) {
-          this.logStreamer.start().catch((err) => {
-            console.warn("\u26A0\uFE0F  Log streaming failed to start:", err.message);
-          });
-        }
-        this.cloudClient.startHeartbeat((tasks) => {
-          this.processCloudTasks(tasks).catch((err) => {
-            console.error("Error processing cloud tasks:", err);
-          });
-        });
-      } else {
-        console.error(`\u274C Cloud registration failed: ${registrationResult.error}`);
-        if (this.mode === "cloud") {
-          throw new Error(`Cloud registration failed: ${registrationResult.error}`);
-        }
-        console.log("\u26A0\uFE0F  Continuing with email mode only...");
-      }
-    }
-    if (this.mode === "email" || this.mode === "hybrid") {
-      console.log("\u{1F4E7} Testing email connection...");
-      const emailOk = await this.resultSender.testConnection();
-      if (!emailOk) {
-        throw new Error("Failed to connect to email server. Please check your email configuration.");
-      }
-      console.log(`\u2705 Email connected - Monitoring: ${this.config.email.email}`);
-    }
-    this.running = true;
-    this.startTime = /* @__PURE__ */ new Date();
-    console.log(`\u2705 CCJK Daemon started`);
-    console.log(`\u{1F4C2} Project: ${this.config.projectPath}`);
-    if (this.mode === "email" || this.mode === "hybrid") {
-      console.log(`\u23F1\uFE0F  Check interval: ${this.config.checkInterval}ms`);
-      console.log(`\u{1F465} Allowed senders: ${this.config.allowedSenders.join(", ")}`);
-    }
-    if (this.mode === "email" || this.mode === "hybrid") {
-      this.scheduleCheck();
-    }
-  }
-  /**
-   * Stop the daemon
-   */
-  async stop() {
-    if (!this.running) {
-      console.log("\u26A0\uFE0F  Daemon is not running");
-      return;
-    }
-    console.log("\u{1F6D1} Stopping CCJK Daemon...");
-    if (this.logStreamer) {
-      console.log("\u{1F4E1} Stopping log streaming...");
-      this.logStreamer.stop();
-    }
-    if (this.cloudClient) {
-      console.log("\u2601\uFE0F  Disconnecting from cloud...");
-      await this.cloudClient.goOffline();
-    }
-    if (this.checkInterval) {
-      clearInterval(this.checkInterval);
-      this.checkInterval = null;
-    }
-    this.emailChecker.disconnect();
-    this.running = false;
-    this.startTime = null;
-    console.log("\u2705 CCJK Daemon stopped");
-  }
-  /**
-   * Schedule periodic email checks
-   */
-  scheduleCheck() {
-    this.checkAndExecute().catch((err) => {
-      console.error("Error in check cycle:", err);
-    });
-    this.checkInterval = setInterval(() => {
-      this.checkAndExecute().catch((err) => {
-        console.error("Error in check cycle:", err);
-      });
-    }, this.config.checkInterval);
-  }
-  /**
-   * Check for new emails and execute tasks
-   */
-  async checkAndExecute() {
-    if (!this.running) {
-      return;
-    }
-    try {
-      this.lastCheckTime = /* @__PURE__ */ new Date();
-      if (this.config.debug) {
-        console.log(`\u{1F50D} Checking for new emails... (${this.lastCheckTime.toISOString()})`);
-      }
-      const emails = await this.emailChecker.fetchNew();
-      if (emails.length === 0) {
-        if (this.config.debug) {
-          console.log("\u{1F4ED} No new emails");
-        }
-        return;
-      }
-      console.log(`\u{1F4EC} Found ${emails.length} new email(s)`);
-      for (const email of emails) {
-        await this.processEmail(email);
-      }
-    } catch (error) {
-      console.error("\u274C Error checking emails:", error);
-    }
-  }
-  /**
-   * Process a single email
-   */
-  async processEmail(email) {
-    try {
-      const sender = this.emailChecker.extractSenderEmail(email.from);
-      console.log(`\u{1F4E7} Processing email from: ${sender}`);
-      const command = this.emailChecker.parseCommand(email);
-      if (!command) {
-        console.log("\u26A0\uFE0F  No command found in email");
-        return;
-      }
-      console.log(`\u{1F4DD} Command: ${command}`);
-      const securityCheck = this.securityManager.performSecurityCheck(sender, command);
-      if (!securityCheck.allowed) {
-        console.log(`\u{1F6AB} Security check failed: ${securityCheck.reason}`);
-        await this.sendSecurityError(sender, command, securityCheck.reason);
-        return;
-      }
-      const task = {
-        id: nanoid(10),
-        command,
-        sender,
-        projectPath: this.config.projectPath,
-        createdAt: /* @__PURE__ */ new Date(),
-        status: "pending"
-      };
-      task.status = "running";
-      task.startTime = Date.now();
-      const result = await this.taskExecutor.execute(task);
-      task.status = result.success ? "completed" : "failed";
-      this.tasksExecuted++;
-      await this.resultSender.send(sender, result, command);
-      console.log(`\u2705 Task ${task.id} processed successfully`);
-    } catch (error) {
-      console.error("\u274C Error processing email:", error);
-    }
-  }
-  /**
-   * Send security error email
-   */
-  async sendSecurityError(to, command, reason) {
-    try {
-      await this.resultSender.send(to, {
-        taskId: "security-error",
-        success: false,
-        output: null,
-        error: `Security check failed: ${reason}`,
-        duration: 0,
-        exitCode: 403
-      }, command);
-    } catch (error) {
-      console.error("Failed to send security error email:", error);
-    }
-  }
-  /**
-   * Process cloud tasks from API
-   */
-  async processCloudTasks(tasks) {
-    if (!this.running || tasks.length === 0) {
-      return;
-    }
-    console.log(`\u2601\uFE0F  Processing ${tasks.length} cloud task(s)`);
-    for (const cloudTask of tasks) {
-      await this.executeCloudTask(cloudTask);
-    }
-  }
-  /**
-   * Execute a single cloud task
-   */
-  async executeCloudTask(cloudTask) {
-    try {
-      console.log(`\u2601\uFE0F  Executing cloud command: ${cloudTask.id}`);
-      console.log(`   Type: ${cloudTask.commandType}`);
-      console.log(`   Command: ${cloudTask.command}`);
-      let commandString = cloudTask.command;
-      if (cloudTask.args && cloudTask.args.length > 0) {
-        commandString = `${cloudTask.command} ${cloudTask.args.join(" ")}`;
-      }
-      const task = {
-        id: cloudTask.id,
-        command: commandString,
-        sender: "cloud-api",
-        projectPath: cloudTask.cwd || this.config.projectPath,
-        createdAt: /* @__PURE__ */ new Date(),
-        status: "pending"
-      };
-      this.cloudClient?.addTask(cloudTask.id);
-      task.status = "running";
-      task.startTime = Date.now();
-      const startTime = Date.now();
-      let result;
-      try {
-        result = await this.taskExecutor.execute(task);
-      } catch (error) {
-        result = {
-          success: false,
-          output: null,
-          error: error instanceof Error ? error.message : String(error),
-          duration: Date.now() - startTime,
-          exitCode: 1
-        };
-      }
-      task.status = result.success ? "completed" : "failed";
-      this.tasksExecuted++;
-      const cloudResult = {
-        exitCode: result.exitCode || (result.success ? 0 : 1),
-        stdout: result.output || "",
-        stderr: result.error || "",
-        success: result.success,
-        duration: result.duration
-      };
-      await this.cloudClient?.reportResult(cloudTask.id, cloudResult);
-      console.log(`\u2705 Cloud task ${cloudTask.id} processed: ${result.success ? "success" : "failed"}`);
-    } catch (error) {
-      console.error(`\u274C Error executing cloud task ${cloudTask.id}:`, error);
-      await this.cloudClient?.reportResult(cloudTask.id, {
-        exitCode: 1,
-        stdout: "",
-        stderr: error instanceof Error ? error.message : String(error),
-        success: false,
-        duration: 0
-      });
-    }
-  }
-  /**
-   * Get daemon status
-   */
-  getStatus() {
-    const deviceInfo = this.cloudClient?.getDeviceInfo();
-    return {
-      running: this.running,
-      pid: process__default.pid,
-      startTime: this.startTime || void 0,
-      uptime: this.startTime ? Date.now() - this.startTime.getTime() : void 0,
-      tasksExecuted: this.tasksExecuted,
-      lastCheckTime: this.lastCheckTime || void 0,
-      config: {
-        email: {
-          email: this.config.email.email,
-          password: "***",
-          imapHost: this.config.email.imapHost,
-          smtpHost: this.config.email.smtpHost
-        },
-        allowedSenders: this.config.allowedSenders,
-        checkInterval: this.config.checkInterval,
-        commandTimeout: this.config.commandTimeout,
-        projectPath: this.config.projectPath,
-        mode: this.mode,
-        cloudConnected: this.cloudClient?.isConnected() ?? false,
-        cloudDeviceId: deviceInfo?.device.id,
-        cloudDeviceName: deviceInfo?.device.name,
-        activeTasksCount: this.cloudClient?.getActiveTasksCount()
-      }
-    };
-  }
-  /**
-   * Get current mode
-   */
-  getMode() {
-    return this.mode;
-  }
-  /**
-   * Get mobile control client
-   */
-  getMobileControl() {
-    return this.mobileControl;
-  }
-  /**
-   * Get log streamer
-   */
-  getLogStreamer() {
-    return this.logStreamer;
-  }
-  /**
-   * Get cloud client
-   */
-  getCloudClient() {
-    return this.cloudClient;
-  }
-  /**
-   * Send mobile control card
-   */
-  async sendMobileCard(channel, templateId, message) {
-    const deviceInfo = this.cloudClient?.getDeviceInfo();
-    if (!deviceInfo || !this.mobileControl) {
-      throw new Error("Cloud client not connected or mobile control not available");
-    }
-    return this.mobileControl.sendCard({
-      deviceId: deviceInfo.device.id,
-      channel,
-      templateId,
-      message
-    });
-  }
-  /**
-   * Check if daemon is running
-   */
-  isRunning() {
-    return this.running;
-  }
-}
-
-const CONFIG_DIR = join(homedir(), ".ccjk");
-const CONFIG_FILE = join(CONFIG_DIR, "daemon-config.json");
-const PID_FILE = join(CONFIG_DIR, "daemon.pid");
-async function setupDaemon() {
-  console.log("\u{1F527} CCJK Daemon Setup\n");
-  const answers = await inquirer.prompt([
-    {
-      type: "list",
-      name: "mode",
-      message: "Select daemon mode:",
-      choices: [
-        { name: "\u{1F4E7} Email (traditional email-based control)", value: "email" },
-        { name: "\u2601\uFE0F  Cloud (cloud API control via api.claudehome.cn)", value: "cloud" },
-        { name: "\u{1F504} Hybrid (both email and cloud control)", value: "hybrid" }
-      ],
-      default: "email"
-    },
-    {
-      type: "input",
-      name: "email",
-      message: "Your email address:",
-      validate: (input) => {
-        if (!input.includes("@")) {
-          return "Please enter a valid email address";
-        }
-        return true;
-      },
-      when: (answers2) => answers2.mode === "email" || answers2.mode === "hybrid"
-    },
-    {
-      type: "password",
-      name: "password",
-      message: "Email password (or app-specific password):",
-      mask: "*",
-      validate: (input) => {
-        if (!input) {
-          return "Password is required";
-        }
-        return true;
-      },
-      when: (answers2) => answers2.mode === "email" || answers2.mode === "hybrid"
-    },
-    {
-      type: "input",
-      name: "cloudToken",
-      message: "Cloud device token (from api.claudehome.cn):",
-      validate: (input) => {
-        if (!input || input.length < 10) {
-          return "Please enter a valid cloud token";
-        }
-        return true;
-      },
-      when: (answers2) => answers2.mode === "cloud" || answers2.mode === "hybrid"
-    },
-    {
-      type: "input",
-      name: "deviceName",
-      message: "Device name (for cloud registration):",
-      default: () => {
-        const os = require("node:os");
-        return `CCJK Device (${os.hostname()})`;
-      },
-      when: (answers2) => answers2.mode === "cloud" || answers2.mode === "hybrid"
-    },
-    {
-      type: "input",
-      name: "allowedSenders",
-      message: "Allowed sender emails (comma-separated):",
-      default: (answers2) => answers2.email || "",
-      filter: (input) => input.split(",").map((s) => s.trim()).filter(Boolean),
-      when: (answers2) => answers2.mode === "email" || answers2.mode === "hybrid"
-    },
-    {
-      type: "input",
-      name: "projectPath",
-      message: "Project path:",
-      default: process.cwd()
-    },
-    {
-      type: "number",
-      name: "checkInterval",
-      message: "Check interval (seconds):",
-      default: 30,
-      filter: (input) => input * 1e3,
-      when: (answers2) => answers2.mode === "email" || answers2.mode === "hybrid"
-    },
-    {
-      type: "number",
-      name: "heartbeatInterval",
-      message: "Heartbeat interval (seconds):",
-      default: 30,
-      filter: (input) => input * 1e3,
-      when: (answers2) => answers2.mode === "cloud" || answers2.mode === "hybrid"
-    },
-    {
-      type: "confirm",
-      name: "debug",
-      message: "Enable debug logging?",
-      default: false
-    }
-  ]);
-  const config = {
-    email: {
-      email: answers.email || "noreply@example.com",
-      password: answers.password || ""
-    },
-    allowedSenders: answers.allowedSenders || [],
-    projectPath: answers.projectPath,
-    checkInterval: answers.checkInterval || 3e4,
-    heartbeatInterval: answers.heartbeatInterval || 3e4,
-    debug: answers.debug,
-    mode: answers.mode,
-    cloudToken: answers.cloudToken,
-    deviceName: answers.deviceName
-  };
-  if (!existsSync(CONFIG_DIR)) {
-    const fs = await import('node:fs/promises');
-    await fs.mkdir(CONFIG_DIR, { recursive: true });
-  }
-  const configToSave = { ...config };
-  if (config.mode === "cloud") {
-    configToSave.email = {
-      email: "noreply@example.com",
-      password: ""
-    };
-  }
-  writeFileSync(CONFIG_FILE, JSON.stringify(configToSave, null, 2));
-  console.log("\n\u2705 Configuration saved to:", CONFIG_FILE);
-  console.log(`
-\u{1F4E1} Mode: ${answers.mode.toUpperCase()}`);
-  if (answers.mode === "email" || answers.mode === "hybrid") {
-    console.log("\n\u{1F4A1} Email control:");
-    console.log("   Send an email to test:");
-    console.log(`      To: ${answers.email}`);
-    console.log("      Subject: [CCJK] Test");
-    console.log('      Body: echo "Hello CCJK!"');
-  }
-  if (answers.mode === "cloud" || answers.mode === "hybrid") {
-    console.log("\n\u{1F4A1} Cloud control:");
-    console.log("   1. Device registered to api.claudehome.cn");
-    console.log("   2. Use the web interface to send commands");
-    console.log(`   3. Device name: ${answers.deviceName}`);
-  }
-  console.log("\n\u{1F4A1} Next steps:");
-  console.log("   Run: ccjk daemon start");
-}
-async function startDaemon() {
-  if (!existsSync(CONFIG_FILE)) {
-    console.error("\u274C Configuration not found. Please run: ccjk daemon setup");
-    process.exit(1);
-  }
-  if (existsSync(PID_FILE)) {
-    const pid = readFileSync(PID_FILE, "utf-8").trim();
-    console.error(`\u274C Daemon is already running (PID: ${pid})`);
-    console.log("   Run: ccjk daemon stop");
-    process.exit(1);
-  }
-  const config = JSON.parse(readFileSync(CONFIG_FILE, "utf-8"));
-  const daemon = new CcjkDaemon(config);
-  const spinner = ora("Starting CCJK Daemon...").start();
-  try {
-    await daemon.start();
-    spinner.succeed("CCJK Daemon started successfully");
-    writeFileSync(PID_FILE, process.pid.toString());
-    process.on("SIGINT", async () => {
-      console.log("\n\u{1F6D1} Received SIGINT, stopping daemon...");
-      await daemon.stop();
-      if (existsSync(PID_FILE)) {
-        const fs = require("node:fs");
-        fs.unlinkSync(PID_FILE);
-      }
-      process.exit(0);
-    });
-    process.on("SIGTERM", async () => {
-      console.log("\n\u{1F6D1} Received SIGTERM, stopping daemon...");
-      await daemon.stop();
-      if (existsSync(PID_FILE)) {
-        const fs = require("node:fs");
-        fs.unlinkSync(PID_FILE);
-      }
-      process.exit(0);
-    });
-    console.log("\n\u{1F4A1} Press Ctrl+C to stop the daemon");
-  } catch (error) {
-    spinner.fail("Failed to start daemon");
-    console.error(error.message);
-    process.exit(1);
-  }
-}
-async function stopDaemon() {
-  if (!existsSync(PID_FILE)) {
-    console.log("\u26A0\uFE0F  Daemon is not running");
-    return;
-  }
-  const pid = readFileSync(PID_FILE, "utf-8").trim();
-  const spinner = ora(`Stopping daemon (PID: ${pid})...`).start();
-  try {
-    process.kill(Number.parseInt(pid), "SIGTERM");
-    await new Promise((resolve) => setTimeout(resolve, 3e3));
-    if (existsSync(PID_FILE)) {
-      const fs = require("node:fs");
-      fs.unlinkSync(PID_FILE);
-    }
-    spinner.succeed("Daemon stopped successfully");
-  } catch (error) {
-    spinner.fail("Failed to stop daemon");
-    console.error(error.message);
-    process.exit(1);
-  }
-}
-async function showStatus() {
-  console.log("\u{1F4CA} CCJK Daemon Status\n");
-  if (!existsSync(PID_FILE)) {
-    console.log("Status: \u26AA Not running");
-    return;
-  }
-  const pid = readFileSync(PID_FILE, "utf-8").trim();
-  try {
-    process.kill(Number.parseInt(pid), 0);
-    console.log("Status: \u{1F7E2} Running");
-    console.log(`PID: ${pid}`);
-  } catch {
-    console.log("Status: \u{1F534} Dead (PID file exists but process not found)");
-    console.log("Run: ccjk daemon start");
-    return;
-  }
-  if (existsSync(CONFIG_FILE)) {
-    const config = JSON.parse(readFileSync(CONFIG_FILE, "utf-8"));
-    console.log(`
-Configuration:`);
-    console.log(`  Mode: ${config.mode?.toUpperCase() || "EMAIL"}`);
-    if (config.mode === "email" || config.mode === "hybrid") {
-      console.log(`  Email: ${config.email.email}`);
-      console.log(`  Check Interval: ${config.checkInterval}ms`);
-      console.log(`  Allowed Senders: ${config.allowedSenders.join(", ") || "None"}`);
-    }
-    if (config.mode === "cloud" || config.mode === "hybrid") {
-      console.log(`  Cloud API: ${config.cloudApiUrl || "https://api.claudehome.cn/api/control"}`);
-      console.log(`  Device Name: ${config.deviceName || "N/A"}`);
-      console.log(`  Heartbeat Interval: ${config.heartbeatInterval}ms`);
-    }
-    console.log(`  Project: ${config.projectPath}`);
-    console.log(`  Debug: ${config.debug ? "Enabled" : "Disabled"}`);
-  }
-}
-async function showLogs() {
-  console.log("\u{1F4CB} CCJK Daemon Logs\n");
-  console.log("\u26A0\uFE0F  Log viewing not implemented yet");
-  console.log("\u{1F4A1} Logs are currently printed to stdout");
-  console.log("   Run daemon in foreground to see logs: ccjk daemon start");
-}
-
-export { setupDaemon, showLogs, showStatus, startDaemon, stopDaemon };