@workclaw/cli 1.0.29 → 1.0.30

package/dist/{index-0P3M9kKr.js → index-DCWFh-f4.js}

@@ -3,92 +3,725 @@ import path, { resolve, dirname } from "node:path";
 import process$1 from "node:process";
 import { fileURLToPath } from "node:url";
 import { Command } from "commander";
-import fs from "node:fs/promises";
+import { exec, execSync } from "node:child_process";
+import boxen from "boxen";
 import chalk from "chalk";
+import inquirer from "inquirer";
+import semver from "semver";
+import fs from "node:fs/promises";
 import ora from "ora";
 import axios from "axios";
-import os from "node:os";
-import { execSync } from "node:child_process";
-class BaseCommand {
-  program;
-  options = [];
-  constructor(program2) {
-    this.program = program2;
+import "node:os";
+let isDebug = false;
+function setDebug(debug) {
+  isDebug = debug;
+}
+function debugLog(...args) {
+  if (isDebug) {
+    console.log(chalk.gray(`[DEBUG]`), ...args);
+  }
+}
+const ERROR_CODES$1 = {
+  APP_KEY_REQUIRED: "APP_KEY_REQUIRED",
+  APP_SECRET_REQUIRED: "APP_SECRET_REQUIRED",
+  NODE_VERSION_LOW: "NODE_VERSION_LOW",
+  NPM_NOT_FOUND: "NPM_NOT_FOUND",
+  NPM_INSTALL_FAILED: "NPM_INSTALL_FAILED"
+};
+let AppError$1 = class AppError extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "AppError";
+  }
+};
+const CONFIG = {
+  PLUGIN_NAME: "openclaw-workclaw",
+  DEFAULT_BASE_URL: "https://workbrain.cn/backend-api",
+  DEFAULT_WS_URL: "wss://workbrain.cn/backend-api/open-apis/connect",
+  MODEL_BASE_URL: "https://maas-api.workbrain.cn/v1/",
+  DIRS: {
+    OPENCLAW: ".openclaw",
+    EXTENSIONS: "extensions",
+    CONFIG_FILE: "openclaw.json",
+    WORKSPACE: "workspace",
+    TEMP: ".temp"
+  },
+  IGNORE_FILES: ["node_modules", ".git", ".trae", ".vscode"],
+  API: {
+    TUZAI_BASE_URL: "https://workbrain.cn/backend-api/tuzai",
+    BASE_URL: "https://workbrain.cn/backend-api/open-apis",
+    TIMEOUT: 1e4
+  }
+};
+const TEST_CONFIG = {
+  PLUGIN_NAME: "openclaw-workclaw",
+  DEFAULT_BASE_URL: "http://172.168.80.30:32005",
+  DEFAULT_WS_URL: "ws://172.168.80.30:32005/open-apis/connect",
+  MODEL_BASE_URL: "http://172.168.80.30:30005/v1",
+  DIRS: {
+    OPENCLAW: ".openclaw",
+    EXTENSIONS: "extensions",
+    CONFIG_FILE: "openclaw.json",
+    WORKSPACE: "workspace",
+    TEMP: ".temp"
+  },
+  IGNORE_FILES: ["node_modules", ".git", ".trae", ".vscode"],
+  API: {
+    TUZAI_BASE_URL: "http://172.168.80.30:32005/tuzai",
+    BASE_URL: "http://172.168.80.30:32005/open-apis",
+    TIMEOUT: 1e4
   }
-  init() {
-    const cmd = this.program.command(this.command);
-    cmd.description(this.description);
-    this.options.forEach(({ name, description }) => {
-      cmd.option(name, description);
+};
+function getConfig(env) {
+  return env === "test" ? TEST_CONFIG : CONFIG;
+}
+function getHomeDir$1() {
+  return process$1.env.HOME || process$1.env.USERPROFILE || "";
+}
+const PLUGIN_PACKAGE_NAME$1 = "@workclaw/openclaw-workclaw";
+function execAsync$1(command, options) {
+  return new Promise((resolve2, reject) => {
+    exec(command, { cwd: options.cwd, timeout: options.timeout }, (error, stdout, stderr) => {
+      if (error) {
+        reject(new Error(stderr || error.message));
+      } else {
+        resolve2(stdout);
+      }
     });
-    cmd.action(this.action.bind(this));
+  });
+}
+function deepMerge$1(target, source) {
+  const result = { ...target };
+  for (const key in source) {
+    const sourceValue = source[key];
+    const targetValue = target[key];
+    if (sourceValue !== void 0 && sourceValue !== null && typeof sourceValue === "object" && !Array.isArray(sourceValue) && typeof targetValue === "object" && targetValue !== null && !Array.isArray(targetValue)) {
+      result[key] = deepMerge$1(targetValue, sourceValue);
+    } else if (sourceValue !== void 0) {
+      result[key] = sourceValue;
+    }
   }
+  return result;
 }
-function createLogger() {
-  return {
-    info(message) {
-      console.log(chalk.blue("•"), message);
-    },
-    success(message) {
-      console.log(chalk.green("✓"), message);
-    },
-    warn(message) {
-      console.log(chalk.yellow("!"), message);
-    },
-    error(message) {
-      console.log(chalk.red("✗"), message);
-    },
-    step(message) {
-      console.log(chalk.cyan("›"), chalk.cyan(message));
-    },
-    start(message) {
-      return ora({
-        text: message,
-        color: "cyan"
-      }).start();
+class BoxInstaller {
+  constructor(config) {
+    this.config = config;
+    this.spinner = ora({ color: "cyan" }).start();
+  }
+  spinner;
+  prefixText = "";
+  validateConfig() {
+    debugLog("[验证配置] 检查 appKey 和 appSecret...");
+    if (!this.config.appKey) {
+      throw new AppError$1(ERROR_CODES$1.APP_KEY_REQUIRED, "AppKey 不能为空，请使用 --app-key 参数");
     }
-  };
+    if (!this.config.appSecret) {
+      throw new AppError$1(ERROR_CODES$1.APP_SECRET_REQUIRED, "AppSecret 不能为空，请使用 --app-secret 参数");
+    }
+    debugLog("[验证配置] 配置检查通过");
+  }
+  getPaths() {
+    const home = getHomeDir$1();
+    const openclawDir = path.join(home, ".openclaw");
+    const extensionsDir = path.join(openclawDir, "extensions");
+    const targetDir = path.join(extensionsDir, "openclaw-workclaw");
+    const configFile = path.join(openclawDir, "openclaw.json");
+    const workspaceDir = path.join(openclawDir, "workspace");
+    const tempDir = path.join(openclawDir, ".temp");
+    return {
+      home,
+      extensions: extensionsDir,
+      target: targetDir,
+      config: configFile,
+      workspace: workspaceDir,
+      temp: tempDir
+    };
+  }
+  updateSpinner(text) {
+    this.spinner.prefixText = this.prefixText;
+    this.spinner.text = chalk.cyan(text);
+    debugLog(`[Spinner] ${text}`);
+  }
+  getPrefixText() {
+    return this.prefixText;
+  }
+  async install() {
+    try {
+      debugLog("[盒子安装] 开始安装...");
+      this.validateConfig();
+      this.prefixText += chalk.green(`  ✓ 配置验证完成
+`);
+      this.updateSpinner("配置验证完成");
+      const paths = this.getPaths();
+      await this.doCleanOldFiles(paths);
+      await this.doDownloadFromNpm();
+      await this.doUpdateConfig(paths);
+      this.spinner.stop();
+      debugLog("[盒子安装] 安装完成");
+    } catch (error) {
+      this.spinner.stop();
+      debugLog(`[盒子安装] 安装失败: ${error.message}`);
+      throw error;
+    }
+  }
+  async doCleanOldFiles(paths) {
+    debugLog("[清理旧版本] 开始清理旧版本...");
+    this.prefixText += chalk.green(`  ✓ 开始清理旧版本
+`);
+    this.updateSpinner("正在清理旧版本...");
+    try {
+      await fs.access(paths.target);
+      debugLog("[清理旧版本] 删除旧版本目录...");
+      await fs.rm(paths.target, { recursive: true, force: true });
+      this.prefixText += chalk.green(`  ✓ 旧版本清理成功
+`);
+      debugLog("[清理旧版本] 旧版本清理成功");
+    } catch {
+      debugLog("[清理旧版本] 无旧版本需要清理");
+      this.prefixText += chalk.green(`  ✓ 无旧版本需要清理
+`);
+    }
+    try {
+      await fs.access(paths.temp);
+      await fs.rm(paths.temp, { recursive: true, force: true });
+    } catch {
+      debugLog("[清理旧版本] 无临时目录需要清理");
+    }
+  }
+  async doDownloadFromNpm() {
+    debugLog("[安装插件] 开始安装插件...");
+    this.prefixText += chalk.green(`  ✓ 开始安装插件
+`);
+    this.spinner.prefixText = this.prefixText;
+    this.spinner.text = chalk.cyan("正在安装插件...");
+    try {
+      await execAsync$1(
+        `openclaw plugins install ${PLUGIN_PACKAGE_NAME$1} --dangerously-force-unsafe-install`,
+        { timeout: 12e4 }
+      );
+      debugLog("[安装插件] openclaw plugins install 执行成功");
+      this.prefixText += chalk.green(`  ✓ 插件安装完成
+`);
+    } catch (error) {
+      const errorMsg = error.message || "未知错误";
+      debugLog(`[安装插件] 安装失败: ${errorMsg}`);
+      this.prefixText += chalk.red(`✗ 安装失败
+`);
+      throw new AppError$1(ERROR_CODES$1.NPM_INSTALL_FAILED, `插件安装失败: ${errorMsg}`);
+    }
+  }
+  async doUpdateConfig(paths) {
+    debugLog("[更新配置] 开始更新配置...");
+    this.prefixText += chalk.green(`  ✓ 开始更新配置
+`);
+    this.updateSpinner("正在生成配置...");
+    let originalConfig = {};
+    try {
+      const content = await fs.readFile(paths.config, "utf-8");
+      originalConfig = JSON.parse(content);
+      debugLog("[更新配置] 读取原有配置成功");
+    } catch {
+      debugLog("[更新配置] 无原有配置");
+    }
+    const config = getConfig(this.config.env);
+    const newConfig = {
+      // diagnostics: 诊断配置
+      diagnostics: {
+        // 启用诊断功能
+        enabled: true,
+        // 启用所有诊断标志 ['*'] 表示全部，[] 表示禁用所有
+        flags: ["*"]
+      },
+      // browser: 浏览器配置
+      browser: {
+        // 禁用浏览器工具
+        enabled: false
+      },
+      // models: 模型配置
+      models: {
+        // 配置合并模式：'merge' 合并 | 'replace' 替换
+        mode: "merge",
+        providers: {
+          "siliconflow-minimax": {
+            // 模型 API 基础地址
+            baseUrl: config.MODEL_BASE_URL,
+            // API 密钥（留空，由外部提供）
+            apiKey: "",
+            // API 类型：'openai-completions' | 'openai-chat' 等
+            api: "openai-completions",
+            // 是否使用 Authorization header 认证
+            authHeader: true,
+            models: [{
+              // 模型 ID（provider/model 格式）
+              id: "Pro/MiniMaxAI/MiniMax-M2.5",
+              // 模型显示名称
+              name: "MiniMax-M2.5",
+              // 是否启用推理能力
+              reasoning: false,
+              // 支持的输入类型：['text'] | ['text', 'image']
+              input: ["text"],
+              // 价格（0 表示免费或未设置）
+              cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+              // 上下文窗口大小（token）
+              contextWindow: 2e5,
+              // 最大输出 token 数
+              maxTokens: 65536
+            }]
+          }
+        }
+      },
+      // agents: 代理配置
+      agents: {
+        defaults: {
+          // 默认使用的模型
+          model: { primary: "siliconflow-minimax/Pro/MiniMaxAI/MiniMax-M2.5" },
+          models: {
+            "siliconflow-minimax/Pro/MiniMaxAI/MiniMax-M2.5": {
+              // 模型别名，用于显示
+              alias: "Pro/MiniMaxAI/MiniMax-M2.5"
+            }
+          },
+          // 工作区目录路径
+          workspace: paths.workspace,
+          // 会话压缩模式：'safeguard' 保守模式
+          compaction: { mode: "safeguard" },
+          // 详细程度：'full' | 'short' | 'off'
+          verboseDefault: "full",
+          // 最大并发任务数
+          maxConcurrent: 4,
+          // 子代理最大并发数
+          subagents: { maxConcurrent: 8 }
+        },
+        // 代理列表
+        list: [{ id: "main", workspace: paths.workspace }]
+      },
+      // tools: 工具配置
+      tools: {
+        // 禁用的工具列表（优先于 allow）
+        deny: ["image", "web_search", "web_fetch"],
+        // 图像分析工具
+        media: { image: { enabled: false } },
+        // 网络搜索和抓取工具
+        web: { search: { enabled: false }, fetch: { enabled: false } },
+        // 提升权限工具（host=gateway）
+        elevated: { enabled: true, allowFrom: { webchat: ["*"] } },
+        // exec 工具安全级别：'deny' | 'allowlist' | 'full'
+        exec: { security: "full" }
+      },
+      // bindings: 绑定配置
+      bindings: [{
+        // 绑定的代理 ID
+        agentId: "main",
+        // 匹配的通道和账户
+        match: { channel: "openclaw-workclaw", accountId: "default" }
+      }],
+      // messages: 消息配置
+      messages: {
+        // 消息确认范围
+        ackReactionScope: "group-mentions"
+      },
+      // commands: 命令配置
+      commands: {
+        // 本机命令：'auto' | 'on' | 'off'
+        native: "auto",
+        // 本机技能：'auto' | 'on' | 'off'
+        nativeSkills: "auto",
+        // 是否允许重启命令
+        restart: true,
+        // 所有者显示格式：'raw' | 'name' | 'hidden'
+        ownerDisplay: "raw"
+      },
+      // session: 会话配置
+      session: {
+        // DM 作用域
+        dmScope: "per-account-channel-peer"
+      },
+      // hooks: 钩子配置
+      hooks: {
+        internal: {
+          // 启用内部钩子
+          enabled: true,
+          entries: {
+            // 启动 Markdown 钩子
+            "boot-md": { enabled: true },
+            // 引导额外文件钩子
+            "bootstrap-extra-files": { enabled: true },
+            // 命令日志钩子
+            "command-logger": { enabled: true },
+            // 会话记忆钩子
+            "session-memory": { enabled: true }
+          }
+        }
+      },
+      // channels: 通道配置
+      channels: {
+        "openclaw-workclaw": {
+          // 启用通道
+          enabled: true,
+          // 连接模式：'websocket' | 'http'
+          connectionMode: "websocket",
+          // 应用密钥
+          appKey: this.config.appKey,
+          // 应用密钥
+          appSecret: this.config.appSecret,
+          // API 基础 URL
+          baseUrl: this.config.baseUrl || config.DEFAULT_BASE_URL,
+          // WebSocket URL
+          websocketUrl: this.config.wsUrl || config.DEFAULT_WS_URL,
+          // 允许不安全的 TLS 连接
+          allowInsecureTls: true,
+          // 允许原始 JSON 载荷
+          allowRawJsonPayload: true,
+          // 用户 ID
+          userId: "",
+          // DM 策略
+          dmPolicy: "open",
+          // 允许所有来源
+          allowFrom: ["*"],
+          accounts: {
+            // 账户配置（agentId 为空表示待分配）
+            default: { enabled: true, agentId: "" }
+          }
+        }
+      },
+      // gateway: 网关配置
+      gateway: {
+        // 网关模式：'local' | 'hosted'
+        mode: "local",
+        // 网关端口
+        port: 18789,
+        // 绑定地址：'loopback' | 'lan' | 'all'
+        bind: "loopback",
+        // 认证模式（token字段未设置，是因为需要使用原始配置的token）
+        auth: {
+          mode: "token"
+        },
+        // Tailscale 配置
+        tailscale: { mode: "off", resetOnExit: false },
+        nodes: {
+          // 节点上禁止的命令
+          denyCommands: [
+            "camera.snap",
+            "camera.clip",
+            "screen.record",
+            "contacts.add",
+            "calendar.add",
+            "reminders.add",
+            "sms.send",
+            "sms.search"
+          ]
+        },
+        controlUi: {
+          // 允许不安全认证
+          allowInsecureAuth: true,
+          // 禁用设备认证（仅用于开发）
+          dangerouslyDisableDeviceAuth: true,
+          // 允许 Host 头源回退
+          dangerouslyAllowHostHeaderOriginFallback: true,
+          // 允许的源
+          allowedOrigins: ["http://localhost:18789", "http://127.0.0.1:18789"]
+        }
+      },
+      // skills: 技能配置
+      skills: {
+        // 技能加载监视模式
+        load: { watch: true }
+      },
+      // logging: 日志配置
+      logging: {
+        // 日志级别：'debug' | 'info' | 'warn' | 'error'
+        level: "info",
+        // 控制台日志级别
+        consoleLevel: "info",
+        // 控制台样式：'pretty' | 'basic' | 'raw'
+        consoleStyle: "pretty",
+        // 敏感信息脱敏：'off' | 'keys' | 'all'
+        redactSensitive: "off",
+        // 日志文件路径（空表示不写入文件）
+        file: "",
+        // 脱敏模式（正则表达式）
+        redactPatterns: ["sk-.*"]
+      },
+      // plugins: 插件配置
+      plugins: {}
+    };
+    const finalConfig = deepMerge$1(originalConfig, newConfig);
+    this.updateSpinner("正在写入配置...");
+    debugLog("[更新配置] 写入配置文件...");
+    await fs.writeFile(paths.config, JSON.stringify(finalConfig, null, 2), "utf-8");
+    this.prefixText += chalk.green(`  ✓ 配置文件更新成功
+`);
+    debugLog(`[更新配置] 配置文件写入成功: ${paths.config}`);
+  }
 }
-const logger = createLogger();
-async function readConfig(configPath) {
+function checkEnv$1() {
+  debugLog("[环境检查] 检测 Node.js 版本...");
+  const nodeVersion = execSync("node --version", { stdio: "pipe" }).toString().trim();
+  debugLog(`[环境检查] Node.js 版本: ${nodeVersion}`);
+  if (!semver.gte(nodeVersion, "18.0.0")) {
+    throw new AppError$1(ERROR_CODES$1.NODE_VERSION_LOW, `Node.js 版本需要 >= 18.0.0，当前版本: ${nodeVersion}`);
+  }
+  debugLog("[环境检查] Node.js 版本检查通过");
+  debugLog("[环境检查] 检测 npm...");
   try {
-    const content = await fs.readFile(configPath, "utf-8");
-    return JSON.parse(content);
+    const npmVersion = execSync("npm --version", { stdio: "pipe" }).toString().trim();
+    debugLog(`[环境检查] npm 版本: ${npmVersion}`);
+    debugLog("[环境检查] npm 检测通过");
   } catch {
-    logger.warn(`配置文件不存在或读取失败: ${configPath}`);
-    return null;
+    throw new AppError$1(ERROR_CODES$1.NPM_NOT_FOUND, "未检测到 npm，请先安装 Node.js 和 npm");
   }
 }
-async function writeConfig(configPath, config) {
-  const dir = path.dirname(configPath);
-  await fs.mkdir(dir, { recursive: true });
-  await fs.writeFile(configPath, JSON.stringify(config, null, 2), "utf-8");
-}
-const defaultConfig = {
-  modelUrl: {
-    test: "http://172.168.80.30:30005/v1",
-    prod: "https://maas-api.workbrain.cn/v1/"
+async function createBoxCommand(options) {
+  setDebug(!!options.debug);
+  debugLog("[盒子安装] 开始处理...");
+  debugLog(`[盒子安装] 参数: env=${options.env}, appKey=${options.appKey ? "***" : "未提供"}, debug=${options.debug}`);
+  checkEnv$1();
+  debugLog("[盒子安装] 环境检查通过");
+  try {
+    let env = options.env;
+    let appKey = options.appKey;
+    let appSecret = options.appSecret;
+    const questions = [];
+    if (!env) {
+      debugLog("[盒子安装] 需要选择环境");
+      questions.push({
+        type: "list",
+        name: "env",
+        message: chalk.cyan("请选择环境:"),
+        default: "test",
+        choices: [
+          { name: `${chalk.green("测试环境")} ${chalk.dim("(test)")}`, value: "test" },
+          { name: `${chalk.red("正式环境")} ${chalk.dim("(prod)")}`, value: "prod" }
+        ]
+      });
+    } else {
+      debugLog(`[盒子安装] 使用命令行参数: env=${env}`);
+    }
+    if (!appKey) {
+      debugLog("[盒子安装] 需要输入 AppKey");
+      questions.push({
+        type: "input",
+        name: "appKey",
+        message: chalk.cyan("请输入 AppKey:"),
+        validate: (value) => {
+          if (!value || value.trim() === "") {
+            return chalk.red("AppKey 不能为空");
+          }
+          return true;
+        }
+      });
+    } else {
+      debugLog("[盒子安装] 使用命令行参数: appKey");
+    }
+    if (!appSecret) {
+      debugLog("[盒子安装] 需要输入 AppSecret");
+      questions.push({
+        type: "input",
+        name: "appSecret",
+        message: chalk.cyan("请输入 AppSecret:"),
+        validate: (value) => {
+          if (!value || value.trim() === "") {
+            return chalk.red("AppSecret 不能为空");
+          }
+          return true;
+        }
+      });
+    } else {
+      debugLog("[盒子安装] 使用命令行参数: appSecret");
+    }
+    if (questions.length > 0) {
+      debugLog(`[盒子安装] 开始交互式问答，共 ${questions.length} 个问题`);
+      const answers = await inquirer.prompt(questions);
+      debugLog("[盒子安装] 交互式问答完成");
+      env = env || answers.env || "test";
+      appKey = appKey || answers.appKey;
+      appSecret = appSecret || answers.appSecret;
+    }
+    debugLog(`[盒子安装] 最终参数: env=${env}`);
+    debugLog("[盒子安装] 创建 BoxInstaller 实例...");
+    const installer = new BoxInstaller({
+      appKey,
+      appSecret,
+      env
+    });
+    debugLog("[盒子安装] 开始安装...");
+    await installer.install();
+    debugLog("[盒子安装] 安装完成");
+    console.log(installer.getPrefixText() + boxen(
+      `${chalk.green("✦")} 插件初始化成功！`,
+      {
+        title: `${chalk.bold.green("初始化成功")}`,
+        titleAlignment: "center",
+        padding: { top: 1, bottom: 1, left: 5, right: 5 },
+        margin: 1,
+        borderStyle: "round",
+        borderColor: "green",
+        textAlignment: "center"
+      }
+    ));
+  } catch (error) {
+    debugLog(`[盒子安装] 发生错误: ${error.message}`);
+    console.error(boxen(
+      `${chalk.yellow(error.message)}`,
+      {
+        title: `${chalk.bold.red("初始化失败")}`,
+        titleAlignment: "center",
+        padding: { top: 1, bottom: 1, left: 5, right: 5 },
+        margin: 1,
+        borderStyle: "round",
+        borderColor: "red",
+        textAlignment: "center"
+      }
+    ));
+    process$1.exit(1);
   }
+}
+function registerCommands$1(program2) {
+  program2.command("box").description("盒子设备安装（无需登录）").option("-e, --env <env>", "环境 (test/prod)").option("--app-key <appKey>", "App Key").option("--app-secret <appSecret>", "App Secret").option("--plugin-version <plugin-version>", "插件版本号（默认最新版）").option("--debug", "开启调试日志").action(createBoxCommand);
+}
+const ERROR_CODES = {
+  PHONE_REQUIRED: "PHONE_REQUIRED",
+  USER_PASS_REQUIRED: "USER_PASS_REQUIRED",
+  LOGIN_FAILED: "LOGIN_FAILED",
+  GET_BOUND_CONFIG_FAILED: "GET_BOUND_CONFIG_FAILED",
+  NODE_VERSION_LOW: "NODE_VERSION_LOW",
+  NODE_NOT_FOUND: "NODE_NOT_FOUND",
+  NPM_NOT_FOUND: "NPM_NOT_FOUND",
+  NPM_INSTALL_FAILED: "NPM_INSTALL_FAILED",
+  CONFIG_WRITE_FAILED: "CONFIG_WRITE_FAILED",
+  HTTP_ERROR: "HTTP_ERROR",
+  NETWORK_ERROR: "NETWORK_ERROR"
 };
-const openApisUrl = {
-  test: "http://172.168.80.30:32005/open-apis",
-  prod: "https://workbrain.cn/backend-api/open-apis"
-};
-const apiBaseUrl = {
-  test: "https://test-api.workbrain.cn/backend-api/",
-  prod: "https://workbrain.cn/backend-api/"
-};
-function getApiBaseUrl(env) {
-  return env === "test" ? apiBaseUrl.test : apiBaseUrl.prod;
+class AppError2 extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "AppError";
+  }
+}
+function createHttpClient() {
+  return axios.create({
+    timeout: 1e4,
+    headers: {
+      "Content-Type": "application/json"
+    }
+  });
 }
-function getWsUrl(env) {
-  return env === "test" ? openApisUrl.test : openApisUrl.prod;
+async function httpPost(url, data, config) {
+  const client = createHttpClient();
+  debugLog(`[HTTP POST] 请求地址: ${url}`);
+  debugLog(`[HTTP POST] 请求参数: ${JSON.stringify(data)}`);
+  debugLog(`[HTTP POST] 请求头: ${JSON.stringify(config?.headers || {})}`);
+  try {
+    const response = await client.post(url, data, config);
+    debugLog(`[HTTP POST] 响应状态: ${response.status}`);
+    debugLog(`[HTTP POST] 响应内容: ${JSON.stringify(response.data)}`);
+    return {
+      status: response.status,
+      data: response.data
+    };
+  } catch (error) {
+    const axiosError = error;
+    if (axiosError.response) {
+      const responseData = axiosError.response.data;
+      debugLog(`[HTTP POST] 响应状态: ${axiosError.response.status}`);
+      debugLog(`[HTTP POST] 响应状态文本: ${axiosError.response.statusText}`);
+      debugLog(`[HTTP POST] 响应数据: ${JSON.stringify(responseData)}`);
+      if (typeof responseData === "string") {
+        throw new AppError2(ERROR_CODES.HTTP_ERROR, `请求失败 (${axiosError.response.status}): ${responseData}`);
+      } else if (responseData && typeof responseData === "object" && "message" in responseData) {
+        throw new AppError2(ERROR_CODES.HTTP_ERROR, `请求失败 (${axiosError.response.status}): ${responseData.message}`);
+      } else {
+        throw new AppError2(ERROR_CODES.HTTP_ERROR, `请求失败 (${axiosError.response.status}): ${axiosError.response.statusText}`);
+      }
+    } else if (axiosError.request) {
+      debugLog(`[HTTP POST] 未收到响应`);
+      debugLog(`[HTTP POST] 错误信息: ${axiosError.message}`);
+      throw new AppError2(ERROR_CODES.NETWORK_ERROR, `网络错误: ${axiosError.message}`);
+    } else {
+      debugLog(`[HTTP POST] 请求配置错误`);
+      debugLog(`[HTTP POST] 错误信息: ${axiosError.message}`);
+      throw new AppError2(ERROR_CODES.HTTP_ERROR, `请求配置错误: ${axiosError.message}`);
+    }
+  }
 }
-function getOpenApisUrl(env) {
-  return env === "test" ? openApisUrl.test : openApisUrl.prod;
+async function login(phone, password, env) {
+  const config = getConfig(env);
+  const url = `${config.API.TUZAI_BASE_URL}/user/login/pass`;
+  debugLog("[登录] 开始登录...");
+  debugLog(`[登录] 请求地址: ${url}`);
+  debugLog(`[登录] 请求参数: phone=${phone}, password=***`);
+  try {
+    const response = await httpPost(url, {
+      phone,
+      userPass: password
+    });
+    const data = response.data;
+    debugLog(`[登录] 响应数据: ${JSON.stringify(data)}`);
+    if (data.code === 200 && data.data?.token) {
+      debugLog("[登录] 登录成功，获取到 token");
+      return data.data.token;
+    }
+    debugLog("[登录] 登录失败");
+    throw new AppError2(ERROR_CODES.LOGIN_FAILED, data.message || "登录失败");
+  } catch (error) {
+    if (error instanceof AppError2) {
+      throw error;
+    }
+    debugLog(`[登录] 发生错误: ${error.message}`);
+    throw new AppError2(ERROR_CODES.LOGIN_FAILED, error.message);
+  }
 }
-function getModelUrl(env) {
-  return env === "test" ? defaultConfig.modelUrl.test : defaultConfig.modelUrl.prod;
+async function fetchBoundConfig(token, phone, env) {
+  const config = getConfig(env);
+  const url = `${config.API.TUZAI_BASE_URL}/work-bot/local/bound/init`;
+  debugLog("[获取绑定配置] 开始获取绑定配置...");
+  debugLog(`[获取绑定配置] 请求地址: ${url}`);
+  debugLog(`[获取绑定配置] 请求参数: phone=${phone}, localCode=001`);
+  debugLog(`[获取绑定配置] 请求头: Authorization=${token.substring(0, 20)}...`);
+  try {
+    const response = await httpPost(url, {
+      phone,
+      localCode: "001"
+    }, {
+      headers: {
+        Authorization: token
+      }
+    });
+    const data = response.data;
+    debugLog(`[获取绑定配置] 响应数据: ${JSON.stringify(data)}`);
+    if (data.code === 200 && data.data) {
+      const boundConfig = {
+        appKey: data.data.app_key,
+        appSecret: data.data.app_secret,
+        userId: data.data.user_id,
+        agentId: data.data.agent_id || data.data.agents?.[0]?.id,
+        modelApiKey: data.data.model_api_key,
+        modelApiBaseUrl: data.data.model_api_base_url
+      };
+      debugLog("[获取绑定配置] 获取绑定配置成功");
+      debugLog(`[获取绑定配置] appKey: ${boundConfig.appKey}`);
+      debugLog(`[获取绑定配置] appSecret: ${boundConfig.appSecret ? "***" : "undefined"}`);
+      debugLog(`[获取绑定配置] userId: ${boundConfig.userId}`);
+      debugLog(`[获取绑定配置] agentId: ${boundConfig.agentId}`);
+      debugLog(`[获取绑定配置] modelApiKey: ${boundConfig.modelApiKey || "undefined"}`);
+      debugLog(`[获取绑定配置] modelApiBaseUrl: ${boundConfig.modelApiBaseUrl || "undefined"}`);
+      if (!boundConfig.appKey || !boundConfig.appSecret || !boundConfig.agentId) {
+        debugLog("[获取绑定配置] 缺少必要字段");
+        throw new AppError2(ERROR_CODES.GET_BOUND_CONFIG_FAILED, "获取绑定配置失败：缺少必要字段");
+      }
+      return boundConfig;
+    }
+    debugLog("[获取绑定配置] 获取绑定配置失败");
+    throw new AppError2(ERROR_CODES.GET_BOUND_CONFIG_FAILED, data.message || data.msg || "获取绑定配置失败");
+  } catch (error) {
+    if (error instanceof AppError2) {
+      throw error;
+    }
+    debugLog(`[获取绑定配置] 发生错误: ${error.message}`);
+    throw new AppError2(ERROR_CODES.GET_BOUND_CONFIG_FAILED, error.message);
+  }
 }
 var BI_RM = "0123456789abcdefghijklmnopqrstuvwxyz";
 function int2char(n) {
@@ -3975,1073 +4608,492 @@ var JSEncrypt = (
 );
 const PUBLIC_KEY = "MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDBSYtNb6neLrrwsuPBsIFjpZBrffdkA8bpp2S35o2TCdhfdxS0nc4pkv9cJLkUvFa+gdQ5nLifnK9B1XoVbIQwY212QAftTDbl77bcHu7GAbv2TZr9pelSeUm1SrtMK5HDr/LzxTutGr4DovVHiDgEn45GQ1X5U+zC0Jp4Awn6ZwIDAQAB";
 function rsaEncrypt(txt) {
-  try {
-    const encrypt = new JSEncrypt();
-    encrypt.setPublicKey(PUBLIC_KEY);
-    const encrypted = encrypt.encrypt(txt);
-    if (!encrypted) {
-      return null;
-    }
-    return encrypted;
-  } catch (error) {
-    console.error("RSA 加密失败:", error);
-    return null;
-  }
+  const encrypt = new JSEncrypt();
+  encrypt.setPublicKey(PUBLIC_KEY);
+  const result = encrypt.encrypt(txt);
+  return result || null;
 }
-const ERROR_CODES = {
-  // 环境检查错误 (1000-1999)
-  NODE_VERSION_LOW: 1001,
-  NODE_NOT_FOUND: 1002,
-  NPM_NOT_FOUND: 1003,
-  // 配置错误 (2000-2999)
-  PHONE_REQUIRED: 2001,
-  USER_PASS_REQUIRED: 2002,
-  MISSING_AGENT_ID: 2003,
-  MISSING_APP_KEY: 2004,
-  MISSING_APP_SECRET: 2005,
-  // 网络错误 (3000-3999)
-  LOGIN_FAILED: 3001,
-  GET_BOUND_CONFIG_FAILED: 3002,
-  FETCH_CONFIG_FAILED: 3003,
-  // 文件系统错误 (4000-4999)
-  CONFIG_WRITE_FAILED: 4001,
-  FILE_COPY_FAILED: 4002,
-  NPM_INSTALL_FAILED: 4003,
-  // 加密错误 (5000-5999)
-  PASSWORD_ENCRYPT_FAILED: 5001
-};
-class AppError extends Error {
-  code;
-  details;
-  constructor(code, message, details) {
-    super(message);
-    this.name = "AppError";
-    this.code = code;
-    this.details = details;
-  }
-  toJSON() {
-    return {
-      code: this.code,
-      message: this.message,
-      details: this.details
-    };
-  }
-  toString() {
-    return `[${this.code}] ${this.message}`;
-  }
-}
-function formatError(error) {
-  if (error instanceof AppError) {
-    return error.toString();
-  }
-  if (error instanceof Error) {
-    return error.message;
-  }
-  return String(error);
-}
-function createHttpClient(baseURL) {
-  return axios.create({
-    baseURL,
-    timeout: 3e4,
-    headers: {
-      "Content-Type": "application/json"
-    }
-  });
-}
-function printRequestLog(log) {
-  console.log();
-  console.log(chalk.cyan("=".repeat(50)));
-  console.log(chalk.bold(`HTTP ${log.method} 请求`));
-  console.log(chalk.cyan("=".repeat(50)));
-  console.log(chalk.blue("[请求地址]"), log.url);
-  if (log.headers) {
-    const headersStr = JSON.stringify(log.headers, null, 2);
-    console.log(chalk.blue("[请求头]"), headersStr);
-  }
-  if (log.data) {
-    const dataStr = JSON.stringify(log.data, null, 2);
-    console.log(chalk.blue("[请求参数]"), dataStr);
-  }
-  if (log.duration) {
-    console.log(chalk.yellow("[耗时]"), `${log.duration}ms`);
-  }
-  if (log.error) {
-    console.log(chalk.red("[错误]"), log.error);
-  }
-  console.log(chalk.cyan("=".repeat(50)));
-  console.log();
-}
-function printResponseLog(log) {
-  if (log.response) {
-    console.log();
-    console.log(chalk.green("=".repeat(50)));
-    console.log(chalk.bold(`HTTP ${log.method} 响应`));
-    console.log(chalk.green("=".repeat(50)));
-    console.log(chalk.green("[状态码]"), log.response.status);
-    const responseStr = JSON.stringify(log.response.data, null, 2);
-    console.log(chalk.green("[响应数据]"), responseStr);
-    console.log(chalk.green("=".repeat(50)));
-    console.log();
-  }
+function getHomeDir() {
+  return process$1.env.HOME || process$1.env.USERPROFILE || "";
 }
-async function httpGet(url, config) {
-  const startTime = Date.now();
-  printRequestLog({
-    method: "GET",
-    url,
-    headers: config?.headers
-  });
-  try {
-    const client = createHttpClient();
-    const response = await client.get(url, config);
-    const duration = Date.now() - startTime;
-    const result = {
-      status: response.status,
-      data: response.data
-    };
-    printResponseLog({
-      method: "GET",
-      url,
-      headers: config?.headers,
-      response: result,
-      duration
-    });
-    return result;
-  } catch (error) {
-    const duration = Date.now() - startTime;
-    const errorMessage = error instanceof Error ? error.message : String(error);
-    printRequestLog({
-      method: "GET",
-      url,
-      headers: config?.headers,
-      error: errorMessage,
-      duration
+const PLUGIN_PACKAGE_NAME = "@workclaw/openclaw-workclaw";
+function execAsync(command, options) {
+  return new Promise((resolve2, reject) => {
+    exec(command, { cwd: options.cwd, timeout: options.timeout }, (error, stdout, stderr) => {
+      if (error) {
+        reject(new Error(stderr || error.message));
+      } else {
+        resolve2(stdout);
+      }
     });
-    throw error;
-  }
-}
-async function httpPost(url, data, config) {
-  const startTime = Date.now();
-  printRequestLog({
-    method: "POST",
-    url,
-    headers: config?.headers,
-    data
   });
-  try {
-    const client = createHttpClient();
-    const response = await client.post(url, data, config);
-    const duration = Date.now() - startTime;
-    const result = {
-      status: response.status,
-      data: response.data
-    };
-    printResponseLog({
-      method: "POST",
-      url,
-      headers: config?.headers,
-      data,
-      response: result,
-      duration
-    });
-    return result;
-  } catch (error) {
-    const duration = Date.now() - startTime;
-    const errorMessage = error instanceof Error ? error.message : String(error);
-    printRequestLog({
-      method: "POST",
-      url,
-      headers: config?.headers,
-      data,
-      error: errorMessage,
-      duration
-    });
-    throw error;
-  }
-}
-function getPathInfo(_scenario) {
-  const homeDir = os.homedir();
-  const configDir = path.join(homeDir, ".openclaw");
-  return {
-    configDir,
-    configFile: path.join(configDir, "openclaw.json"),
-    pluginDir: path.join(configDir, "plugins")
-  };
 }
-function detectOS() {
-  const platform = os.platform();
-  switch (platform) {
-    case "win32":
-      return "windows-local";
-    case "darwin":
-      return "mac-local";
-    case "linux":
-      return "linux-local";
-    default:
-      return "linux-local";
-  }
-}
-async function ensureDir(dirPath) {
-  await fs.mkdir(dirPath, { recursive: true });
-}
-class BaseInstaller {
-  config;
-  logger;
-  constructor(config, logger2) {
-    this.config = config;
-    this.logger = logger2;
-  }
-  /**
-   * 获取 API 基础地址
-   */
-  getApiBaseUrl() {
-    if (this.config.baseUrl) {
-      return this.config.baseUrl;
-    }
-    const defaultUrls = {
-      test: "https://test-api.workbrain.cn/backend-api/",
-      prod: "https://workbrain.cn/backend-api/"
-    };
-    return defaultUrls[this.config.env];
-  }
-  /**
-   * 获取 WebSocket 地址
-   */
-  getWsUrl() {
-    if (this.config.wsUrl) {
-      return this.config.wsUrl;
-    }
-    const defaultUrls = {
-      test: "wss://test-api.workbrain.cn/backend-api/open-apis/connect/",
-      prod: "wss://workbrain.cn/backend-api/open-apis/connect/"
-    };
-    return defaultUrls[this.config.env];
-  }
-}
-class BoxInstaller extends BaseInstaller {
-  scenario;
-  constructor(config) {
-    super(config, logger);
-    this.scenario = config.scenario;
-  }
-  /**
-   * 验证配置
-   */
-  validateConfig() {
-    if (!this.config.appKey || !this.config.appSecret) {
-      logger.error("缺少必填参数: appKey 和 appSecret");
-      return false;
-    }
-    return true;
-  }
-  /**
-   * 获取配置路径
-   */
-  getConfigPath() {
-    const paths = getPathInfo(this.scenario);
-    return paths.configFile;
-  }
-  /**
-   * 获取场景类型
-   */
-  getScenario() {
-    return this.scenario;
-  }
-  /**
-   * 执行安装
-   */
-  async install() {
-    const spinner = logger.start("开始安装 (Box 环境)...");
-    try {
-      if (!this.validateConfig()) {
-        spinner.fail("配置验证失败");
-        return {
-          success: false,
-          error: "配置验证失败"
-        };
-      }
-      spinner.text = "获取 Access Token...";
-      const token = await this.getAccessToken();
-      if (!token) {
-        spinner.fail("获取 Access Token 失败");
-        return {
-          success: false,
-          error: "获取 Access Token 失败"
-        };
-      }
-      spinner.text = "获取 Agent 配置...";
-      const agentConfig = await this.getAgentConfig(token);
-      if (!agentConfig) {
-        spinner.fail("获取 Agent 配置失败");
-        return {
-          success: false,
-          error: "获取 Agent 配置失败"
-        };
-      }
-      spinner.text = "创建配置目录...";
-      const paths = getPathInfo(this.scenario);
-      await ensureDir(paths.configDir);
-      spinner.text = "写入配置文件...";
-      await this.writeConfigFile(token, agentConfig);
-      spinner.succeed("安装成功 (Box 环境)!");
-      logger.success(`配置文件已写入: ${this.getConfigPath()}`);
-      logger.info(`环境: ${this.config.env === "test" ? "测试环境" : "正式环境"}`);
-      return {
-        success: true,
-        message: "安装成功 (Box 环境)"
-      };
-    } catch (error) {
-      spinner.fail("安装失败");
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      logger.error(`安装失败: ${errorMessage}`);
-      return {
-        success: false,
-        error: errorMessage
-      };
-    }
-  }
-  /**
-   * 获取 Access Token
-   */
-  async getAccessToken() {
-    try {
-      const client = createHttpClient(this.getApiBaseUrl());
-      const response = await client.post("/v1/auth/token", {
-        appKey: this.config.appKey,
-        appSecret: this.config.appSecret
-      });
-      const data = response.data;
-      return data.accessToken || null;
-    } catch {
-      return null;
-    }
-  }
-  /**
-   * 获取 Agent 配置
-   */
-  async getAgentConfig(token) {
-    try {
-      const client = createHttpClient(this.getApiBaseUrl());
-      const response = await client.get("/v1/agent/config", {
-        headers: {
-          Authorization: `Bearer ${token}`
-        }
-      });
-      return response.data;
-    } catch {
-      return null;
+function deepMerge(target, source) {
+  const result = { ...target };
+  for (const key in source) {
+    const sourceValue = source[key];
+    const targetValue = target[key];
+    if (sourceValue !== void 0 && sourceValue !== null && typeof sourceValue === "object" && !Array.isArray(sourceValue) && typeof targetValue === "object" && targetValue !== null && !Array.isArray(targetValue)) {
+      result[key] = deepMerge(targetValue, sourceValue);
+    } else if (sourceValue !== void 0) {
+      result[key] = sourceValue;
     }
   }
-  /**
-   * 写入配置文件
-   */
-  async writeConfigFile(token, agentConfig) {
-    const configPath = this.getConfigPath();
-    let existingConfig = await readConfig(configPath);
-    if (!existingConfig || typeof existingConfig !== "object") {
-      existingConfig = {};
-    }
-    const safeConfig = existingConfig;
-    const existingChannels = safeConfig.channels;
-    const newConfig = {
-      ...safeConfig,
-      channels: {
-        ...existingChannels || {},
-        "openclaw-workclaw": {
-          userId: agentConfig.userId,
-          apiKey: token,
-          baseUrl: this.getApiBaseUrl(),
-          wsUrl: this.getWsUrl(),
-          accounts: {
-            default: {
-              agentId: agentConfig.agentId
-            }
-          }
-        }
-      }
-    };
-    await writeConfig(configPath, newConfig);
-  }
+  return result;
 }
-const PLUGIN_PACKAGE_NAME = "@workclaw/openclaw-workclaw";
-class LocalInstaller extends BaseInstaller {
+class LocalInstaller {
   constructor(config) {
-    super(config, logger);
+    this.config = config;
+    this.spinner = ora({ color: "cyan" }).start();
   }
+  spinner;
+  prefixText = "";
   validateConfig() {
+    debugLog("[验证配置] 检查手机号码和密码...");
     if (!this.config.phone) {
-      throw new AppError(ERROR_CODES.PHONE_REQUIRED, "手机号码不能为空，请使用 --phone 参数");
+      throw new AppError2(ERROR_CODES.PHONE_REQUIRED, "手机号码不能为空，请使用 --phone 参数");
     }
     if (!this.config.userPass) {
-      throw new AppError(ERROR_CODES.USER_PASS_REQUIRED, "用户密码不能为空，请使用 --user-pass 参数");
+      throw new AppError2(ERROR_CODES.USER_PASS_REQUIRED, "用户密码不能为空，请使用 --user-pass 参数");
     }
-  }
-  getConfigPath() {
-    return path.join(os.homedir(), ".openclaw", "openclaw.json");
-  }
-  getScenario() {
-    return this.config.scenario;
-  }
-  getInstallPath() {
-    return path.join(os.homedir(), ".openclaw", "plugins", "openclaw-workclaw");
-  }
-  getExtensionsPath() {
-    return path.join(os.homedir(), ".openclaw", "extensions");
-  }
-  getWorkspacePath() {
-    return path.join(os.homedir(), ".openclaw", "workspace");
+    debugLog("[验证配置] 配置验证通过");
   }
   async install() {
     try {
-      logger.info("开始安装 WorkClaw 插件（NPM 安装模式）");
-      logger.info("=".repeat(40));
+      debugLog("[安装开始]");
       this.validateConfig();
-      await this.cleanOldFiles();
-      this.checkEnv();
-      await this.downloadFromNpm();
-      await this.fetchConfigAndUpdate();
-      logger.success("安装完成");
-      return { success: true, message: "插件安装成功" };
+      const env = this.config.env || "test";
+      const config = getConfig(env);
+      const homeDir = getHomeDir();
+      const paths = {
+        home: path.join(homeDir, config.DIRS.OPENCLAW),
+        extensions: path.join(homeDir, config.DIRS.OPENCLAW, config.DIRS.EXTENSIONS),
+        target: path.join(homeDir, config.DIRS.OPENCLAW, config.DIRS.EXTENSIONS, config.PLUGIN_NAME),
+        config: path.join(homeDir, config.DIRS.OPENCLAW, config.DIRS.CONFIG_FILE),
+        workspace: path.join(homeDir, config.DIRS.OPENCLAW, config.DIRS.WORKSPACE),
+        temp: path.join(homeDir, config.DIRS.OPENCLAW, config.DIRS.TEMP)
+      };
+      debugLog(`[路径配置] home=${paths.home}`);
+      debugLog(`[路径配置] extensions=${paths.extensions}`);
+      debugLog(`[路径配置] target=${paths.target}`);
+      debugLog(`[路径配置] config=${paths.config}`);
+      debugLog(`[路径配置] workspace=${paths.workspace}`);
+      const token = await this.doLogin(env);
+      const boundConfig = await this.doFetchBoundConfig(env, token);
+      await this.doCleanOldFiles(paths.target);
+      await this.doDownloadFromNpm(paths);
+      await this.doUpdateConfig(paths, boundConfig, env);
+      this.spinner.stop();
     } catch (error) {
-      const errorMessage = formatError(error);
-      if (error instanceof AppError) {
-        logger.error(`安装失败 [${error.code}]: ${errorMessage}`);
-      } else {
-        logger.error(`安装失败: ${errorMessage}`);
-      }
-      return { success: false, error: errorMessage };
+      this.spinner.stop();
+      throw error;
     }
   }
-  async cleanOldFiles() {
-    const spinner = logger.start("步骤 1: 清理旧版本");
-    const targetDir = this.getInstallPath();
-    try {
-      await fs.access(targetDir);
-      spinner.text = "发现旧版本，正在清理...";
-      await fs.rm(targetDir, { recursive: true, force: true });
-      spinner.succeed("旧版本清理完成");
-    } catch {
-      spinner.succeed("未发现旧版本");
-    }
+  getPrefixText() {
+    return this.prefixText;
   }
-  checkEnv() {
-    const spinner = logger.start("步骤 2: 检查环境");
-    try {
-      const nodeVersion = execSync("node --version", { stdio: "pipe" }).toString().trim();
-      const majorVersion = Number.parseInt(nodeVersion.replace("v", "").split(".")[0]);
-      if (majorVersion < 18) {
-        spinner.fail(`Node.js 版本过低（当前: ${nodeVersion}，需要: v18.0.0 或更高版本）`);
-        throw new AppError(ERROR_CODES.NODE_VERSION_LOW, `Node.js 版本过低（当前: ${nodeVersion}，需要: v18.0.0 或更高版本）`);
-      }
-      spinner.text = `Node.js 已就绪（${nodeVersion}）`;
-    } catch (error) {
-      if (error instanceof AppError) {
-        throw error;
-      }
-      spinner.fail("未检测到 Node.js，请检查环境配置");
-      throw new AppError(ERROR_CODES.NODE_NOT_FOUND, "未检测到 Node.js，请检查环境配置");
-    }
-    try {
-      execSync("npm --version", { stdio: "ignore" });
-      spinner.succeed("环境检查完成");
-    } catch {
-      spinner.fail("未检测到 npm，请检查环境配置");
-      throw new AppError(ERROR_CODES.NPM_NOT_FOUND, "未检测到 npm，请检查环境配置");
+  async doLogin(env) {
+    this.spinner.prefixText = this.prefixText;
+    this.spinner.text = chalk.cyan("正在验证账号...");
+    debugLog(`[用户登录] 手机号: ${this.config.phone}`);
+    debugLog("[用户登录] RSA 加密密码...");
+    const encryptedPassword = rsaEncrypt(this.config.userPass);
+    if (!encryptedPassword) {
+      throw new AppError2(ERROR_CODES.LOGIN_FAILED, "密码加密失败");
     }
+    debugLog("[用户登录] 密码加密成功");
+    debugLog("[用户登录] 调用登录接口...");
+    const token = await login(this.config.phone, encryptedPassword, env);
+    this.prefixText += chalk.green(`  ✓ 账号验证成功
+`);
+    debugLog("[用户登录] 登录成功");
+    return token;
   }
-  async downloadFromNpm() {
-    const spinner = logger.start("步骤 3: 从 NPM 下载插件");
-    const extensionsDir = this.getExtensionsPath();
-    spinner.text = `插件安装目录: ${extensionsDir}`;
-    try {
-      await fs.mkdir(extensionsDir, { recursive: true });
-    } catch {
-    }
-    spinner.text = `正在从 NPM 下载插件 ${PLUGIN_PACKAGE_NAME}...`;
+  async doFetchBoundConfig(env, token) {
+    this.spinner.prefixText = this.prefixText;
+    this.spinner.text = chalk.cyan("正在获取绑定信息...");
+    debugLog("[获取配置] 调用绑定配置接口...");
+    const boundConfig = await fetchBoundConfig(token, this.config.phone, env);
+    debugLog(`[获取配置] agentId=${boundConfig.agentId}, appKey=${boundConfig.appKey?.slice(0, 8)}...`);
+    this.prefixText += chalk.green(`  ✓ 绑定信息获取成功
+`);
+    debugLog("[获取配置] 获取成功");
+    return boundConfig;
+  }
+  async doCleanOldFiles(targetPath) {
+    this.spinner.prefixText = this.prefixText;
+    this.spinner.text = chalk.cyan("正在检查已安装版本...");
+    debugLog(`[清理旧版本] 检查目录: ${targetPath}`);
     try {
-      execSync(`npm install ${PLUGIN_PACKAGE_NAME}`, {
-        cwd: extensionsDir,
-        stdio: "pipe"
-      });
-      spinner.succeed("插件下载完成");
+      await fs.access(targetPath);
+      this.spinner.text = chalk.cyan("正在清理旧文件...");
+      debugLog("[清理旧版本] 发现旧版本，开始清理...");
+      await fs.rm(targetPath, { recursive: true, force: true });
+      this.prefixText += chalk.green(`  ✓ 旧版本清理完成
+`);
+      debugLog("[清理旧版本] 清理完成");
     } catch {
-      spinner.fail("插件下载失败");
-      throw new AppError(ERROR_CODES.NPM_INSTALL_FAILED, `插件 ${PLUGIN_PACKAGE_NAME} 下载失败`);
-    }
-  }
-  async fetchConfigAndUpdate() {
-    const spinner = logger.start("步骤 5: 获取配置并更新");
-    spinner.text = "正在登录...";
-    const token = await this.login();
-    spinner.text = "登录成功";
-    spinner.text = "正在获取绑定配置...";
-    const boundConfig = await this.fetchBoundConfig(token);
-    if (!boundConfig || !boundConfig.agentId) {
-      spinner.fail("获取绑定配置失败：缺少 agentId");
-      throw new Error("获取绑定配置失败：缺少 agentId");
-    }
-    spinner.text = "正在更新配置文件...";
-    await this.updateConfig(boundConfig, token);
-    spinner.succeed("配置文件更新完成");
-  }
-  async login() {
-    const apiUrl = `${this.getApiBaseUrl()}/user/login/pass`;
-    logger.info(`登录接口: ${apiUrl}`);
-    const encryptedPassword = rsaEncrypt(this.config.userPass);
-    if (!encryptedPassword) {
-      throw new Error("密码加密失败");
-    }
-    const response = await httpPost(apiUrl, {
-      phone: this.config.phone,
-      userPass: encryptedPassword
-    });
-    const res = response.data;
-    if (res.code === 200 && res.data && res.data.token) {
-      return res.data.token;
+      this.prefixText += chalk.green(`  ✓ 无旧版本需要清理
+`);
+      debugLog("[清理旧版本] 未发现旧版本");
     }
-    throw new Error(res.message || "登录失败");
   }
-  async fetchBoundConfig(token) {
-    const apiUrl = `${this.getApiBaseUrl()}/work-bot/local/bound/init`;
-    logger.info(`绑定配置接口: ${apiUrl}`);
-    const response = await httpGet(apiUrl, {
-      headers: {
-        Authorization: token
-      }
-    });
-    const res = response.data;
-    if (res.code === 200 && res.data) {
-      return {
-        appKey: res.data.app_key,
-        appSecret: res.data.app_secret,
-        userId: res.data.user_id,
-        agentId: res.data.agent_id,
-        modelApiKey: res.data.model_api_key,
-        modelApiBaseUrl: res.data.model_api_base_url
-      };
+  async doDownloadFromNpm(paths) {
+    this.spinner.prefixText = this.prefixText;
+    this.spinner.text = chalk.cyan("正在安装插件...");
+    debugLog("[安装插件] 创建扩展目录...");
+    await fs.mkdir(paths.extensions, { recursive: true });
+    debugLog(`[安装插件] 扩展目录: ${paths.extensions}`);
+    debugLog("[安装插件] 执行 openclaw plugins install 命令");
+    try {
+      await execAsync(
+        `openclaw plugins install ${PLUGIN_PACKAGE_NAME} --dangerously-force-unsafe-install`,
+        { timeout: 12e4 }
+      );
+      debugLog("[安装插件] openclaw plugins install 执行成功");
+      this.prefixText += chalk.green(`  ✓ 插件安装完成
+`);
+    } catch (error) {
+      const errorMsg = error.message || "未知错误";
+      debugLog(`[安装插件] 安装失败: ${errorMsg}`);
+      throw new AppError2(ERROR_CODES.NPM_INSTALL_FAILED, `插件安装失败: ${errorMsg}`);
     }
-    throw new Error(res.message || "获取绑定配置失败");
   }
-  async updateConfig(boundConfig, token) {
-    const configPath = this.getConfigPath();
-    const workspacePath = this.getWorkspacePath();
-    logger.info(`配置文件路径: ${configPath}`);
-    logger.info(`工作区路径: ${workspacePath}`);
-    logger.info(`Agent ID: ${boundConfig.agentId}`);
+  async doUpdateConfig(paths, boundConfig, env) {
+    this.spinner.prefixText = this.prefixText;
+    this.spinner.text = chalk.cyan("正在生成配置...");
+    debugLog("[更新配置] 创建目录...");
+    await fs.mkdir(paths.home, { recursive: true });
+    await fs.mkdir(paths.workspace, { recursive: true });
+    debugLog("[更新配置] 目录创建完成");
+    debugLog("[更新配置] 读取原有配置...");
     let originalConfig = {};
     try {
-      const content = await fs.readFile(configPath, "utf-8");
+      const content = await fs.readFile(paths.config, "utf-8");
       originalConfig = JSON.parse(content);
-      logger.info("已读取现有配置文件");
+      debugLog("[更新配置] 读取原有配置成功");
     } catch {
-      logger.info("创建新配置文件");
+      debugLog("[更新配置] 无原有配置");
     }
-    const dynamicConfig = {
-      // 诊断配置
+    const config = getConfig(env);
+    const newConfig = {
+      // diagnostics: 诊断配置
       diagnostics: {
-        // 启用诊断功能
         enabled: true,
-        // 诊断标志列表
         flags: ["*"]
       },
-      // 浏览器配置
+      // browser: 浏览器配置
       browser: {
-        // 禁用内置浏览器
         enabled: false
       },
-      // 模型配置
+      // models: 模型配置
       models: {
-        // 配置合并模式：merge 会将新配置与现有配置合并
         mode: "merge",
-        // 模型提供商配置
         providers: {
-          // SiliconFlow MiniMax 提供商
           "siliconflow-minimax": {
-            // API 基础地址，从绑定配置获取或使用默认值
-            baseUrl: boundConfig.modelApiBaseUrl || this.getDefaultModelUrl(),
-            // API 密钥，用于认证
+            baseUrl: boundConfig.modelApiBaseUrl || config.MODEL_BASE_URL,
             apiKey: boundConfig.modelApiKey,
-            // API 类型，这里使用 OpenAI 兼容格式
             api: "openai-completions",
-            // 是否使用 Authorization header 进行认证
             authHeader: true,
-            // 模型列表配置
-            models: [
-              {
-                // 模型标识符
-                id: "Pro/MiniMaxAI/MiniMax-M2.5",
-                // 模型显示名称
-                name: "MiniMax-M2.5",
-                // 是否支持推理能力
-                reasoning: false,
-                // 支持的输入类型
-                input: [
-                  "text"
-                ],
-                // 费用配置（单位：分）
-                cost: {
-                  // 输入费用
-                  input: 0,
-                  // 输出费用
-                  output: 0,
-                  // 缓存读取费用
-                  cacheRead: 0,
-                  // 缓存写入费用
-                  cacheWrite: 0
-                },
-                // 上下文窗口大小（token 数）
-                contextWindow: 2e5,
-                // 最大输出 token 数
-                maxTokens: 65536
-              }
-            ]
+            models: [{
+              id: "Pro/MiniMaxAI/MiniMax-M2.5",
+              name: "MiniMax-M2.5",
+              reasoning: false,
+              input: ["text"],
+              cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+              contextWindow: 2e5,
+              maxTokens: 65536
+            }]
           }
         }
       },
-      // Agent 配置
+      // agents: 代理配置
       agents: {
-        // 默认 Agent 设置
         defaults: {
-          // 默认模型配置
-          model: {
-            // 主要使用的模型
-            primary: "siliconflow-minimax/Pro/MiniMaxAI/MiniMax-M2.5"
-          },
-          // 模型映射表
+          model: { primary: "siliconflow-minimax/Pro/MiniMaxAI/MiniMax-M2.5" },
           models: {
-            // 模型的别名配置
             "siliconflow-minimax/Pro/MiniMaxAI/MiniMax-M2.5": {
-              // 模型别名
               alias: "Pro/MiniMaxAI/MiniMax-M2.5"
             }
           },
-          // 默认工作区路径
-          workspace: workspacePath,
-          // 压缩配置
-          compaction: {
-            // 压缩模式：safeguard 模式
-            mode: "safeguard"
-          },
-          // 默认详细模式：full 表示完整输出
+          workspace: paths.workspace,
+          compaction: { mode: "safeguard" },
           verboseDefault: "full",
-          // 最大并发数
           maxConcurrent: 4,
-          // 子 Agent 配置
-          subagents: {
-            // 子 Agent 最大并发数
-            maxConcurrent: 8
-          }
+          subagents: { maxConcurrent: 8 }
         },
-        // Agent 列表
-        list: [
-          {
-            // Agent ID
-            id: "main",
-            // Agent 工作区路径
-            workspace: workspacePath
-          }
-        ]
+        list: [{ id: "main", workspace: paths.workspace }]
       },
-      // 工具权限配置
+      // tools: 工具配置
       tools: {
-        // 禁止使用的工具类型列表
-        deny: [
-          "image",
-          "web_search",
-          "web_fetch"
-        ],
-        // 媒体工具配置
-        media: {
-          // 图片处理工具
-          image: { enabled: false }
-        },
-        // 网页工具配置
-        web: {
-          // 网络搜索
-          search: { enabled: false },
-          // 网页抓取
-          fetch: { enabled: false }
-        },
-        // 提权工具配置
-        elevated: {
-          // 启用/禁用提权功能
-          enabled: true,
-          // 允许使用提权的来源
-          allowFrom: {
-            // webchat来源允许使用提权
-            webchat: ["*"]
-          }
-        },
-        // 执行工具配置
-        exec: {
-          // 安全模式级别
-          security: "full"
-        }
+        deny: ["image", "web_search", "web_fetch"],
+        media: { image: { enabled: false } },
+        web: { search: { enabled: false }, fetch: { enabled: false } },
+        elevated: { enabled: true, allowFrom: { webchat: ["*"] } },
+        exec: { security: "full" }
       },
-      // 绑定配置
-      bindings: [
-        {
-          // 绑定的智能体ID
-          agentId: "main",
-          match: {
-            // 匹配通道名称
-            channel: "openclaw-workclaw",
-            // 匹配账号ID
-            accountId: "default"
-          }
-        }
-      ],
-      // 消息配置
+      // bindings: 绑定配置
+      bindings: [{
+        agentId: "main",
+        match: { channel: "openclaw-workclaw", accountId: "default" }
+      }],
+      // messages: 消息配置
       messages: {
-        // 消息确认反应的作用域
         ackReactionScope: "group-mentions"
       },
-      // 命令配置
+      // commands: 命令配置
       commands: {
-        // 原生命令处理模式
         native: "auto",
-        // 技能命令处理模式
         nativeSkills: "auto",
-        // 允许使用restart命令
         restart: true,
-        // 所有者信息显示方式
         ownerDisplay: "raw"
       },
-      // 会话配置
+      // session: 会话配置
       session: {
-        // 会话隔离策略
         dmScope: "per-account-channel-peer"
       },
-      // 钩子配置
+      // hooks: 钩子配置
       hooks: {
         internal: {
-          // 启用/禁用内部钩子
           enabled: true,
           entries: {
-            // 启动时显示Markdown
             "boot-md": { enabled: true },
-            // 加载额外引导文件
             "bootstrap-extra-files": { enabled: true },
-            // 记录命令执行日志
             "command-logger": { enabled: true },
-            // 启用会话记忆
             "session-memory": { enabled: true }
           }
         }
       },
-      // 渠道配置
+      // channels: 通道配置
       channels: {
-        // WorkClaw 插件渠道
         "openclaw-workclaw": {
-          // 是否启用此渠道
           enabled: true,
-          // 连接模式：使用 WebSocket 连接
           connectionMode: "websocket",
-          // WebSocket 连接策略：每个 appKey 一个连接
-          wsConnectionStrategy: "per-appKey",
-          // 应用密钥，用于身份验证
           appKey: boundConfig.appKey,
-          // 应用密钥，用于身份验证
           appSecret: boundConfig.appSecret,
-          // API 基础地址
-          baseUrl: this.config.baseUrl || this.getDefaultBaseUrl(),
-          // WebSocket 连接地址
-          websocketUrl: this.config.wsUrl || this.getDefaultWsUrl(),
-          // 是否允许不安全的 TLS 连接
+          baseUrl: this.config.baseUrl || config.DEFAULT_BASE_URL,
+          websocketUrl: this.config.wsUrl || config.DEFAULT_WS_URL,
           allowInsecureTls: true,
-          // 是否允许原始 JSON 载荷
           allowRawJsonPayload: true,
-          // 账号配置
+          userId: boundConfig.userId,
+          dmPolicy: "open",
+          allowFrom: ["*"],
           accounts: {
-            // 默认账号
-            default: {
-              // 是否启用默认账号
-              enabled: true,
-              // 代理 ID
-              agentId: boundConfig.agentId
-            }
+            default: { enabled: true, agentId: boundConfig.agentId }
           }
         }
       },
-      // Gateway 节点配置
+      // gateway: 网关配置
       gateway: {
-        // 运行模式
         mode: "local",
-        // 监听端口
         port: 18789,
-        // 绑定地址（仅监听本地）
-        bind: "loopback",
-        // 认证配置（为空字符串会使用原始配置中的值）
+        bind: "lan",
         auth: {
-          // 认证模式
-          mode: "token",
-          // 认证令牌（为空会使用原始配置中的值）
-          token: ""
-        },
-        // Tailscale 配置
-        tailscale: {
-          // Tailscale 模式
-          mode: "off",
-          // 退出时重置
-          resetOnExit: false
+          mode: "token"
         },
+        tailscale: { mode: "off", resetOnExit: false },
         nodes: {
-          // 禁用的节点命令（出于安全考虑）
           denyCommands: [
             "camera.snap",
             "camera.clip",
             "screen.record",
             "contacts.add",
             "calendar.add",
-            "reminders.add",
-            "sms.send",
-            "sms.search"
+            "reminders.add"
           ]
         },
-        // 控制面板配置
         controlUi: {
-          // 允许非安全认证
           allowInsecureAuth: true,
-          // 禁用设备认证
           dangerouslyDisableDeviceAuth: true,
-          // 允许 Host header 源回退
           dangerouslyAllowHostHeaderOriginFallback: true,
-          // 允许的来源（本地开发）
-          allowedOrigins: [
-            "http://localhost:18789",
-            "http://127.0.0.1:18789"
-          ]
+          allowedOrigins: ["http://localhost:18789", "http://127.0.0.1:18789"]
         }
       },
-      // 技能配置
+      // skills: 技能配置
       skills: {
-        load: {
-          // 监听技能文件变化
-          watch: true
-        }
+        load: { watch: true }
       },
-      // 日志配置
+      // logging: 日志配置
       logging: {
-        // 日志级别
         level: "info",
-        // 控制台日志级别
         consoleLevel: "info",
-        // 控制台样式
         consoleStyle: "pretty",
-        // 敏感信息脱敏
         redactSensitive: "off",
-        // 日志文件路径（空表示使用系统默认）
         file: "",
-        // 脱敏模式
         redactPatterns: ["sk-.*"]
       },
-      // 插件配置
+      // plugins: 插件配置
       plugins: {
-        // 允许的插件列表
-        allow: ["openclaw-workclaw"],
-        // 插件安装配置
+        allow: [config.PLUGIN_NAME],
         installs: {
-          // WorkClaw 插件安装信息
-          "openclaw-workclaw": {
-            // 插件来源类型：npm 表示从 NPM 安装
+          [config.PLUGIN_NAME]: {
             source: "npm",
-            // NPM 包名
-            npm: PLUGIN_PACKAGE_NAME,
-            // 插件安装路径
-            installPath: this.getExtensionsPath()
+            spec: PLUGIN_PACKAGE_NAME,
+            installPath: paths.target
           }
         },
-        // 插件入口配置
         entries: {
-          // WorkClaw 插件入口
-          "openclaw-workclaw": {
-            // 是否启用此插件
-            enabled: true
-          }
+          [config.PLUGIN_NAME]: { enabled: true }
         }
-      },
-      // 魔导配置（为空字符串会使用原始配置中的值）
-      wizard: {
-        // 上次运行时间（为空会保留原始配置值）
-        lastRunAt: "",
-        // 上次运行版本（为空会保留原始配置值）
-        lastRunVersion: "",
-        // 上次运行命令（为空会保留原始配置值）
-        lastRunCommand: "",
-        // 上次运行模式（为空会保留原始配置值）
-        lastRunMode: ""
-      },
-      // 元数据配置（为空字符串会使用原始配置中的值）
-      meta: {
-        // 上次修改版本（为空会保留原始配置值）
-        lastTouchedVersion: "",
-        // 上次修改时间（为空会保留原始配置值）
-        lastTouchedAt: ""
       }
     };
-    const finalConfig = this.mergeConfig(originalConfig, dynamicConfig);
-    await fs.writeFile(configPath, JSON.stringify(finalConfig, null, 2), "utf-8");
-    await this.sendCallback(boundConfig.agentId, token);
-  }
-  async sendCallback(agentId, token) {
-    try {
-      const callbackUrl = `${this.getOpenApisUrl()}/instance/agent-created/status`;
-      await httpPost(callbackUrl, {
-        agentId,
-        success: true
-      }, {
-        headers: {
-          Authorization: token
-        }
-      });
-      logger.success("智小途插件初始化回调成功");
-    } catch {
-      logger.warn("回调通知失败，请手动确认");
-    }
-  }
-  mergeConfig(original, dynamic) {
-    const result = { ...original };
-    for (const key in dynamic) {
-      const dynamicValue = dynamic[key];
-      const originalValue = result[key];
-      if (dynamicValue !== null && typeof dynamicValue === "object") {
-        result[key] = {
-          ...originalValue || {},
-          ...dynamicValue
-        };
-      } else if (dynamicValue === "" || dynamicValue === null || dynamicValue === void 0) ;
-      else {
-        result[key] = dynamicValue;
-      }
-    }
-    return result;
-  }
-  getApiBaseUrl() {
-    if (this.config.baseUrl) {
-      return `${this.config.baseUrl}/tuzai`;
-    }
-    return `${getApiBaseUrl(this.config.env)}/tuzai`;
-  }
-  getOpenApisUrl() {
-    if (this.config.baseUrl) {
-      return `${this.config.baseUrl}/open-apis`;
-    }
-    return getOpenApisUrl(this.config.env);
-  }
-  getDefaultBaseUrl() {
-    return this.config.baseUrl || getApiBaseUrl(this.config.env);
-  }
-  getDefaultWsUrl() {
-    if (this.config.wsUrl) {
-      return this.config.wsUrl;
-    }
-    return getWsUrl(this.config.env);
-  }
-  getDefaultModelUrl() {
-    return getModelUrl(this.config.env);
+    const finalConfig = deepMerge(originalConfig, newConfig);
+    this.spinner.prefixText = this.prefixText;
+    this.spinner.text = chalk.cyan("正在写入配置...");
+    debugLog("[更新配置] 写入配置文件...");
+    await fs.writeFile(paths.config, JSON.stringify(finalConfig, null, 2), "utf-8");
+    this.prefixText += chalk.green(`  ✓ 配置更新完成
+`);
+    debugLog(`[更新配置] 配置文件写入成功: ${paths.config}`);
   }
 }
-class InitCommand extends BaseCommand {
-  command = "init";
-  description = "初始化 WorkClaw 插件";
-  /**
-   * 实现抽象的 action 方法
-   */
-  async action(...args) {
-    const options = args[args.length - 1];
-    await this.handleInit(options);
+function checkEnv() {
+  debugLog("[环境检查] 检测 Node.js 版本...");
+  const nodeVersion = execSync("node --version", { stdio: "pipe" }).toString().trim();
+  debugLog(`[环境检查] Node.js 版本: ${nodeVersion}`);
+  if (!semver.gte(nodeVersion, "18.0.0")) {
+    throw new AppError2(ERROR_CODES.NODE_VERSION_LOW, `Node.js 版本需要 >= 18.0.0，当前版本: ${nodeVersion}`);
   }
-  /**
-   * 获取 Commander 命令实例
-   */
-  getCommand() {
-    const cmd = new Command(this.command);
-    cmd.description(this.description).option("-s, --scenario <scenario>", "安装场景 (windows-local/mac-local/linux-local/linux-box)").option("-e, --env <env>", "环境 (test/prod)", "test").option("--phone <phone>", "手机号码").option("--user-pass <userPass>", "用户密码").option("--base-url <baseUrl>", "API 基础地址").option("--ws-url <wsUrl>", "WebSocket 地址").option("-f, --force", "强制覆盖", false).action(this.handleInit.bind(this)).addHelpText("after", `
-        示例:
-        $ workclaw init --phone 13800138000 --user-pass 123456
-        $ workclaw init --scenario windows-local --env test
-        $ workclaw init --scenario linux-box --base-url https://api.example.com
-
-        场景说明:
-        windows-local  - Windows 本地安装
-        mac-local      - macOS 本地安装
-        linux-local    - Linux 本地安装
-        linux-box      - Linux Box 环境安装`);
-    return cmd;
+  debugLog("[环境检查] Node.js 版本检查通过");
+  debugLog("[环境检查] 检测 npm...");
+  try {
+    const npmVersion = execSync("npm --version", { stdio: "pipe" }).toString().trim();
+    debugLog(`[环境检查] npm 版本: ${npmVersion}`);
+    debugLog("[环境检查] npm 检测通过");
+  } catch {
+    throw new AppError2(ERROR_CODES.NPM_NOT_FOUND, "未检测到 npm，请先安装 Node.js 和 npm");
   }
-  /**
-   * 处理 init 命令
-   */
-  async handleInit(options) {
-    logger.info("WorkClaw CLI 插件初始化工具 v2.0.0");
-    logger.info("=".repeat(40));
-    const scenario = this.resolveScenario(options.scenario);
-    const env = this.resolveEnv(options.env);
-    logger.info(`安装场景: ${this.getScenarioLabel(scenario)}`);
-    logger.info(`环境: ${env === "test" ? "测试环境" : "正式环境"}`);
-    const config = {
-      phone: options.phone,
-      userPass: options.userPass,
-      baseUrl: options.baseUrl,
-      wsUrl: options.wsUrl,
-      force: options.force,
-      env,
-      scenario
-    };
-    const installer = this.createInstaller(config);
-    const result = await installer.install();
-    if (!result.success) {
-      process$1.exit(1);
+}
+async function createLocalCommand(options) {
+  setDebug(!!options.debug);
+  debugLog("[初始化] 开始处理...");
+  debugLog(`[初始化] 参数: scenario=${options.scenario}, env=${options.env}, phone=${options.phone}, debug=${options.debug}`);
+  checkEnv();
+  debugLog("[初始化] 环境检查通过");
+  try {
+    let scenario = options.scenario;
+    let env = options.env;
+    let phone = options.phone;
+    let userPass = options.userPass;
+    const questions = [];
+    if (!scenario) {
+      debugLog("[初始化] 需要选择安装场景");
+      questions.push({
+        type: "list",
+        name: "scenario",
+        message: chalk.cyan("请选择安装场景:"),
+        default: "windows-local",
+        choices: [
+          { name: `${chalk.green("Windows")} ${chalk.dim("本地安装")}`, value: "windows-local" },
+          { name: `${chalk.green("macOS")} ${chalk.dim("本地安装")}`, value: "mac-local" },
+          { name: `${chalk.green("Linux")} ${chalk.dim("本地安装")}`, value: "linux-local" }
+        ]
+      });
+    } else {
+      debugLog(`[初始化] 使用命令行参数: scenario=${scenario}`);
     }
-  }
-  /**
-   * 解析场景
-   */
-  resolveScenario(scenario) {
-    if (scenario) {
-      const validScenarios = ["windows-local", "mac-local", "linux-local", "linux-box"];
-      if (validScenarios.includes(scenario)) {
-        return scenario;
-      }
-      logger.warn(`无效的场景: ${scenario}，将使用自动检测`);
+    if (!env) {
+      debugLog("[初始化] 需要选择环境");
+      questions.push({
+        type: "list",
+        name: "env",
+        message: chalk.cyan("请选择环境:"),
+        default: "test",
+        choices: [
+          { name: `${chalk.green("测试环境")} ${chalk.dim("(test)")}`, value: "test" },
+          { name: `${chalk.red("正式环境")} ${chalk.dim("(prod)")}`, value: "prod" }
+        ]
+      });
+    } else {
+      debugLog(`[初始化] 使用命令行参数: env=${env}`);
     }
-    return detectOS();
-  }
-  /**
-   * 解析环境
-   */
-  resolveEnv(env) {
-    if (env === "prod" || env === "test") {
-      return env;
+    if (!phone) {
+      debugLog("[初始化] 需要输入手机号码");
+      questions.push({
+        type: "input",
+        name: "phone",
+        message: chalk.cyan("请输入手机号码:"),
+        validate: (value) => {
+          if (!value || value.trim() === "") {
+            return chalk.red("手机号码不能为空");
+          }
+          if (!/^1[3-9]\d{9}$/.test(value)) {
+            return chalk.yellow("请输入正确的手机号码");
+          }
+          return true;
+        }
+      });
+    } else {
+      debugLog("[初始化] 使用命令行参数: phone");
     }
-    return "test";
-  }
-  /**
-   * 获取场景标签
-   */
-  getScenarioLabel(scenario) {
-    const labels = {
-      "windows-local": "Windows 本地安装",
-      "mac-local": "macOS 本地安装",
-      "linux-local": "Linux 本地安装",
-      "linux-box": "Linux Box 环境安装"
-    };
-    return labels[scenario];
-  }
-  /**
-   * 创建安装器实例
-   */
-  createInstaller(config) {
-    if (config.scenario === "linux-box") {
-      return new BoxInstaller(config);
+    if (!userPass) {
+      debugLog("[初始化] 需要输入用户密码");
+      questions.push({
+        type: "input",
+        name: "userPass",
+        message: chalk.cyan("请输入用户密码:"),
+        validate: (value) => {
+          if (!value || value.trim() === "") {
+            return chalk.red("用户密码不能为空");
+          }
+          return true;
+        }
+      });
+    } else {
+      debugLog("[初始化] 使用命令行参数: userPass");
+    }
+    if (questions.length > 0) {
+      debugLog(`[初始化] 开始交互式问答，共 ${questions.length} 个问题`);
+      const answers = await inquirer.prompt(questions);
+      debugLog("[初始化] 交互式问答完成");
+      scenario = scenario || answers.scenario;
+      env = env || answers.env || "test";
+      phone = phone || answers.phone;
+      userPass = userPass || answers.userPass;
     }
-    return new LocalInstaller(config);
+    debugLog(`[初始化] 最终参数: scenario=${scenario}, env=${env}, phone=${phone}, pluginVersion=${options.pluginVersion}`);
+    debugLog("[初始化] 创建 LocalInstaller 实例...");
+    const installer = new LocalInstaller({
+      phone,
+      userPass,
+      scenario,
+      env,
+      pluginVersion: options.pluginVersion
+    });
+    debugLog("[初始化] 开始安装...");
+    await installer.install();
+    debugLog("[初始化] 安装完成");
+    console.log(installer.getPrefixText() + boxen(
+      `${chalk.green("✦")} 插件初始化成功！`,
+      {
+        title: `${chalk.bold.green("初始化成功")}`,
+        titleAlignment: "center",
+        padding: { top: 1, bottom: 1, left: 5, right: 5 },
+        margin: 1,
+        borderStyle: "round",
+        borderColor: "green",
+        textAlignment: "center"
+      }
+    ));
+  } catch (error) {
+    debugLog(`[初始化] 发生错误: ${error.message}`);
+    console.error(boxen(
+      `${chalk.yellow(error.message)}`,
+      {
+        title: `${chalk.bold.red("初始化失败")}`,
+        titleAlignment: "center",
+        padding: { top: 1, bottom: 1, left: 5, right: 5 },
+        margin: 1,
+        borderStyle: "round",
+        borderColor: "red",
+        textAlignment: "center"
+      }
+    ));
+    process$1.exit(1);
   }
 }
-function createInitCommandInstance(program2) {
-  const initCommand = new InitCommand(program2);
-  const cmd = initCommand.getCommand();
-  program2.addCommand(cmd);
+function registerCommands(program2) {
+  program2.command("local").description("本地账户安装（需要登录）").option("-s, --scenario <scenario>", "安装场景").option("-e, --env <env>", "环境 (test/prod)").option("--phone <phone>", "手机号码").option("--user-pass <userPass>", "用户密码").option("--plugin-version <plugin-version>", "插件版本号（默认最新版）").option("--debug", "开启调试日志").action(createLocalCommand);
 }
 const __filename$1 = fileURLToPath(import.meta.url);
 const __dirname$1 = dirname(__filename$1);
@@ -5049,7 +5101,8 @@ const pkg = JSON.parse(readFileSync(resolve(__dirname$1, "../package.json"), "ut
 const program = new Command();
 function index() {
   program.name(Object.keys(pkg.bin)[0]).version(pkg.version).description(pkg.description);
-  createInitCommandInstance(program);
+  registerCommands(program);
+  registerCommands$1(program);
   program.parse(process$1.argv);
 }
 export {