weapp-ide-cli 5.0.4 → 5.1.0

package/dist/chunk-C2MXNGAM.js

@@ -0,0 +1,1472 @@
+import {
+  audit,
+  colors,
+  configureLocaleFromArgv,
+  currentPage,
+  i18nText,
+  input,
+  logger_default,
+  navigateBack,
+  navigateTo,
+  pageData,
+  pageStack,
+  reLaunch,
+  redirectTo,
+  remote,
+  scrollTo,
+  switchTab,
+  systemInfo,
+  tap,
+  validateLocaleOption
+} from "./chunk-NSYCXXXT.js";
+
+// src/cli/automator-argv.ts
+import process from "process";
+function parseAutomatorArgs(argv) {
+  const positionals = [];
+  let projectPath = process.cwd();
+  let timeout;
+  let json = false;
+  for (let index = 0; index < argv.length; index += 1) {
+    const token = argv[index];
+    if (!token) {
+      continue;
+    }
+    if (token === "-p" || token === "--project") {
+      const value = argv[index + 1];
+      if (typeof value === "string" && !value.startsWith("-")) {
+        projectPath = value;
+        index += 1;
+      } else {
+        projectPath = process.cwd();
+      }
+      continue;
+    }
+    if (token.startsWith("--project=")) {
+      projectPath = token.slice("--project=".length) || process.cwd();
+      continue;
+    }
+    if (token === "-t" || token === "--timeout") {
+      const value = argv[index + 1];
+      if (typeof value === "string") {
+        timeout = parsePositiveInt(value);
+        index += 1;
+      }
+      continue;
+    }
+    if (token.startsWith("--timeout=")) {
+      timeout = parsePositiveInt(token.slice("--timeout=".length));
+      continue;
+    }
+    if (token === "--json") {
+      json = true;
+      continue;
+    }
+    if (token.startsWith("-")) {
+      const optionName = token.includes("=") ? token.slice(0, token.indexOf("=")) : token;
+      if (takesValue(optionName) && !token.includes("=")) {
+        const value = argv[index + 1];
+        if (typeof value === "string" && !value.startsWith("-")) {
+          index += 1;
+        }
+      }
+      continue;
+    }
+    positionals.push(token);
+  }
+  return {
+    projectPath,
+    timeout,
+    json,
+    positionals
+  };
+}
+function readOptionValue(argv, optionName) {
+  const optionWithEqual = `${optionName}=`;
+  for (let index = 0; index < argv.length; index += 1) {
+    const token = argv[index];
+    if (!token) {
+      continue;
+    }
+    if (token === optionName) {
+      const value = argv[index + 1];
+      if (typeof value !== "string") {
+        return void 0;
+      }
+      return value.trim();
+    }
+    if (token.startsWith(optionWithEqual)) {
+      return token.slice(optionWithEqual.length).trim();
+    }
+  }
+  return void 0;
+}
+function removeOption(argv, optionName) {
+  const optionWithEqual = `${optionName}=`;
+  const nextArgv = [];
+  for (let index = 0; index < argv.length; index += 1) {
+    const token = argv[index];
+    if (!token) {
+      continue;
+    }
+    if (token === optionName) {
+      const nextToken = argv[index + 1];
+      if (takesValue(optionName) && typeof nextToken === "string" && !nextToken.startsWith("-")) {
+        index += 1;
+      }
+      continue;
+    }
+    if (token.startsWith(optionWithEqual)) {
+      continue;
+    }
+    nextArgv.push(token);
+  }
+  return nextArgv;
+}
+function parsePositiveInt(raw) {
+  const value = Number.parseInt(raw, 10);
+  if (!Number.isFinite(value) || value <= 0) {
+    return void 0;
+  }
+  return value;
+}
+function takesValue(optionName) {
+  return optionName === "-p" || optionName === "--project" || optionName === "-t" || optionName === "--timeout" || optionName === "-o" || optionName === "--output" || optionName === "--page" || optionName === "--login-retry" || optionName === "--login-retry-timeout" || optionName === "--lang" || optionName === "--platform" || optionName === "--qr-output" || optionName === "-r" || optionName === "--result-output" || optionName === "--info-output" || optionName === "-i";
+}
+
+// src/cli/screenshot.ts
+function printScreenshotHelp() {
+  console.log(i18nText(`
+${colors.bold("Usage:")} weapp screenshot [options]
+
+${colors.bold("\u53C2\u6570:")}
+  -p, --project <path>   \u9879\u76EE\u8DEF\u5F84\uFF08\u9ED8\u8BA4\uFF1A\u5F53\u524D\u76EE\u5F55\uFF09
+  -o, --output <path>    \u622A\u56FE\u8F93\u51FA\u6587\u4EF6\u8DEF\u5F84
+      --page <path>      \u622A\u56FE\u524D\u5148\u8DF3\u8F6C\u9875\u9762
+  -t, --timeout <ms>     \u8FDE\u63A5\u8D85\u65F6\u65F6\u95F4\uFF08\u9ED8\u8BA4\uFF1A30000\uFF09
+      --json             \u4EE5 JSON \u683C\u5F0F\u8F93\u51FA
+      --lang <lang>      \u8BED\u8A00\u5207\u6362\uFF1Azh | en\uFF08\u9ED8\u8BA4\uFF1Azh\uFF09
+  -h, --help             \u663E\u793A\u6B64\u5E2E\u52A9\u4FE1\u606F
+
+${colors.bold("\u793A\u4F8B:")}
+  # \u8F93\u51FA base64 \u5230 stdout
+  weapp screenshot -p /path/to/project
+
+  # \u4FDD\u5B58\u5230\u6587\u4EF6
+  weapp screenshot -p /path/to/project -o screenshot.png
+
+  # \u5148\u8DF3\u8F6C\u9875\u9762\u518D\u622A\u56FE
+  weapp screenshot -p /path/to/project --page pages/index/index
+
+  # \u4EE5 JSON \u8F93\u51FA\u4FBF\u4E8E\u811A\u672C\u89E3\u6790
+  weapp screenshot -p /path/to/project --json
+`, `
+${colors.bold("Usage:")} weapp screenshot [options]
+
+${colors.bold("Options:")}
+  -p, --project <path>   Project path (default: current directory)
+  -o, --output <path>    Output file path for screenshot
+      --page <path>      Navigate to page before taking screenshot
+  -t, --timeout <ms>     Connection timeout in milliseconds (default: 30000)
+      --json             Output as JSON format
+      --lang <lang>      Language: zh | en (default: zh)
+  -h, --help             Show this help message
+
+${colors.bold("Examples:")}
+  # Output base64 to stdout
+  weapp screenshot -p /path/to/project
+
+  # Save to file
+  weapp screenshot -p /path/to/project -o screenshot.png
+
+  # Navigate to page first
+  weapp screenshot -p /path/to/project --page pages/index/index
+
+  # JSON output for parsing
+  weapp screenshot -p /path/to/project --json
+`));
+}
+function parseScreenshotArgs(argv) {
+  const parsed = parseAutomatorArgs(argv);
+  return {
+    projectPath: parsed.projectPath,
+    timeout: parsed.timeout,
+    outputPath: readOptionValue(argv, "-o") || readOptionValue(argv, "--output"),
+    page: readOptionValue(argv, "--page")
+  };
+}
+async function runScreenshot(argv) {
+  if (argv.includes("-h") || argv.includes("--help")) {
+    printScreenshotHelp();
+    return;
+  }
+  const options = parseScreenshotArgs(argv);
+  const isJsonOutput = argv.includes("--json");
+  const { takeScreenshot: takeScreenshot2 } = await import("./commands-QGH4FNJB.js");
+  const result = await takeScreenshot2(options);
+  if (isJsonOutput) {
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+  if (result.base64) {
+    console.log(result.base64);
+  }
+}
+
+// src/cli/run-automator.ts
+var COMMON_ALLOWED_OPTIONS = /* @__PURE__ */ new Set(["-p", "--project", "-t", "--timeout", "--json", "--lang", "-h", "--help"]);
+var COMMAND_DEFINITIONS = {
+  "navigate": createDefinition({
+    description: { zh: "\u8DF3\u8F6C\u5230\u9875\u9762\uFF08\u4FDD\u7559\u5F53\u524D\u9875\u9762\u6808\uFF09", en: "Navigate to a page (keep current page in stack)" },
+    usage: "weapp navigate <url> -p <project-path>",
+    handler: async ({ args }) => {
+      const url = requiredPositional(
+        args.positionals[0],
+        i18nText("navigate \u547D\u4EE4\u7F3A\u5C11 URL \u53C2\u6570", "URL is required for 'navigate' command")
+      );
+      await navigateTo({ ...args, url });
+    }
+  }),
+  "redirect": createDefinition({
+    description: { zh: "\u91CD\u5B9A\u5411\u5230\u9875\u9762\uFF08\u5173\u95ED\u5F53\u524D\u9875\u9762\uFF09", en: "Redirect to a page (close current page)" },
+    usage: "weapp redirect <url> -p <project-path>",
+    handler: async ({ args }) => {
+      const url = requiredPositional(
+        args.positionals[0],
+        i18nText("redirect \u547D\u4EE4\u7F3A\u5C11 URL \u53C2\u6570", "URL is required for 'redirect' command")
+      );
+      await redirectTo({ ...args, url });
+    }
+  }),
+  "back": createDefinition({
+    description: { zh: "\u8FD4\u56DE\u4E0A\u4E00\u9875", en: "Navigate back to previous page" },
+    usage: "weapp back -p <project-path>",
+    handler: async ({ args }) => {
+      await navigateBack(args);
+    }
+  }),
+  "relaunch": createDefinition({
+    description: { zh: "\u91CD\u542F\u5230\u9875\u9762\uFF08\u5173\u95ED\u5168\u90E8\u9875\u9762\uFF09", en: "Re-launch to a page (close all pages)" },
+    usage: "weapp relaunch <url> -p <project-path>",
+    handler: async ({ args }) => {
+      const url = requiredPositional(
+        args.positionals[0],
+        i18nText("relaunch \u547D\u4EE4\u7F3A\u5C11 URL \u53C2\u6570", "URL is required for 'relaunch' command")
+      );
+      await reLaunch({ ...args, url });
+    }
+  }),
+  "switch-tab": createDefinition({
+    description: { zh: "\u5207\u6362\u5230 tabBar \u9875\u9762", en: "Switch to a tab bar page" },
+    usage: "weapp switch-tab <url> -p <project-path>",
+    handler: async ({ args }) => {
+      const url = requiredPositional(
+        args.positionals[0],
+        i18nText("switch-tab \u547D\u4EE4\u7F3A\u5C11 URL \u53C2\u6570", "URL is required for 'switch-tab' command")
+      );
+      await switchTab({ ...args, url });
+    }
+  }),
+  "page-stack": createDefinition({
+    description: { zh: "\u83B7\u53D6\u9875\u9762\u6808", en: "Get the page stack" },
+    usage: "weapp page-stack -p <project-path>",
+    handler: async ({ args }) => {
+      await pageStack(args);
+    }
+  }),
+  "current-page": createDefinition({
+    description: { zh: "\u83B7\u53D6\u5F53\u524D\u9875\u9762\u4FE1\u606F", en: "Get current page info" },
+    usage: "weapp current-page -p <project-path>",
+    handler: async ({ args }) => {
+      await currentPage(args);
+    }
+  }),
+  "system-info": createDefinition({
+    description: { zh: "\u83B7\u53D6\u7CFB\u7EDF\u4FE1\u606F", en: "Get system info" },
+    usage: "weapp system-info -p <project-path>",
+    handler: async ({ args }) => {
+      await systemInfo(args);
+    }
+  }),
+  "page-data": createDefinition({
+    description: { zh: "\u83B7\u53D6\u9875\u9762\u6570\u636E", en: "Get page data" },
+    usage: "weapp page-data [path] -p <project-path>",
+    handler: async ({ args }) => {
+      await pageData({ ...args, path: args.positionals[0] });
+    }
+  }),
+  "tap": createDefinition({
+    description: { zh: "\u70B9\u51FB\u5143\u7D20", en: "Tap an element" },
+    usage: "weapp tap <selector> -p <project-path>",
+    handler: async ({ args }) => {
+      const selector = requiredPositional(
+        args.positionals[0],
+        i18nText("tap \u547D\u4EE4\u7F3A\u5C11 selector \u53C2\u6570", "Selector is required for tap command")
+      );
+      await tap({ ...args, selector });
+    }
+  }),
+  "input": createDefinition({
+    description: { zh: "\u5411\u5143\u7D20\u8F93\u5165\u6587\u672C", en: "Input text into an element" },
+    usage: "weapp input <selector> <value> -p <project-path>",
+    handler: async ({ args }) => {
+      const errorMessage = i18nText("input \u547D\u4EE4\u7F3A\u5C11 selector \u6216 value \u53C2\u6570", "Selector and value are required for input command");
+      const selector = requiredPositional(args.positionals[0], errorMessage);
+      const value = requiredPositional(args.positionals[1], errorMessage);
+      await input({ ...args, selector, value });
+    }
+  }),
+  "scroll": createDefinition({
+    description: { zh: "\u6EDA\u52A8\u9875\u9762\u5230\u6307\u5B9A\u4F4D\u7F6E", en: "Scroll page to position" },
+    usage: "weapp scroll <scrollTop> -p <project-path>",
+    handler: async ({ args }) => {
+      const rawScrollTop = requiredPositional(
+        args.positionals[0],
+        i18nText("scroll \u547D\u4EE4\u7F3A\u5C11\u6EDA\u52A8\u4F4D\u7F6E\u53C2\u6570", "Scroll position is required for scroll command")
+      );
+      const scrollTop = Number.parseInt(rawScrollTop, 10);
+      if (!Number.isFinite(scrollTop)) {
+        throw new TypeError(i18nText(`\u65E0\u6548\u7684\u6EDA\u52A8\u4F4D\u7F6E: ${rawScrollTop}`, `Invalid scroll position: ${rawScrollTop}`));
+      }
+      await scrollTo({ ...args, scrollTop });
+    }
+  }),
+  "audit": createDefinition({
+    description: { zh: "\u6267\u884C\u4F53\u9A8C\u8BC4\u5206\u5BA1\u8BA1", en: "Run experience audit" },
+    usage: "weapp audit -p <project-path>",
+    options: [
+      { flag: "-o, --output <path>", description: { zh: "\u5BA1\u8BA1\u62A5\u544A\u8F93\u51FA\u6587\u4EF6\u8DEF\u5F84", en: "Output file path for report" } }
+    ],
+    allowedOptions: ["-o", "--output"],
+    handler: async ({ args, argv }) => {
+      const outputPath = readOptionValue(argv, "-o") || readOptionValue(argv, "--output");
+      await audit({ ...args, outputPath });
+    }
+  }),
+  "remote": createDefinition({
+    description: { zh: "\u5F00\u542F/\u5173\u95ED\u8FDC\u7A0B\u8C03\u8BD5", en: "Enable/disable remote debugging" },
+    usage: "weapp remote -p <project-path>",
+    options: [
+      { flag: "--disable", description: { zh: "\u5173\u95ED\u8FDC\u7A0B\u8C03\u8BD5", en: "Disable remote debugging" } }
+    ],
+    allowedOptions: ["--disable"],
+    handler: async ({ args, argv }) => {
+      await remote({ ...args, enable: !argv.includes("--disable") });
+    }
+  })
+};
+var AUTOMATOR_COMMAND_NAMES = ["screenshot", ...Object.keys(COMMAND_DEFINITIONS)];
+var AUTOMATOR_COMMANDS = new Set(AUTOMATOR_COMMAND_NAMES);
+function isAutomatorCommand(command) {
+  return Boolean(command && AUTOMATOR_COMMANDS.has(command));
+}
+async function runAutomatorCommand(command, argv) {
+  if (command === "screenshot") {
+    await runScreenshot(argv);
+    return;
+  }
+  const definition = COMMAND_DEFINITIONS[command];
+  if (!definition) {
+    throw new Error(i18nText(`\u672A\u77E5 automator \u547D\u4EE4: ${command}`, `Unknown automator command: ${command}`));
+  }
+  if (argv.includes("-h") || argv.includes("--help")) {
+    printCommandHelp(command);
+    return;
+  }
+  validateUnsupportedOptions(command, argv, definition.allowedOptions);
+  const args = parseAutomatorArgs(argv);
+  await definition.handler({ argv, args });
+}
+function getAutomatorCommandHelp(command) {
+  const definition = COMMAND_DEFINITIONS[command];
+  if (!definition) {
+    return void 0;
+  }
+  const optionLines = [
+    ...definition.options,
+    { flag: "-p, --project <path>", description: { zh: "\u9879\u76EE\u8DEF\u5F84\uFF08\u9ED8\u8BA4\uFF1A\u5F53\u524D\u76EE\u5F55\uFF09", en: "Project path (default: current directory)" } },
+    { flag: "-t, --timeout <ms>", description: { zh: "\u8FDE\u63A5\u8D85\u65F6\u65F6\u95F4\uFF08\u9ED8\u8BA4\uFF1A30000\uFF09", en: "Connection timeout (default: 30000)" } },
+    { flag: "--json", description: { zh: "\u652F\u6301\u65F6\u4EE5 JSON \u8F93\u51FA", en: "Output as JSON when supported" } },
+    { flag: "--lang <lang>", description: { zh: "\u8BED\u8A00\u5207\u6362\uFF1Azh | en\uFF08\u9ED8\u8BA4\uFF1Azh\uFF09", en: "Language: zh | en (default: zh)" } },
+    { flag: "-h, --help", description: { zh: "\u663E\u793A\u547D\u4EE4\u5E2E\u52A9", en: "Show command help" } }
+  ];
+  return [
+    i18nText(definition.description.zh, definition.description.en),
+    "",
+    `Usage: ${definition.usage}`,
+    "",
+    i18nText("\u53C2\u6570\uFF1A", "Options:"),
+    ...optionLines.map((option) => `  ${option.flag.padEnd(24)} ${i18nText(option.description.zh, option.description.en)}`)
+  ].join("\n");
+}
+function printCommandHelp(command) {
+  const help = getAutomatorCommandHelp(command);
+  if (help) {
+    console.log(help);
+    return;
+  }
+  logger_default.warn(i18nText(`\u547D\u4EE4 ${command} \u6682\u65E0\u5E2E\u52A9\u4FE1\u606F`, `No help available for command: ${command}`));
+}
+function createDefinition(input3) {
+  const options = input3.options ?? [];
+  const allowedOptions = /* @__PURE__ */ new Set([...COMMON_ALLOWED_OPTIONS, ...input3.allowedOptions ?? []]);
+  return {
+    description: input3.description,
+    usage: input3.usage,
+    options,
+    allowedOptions,
+    handler: input3.handler
+  };
+}
+function validateUnsupportedOptions(command, argv, allowedOptions) {
+  for (const token of argv) {
+    if (!token.startsWith("-")) {
+      continue;
+    }
+    const optionName = token.includes("=") ? token.slice(0, token.indexOf("=")) : token;
+    if (allowedOptions.has(optionName)) {
+      continue;
+    }
+    throw new Error(i18nText(
+      `'${command}' \u547D\u4EE4\u4E0D\u652F\u6301\u53C2\u6570 '${optionName}'`,
+      `Unknown option '${optionName}' for '${command}' command`
+    ));
+  }
+}
+function requiredPositional(value, message) {
+  if (!value) {
+    throw new Error(message);
+  }
+  return value;
+}
+
+// src/cli/command-catalog.ts
+var WECHAT_CLI_COMMAND_NAMES = [
+  "open",
+  "login",
+  "islogin",
+  "preview",
+  "auto-preview",
+  "upload",
+  "build-npm",
+  "auto",
+  "auto-replay",
+  "reset-fileutils",
+  "close",
+  "quit",
+  "cache",
+  "engine",
+  "open-other",
+  "build-ipa",
+  "build-apk",
+  "cloud"
+];
+var MINIDEV_NAMESPACE_COMMAND_NAMES = ["alipay", "ali", "minidev"];
+var CONFIG_COMMAND_NAME = "config";
+var WEAPP_IDE_TOP_LEVEL_COMMAND_NAMES = [
+  ...WECHAT_CLI_COMMAND_NAMES,
+  ...AUTOMATOR_COMMAND_NAMES,
+  ...MINIDEV_NAMESPACE_COMMAND_NAMES,
+  CONFIG_COMMAND_NAME
+];
+var WEAPP_IDE_TOP_LEVEL_COMMAND_SET = new Set(WEAPP_IDE_TOP_LEVEL_COMMAND_NAMES);
+function isWeappIdeTopLevelCommand(command) {
+  return Boolean(command && WEAPP_IDE_TOP_LEVEL_COMMAND_SET.has(command));
+}
+
+// src/utils/path.ts
+import process2 from "process";
+import path from "pathe";
+function resolvePath(filePath) {
+  if (path.isAbsolute(filePath)) {
+    return filePath;
+  }
+  return path.resolve(process2.cwd(), filePath);
+}
+
+// src/config/paths.ts
+import os from "os";
+import path2 from "pathe";
+var homedir = os.homedir();
+var defaultCustomConfigDirPath = path2.join(homedir, ".weapp-ide-cli");
+var defaultCustomConfigFilePath = path2.join(
+  defaultCustomConfigDirPath,
+  "config.json"
+);
+
+// src/config/custom.ts
+import fs from "fs-extra";
+var JSON_OPTIONS = {
+  encoding: "utf8",
+  spaces: 2
+};
+async function createCustomConfig(params) {
+  const trimmedCliPath = params.cliPath.trim();
+  if (!trimmedCliPath) {
+    throw new Error("cliPath cannot be empty");
+  }
+  const normalizedCliPath = resolvePath(trimmedCliPath);
+  await writeCustomConfig({
+    cliPath: normalizedCliPath
+  });
+  return normalizedCliPath;
+}
+async function createLocaleConfig(locale) {
+  await writeCustomConfig({ locale });
+  return locale;
+}
+async function removeCustomConfigKey(key) {
+  const currentConfig = await readCustomConfig();
+  if (!(key in currentConfig)) {
+    return;
+  }
+  const nextConfig = { ...currentConfig };
+  delete nextConfig[key];
+  await writeCustomConfig(nextConfig, { replace: true });
+}
+async function overwriteCustomConfig(config) {
+  const nextConfig = {};
+  if (typeof config.cliPath === "string" && config.cliPath.trim()) {
+    nextConfig.cliPath = resolvePath(config.cliPath.trim());
+  }
+  if (config.locale === "zh" || config.locale === "en") {
+    nextConfig.locale = config.locale;
+  }
+  await writeCustomConfig(nextConfig, { replace: true });
+}
+async function readCustomConfig() {
+  if (!await fs.pathExists(defaultCustomConfigFilePath)) {
+    return {};
+  }
+  try {
+    const config = await fs.readJSON(defaultCustomConfigFilePath);
+    if (!config || typeof config !== "object") {
+      return {};
+    }
+    const candidate = config;
+    const next = {};
+    if (typeof candidate.cliPath === "string" && candidate.cliPath.trim()) {
+      next.cliPath = candidate.cliPath.trim();
+    }
+    if (candidate.locale === "zh" || candidate.locale === "en") {
+      next.locale = candidate.locale;
+    }
+    return next;
+  } catch {
+    return {};
+  }
+}
+async function writeCustomConfig(patch, options = {}) {
+  const currentConfig = options.replace ? {} : await readCustomConfig();
+  const nextConfig = { ...currentConfig, ...patch };
+  await fs.ensureDir(defaultCustomConfigDirPath);
+  await fs.writeJSON(defaultCustomConfigFilePath, nextConfig, JSON_OPTIONS);
+}
+
+// src/cli/prompt.ts
+import { stdin as input2, stdout as output } from "process";
+import { createInterface } from "readline/promises";
+import fs2 from "fs-extra";
+async function promptForCliPath() {
+  const rl = createInterface({ input: input2, output });
+  try {
+    logger_default.info(`\u8BF7\u8BBE\u7F6E ${colors.bold("\u5FAE\u4FE1web\u5F00\u53D1\u8005\u5DE5\u5177 CLI")} \u7684\u8DEF\u5F84`);
+    logger_default.info("\u63D0\u793A\uFF1A\u547D\u4EE4\u884C\u5DE5\u5177\u9ED8\u8BA4\u6240\u5728\u4F4D\u7F6E\uFF1A");
+    logger_default.info(`- MacOS: ${colors.green("<\u5B89\u88C5\u8DEF\u5F84>/Contents/MacOS/cli")}`);
+    logger_default.info(`- Windows: ${colors.green("<\u5B89\u88C5\u8DEF\u5F84>/cli.bat")}`);
+    logger_default.info(`- Linux: ${colors.green("<\u5B89\u88C5\u8DEF\u5F84>/files/bin/bin/wechat-devtools-cli")}`);
+    const cliPath = (await rl.question("\u8BF7\u8F93\u5165\u5FAE\u4FE1web\u5F00\u53D1\u8005\u5DE5\u5177 CLI \u8DEF\u5F84\uFF1A")).trim();
+    if (!cliPath) {
+      logger_default.error("\u8DEF\u5F84\u4E0D\u80FD\u4E3A\u7A7A\uFF0C\u5DF2\u53D6\u6D88\u672C\u6B21\u914D\u7F6E\u3002");
+      return null;
+    }
+    try {
+      const normalizedPath = await createCustomConfig({ cliPath });
+      logger_default.info(`\u5168\u5C40\u914D\u7F6E\u5B58\u50A8\u4F4D\u7F6E\uFF1A${colors.green(defaultCustomConfigFilePath)}`);
+      if (!await fs2.pathExists(normalizedPath)) {
+        logger_default.warn("\u5728\u5F53\u524D\u8DEF\u5F84\u672A\u627E\u5230\u5FAE\u4FE1web\u5F00\u53D1\u8005\u547D\u4EE4\u884C\u5DE5\u5177\uFF0C\u8BF7\u786E\u8BA4\u8DEF\u5F84\u662F\u5426\u6B63\u786E\u3002");
+      }
+      return normalizedPath;
+    } catch (error) {
+      const reason = error instanceof Error ? error.message : String(error);
+      logger_default.error(`\u4FDD\u5B58\u914D\u7F6E\u5931\u8D25\uFF1A${reason}`);
+      return null;
+    }
+  } finally {
+    rl.close();
+  }
+}
+
+// src/runtime/platform.ts
+import os2 from "os";
+import process3 from "process";
+import fs3 from "fs-extra";
+import path3 from "pathe";
+var SupportedPlatformsMap = {
+  Windows_NT: "Windows_NT",
+  Darwin: "Darwin",
+  Linux: "Linux"
+};
+function isOperatingSystemSupported(osName = os2.type()) {
+  return osName === SupportedPlatformsMap.Windows_NT || osName === SupportedPlatformsMap.Darwin || osName === SupportedPlatformsMap.Linux;
+}
+var operatingSystemName = os2.type();
+function createLinuxCliResolver() {
+  let resolvedPath;
+  let attempted = false;
+  let pending = null;
+  return async () => {
+    if (attempted) {
+      return resolvedPath;
+    }
+    if (!pending) {
+      pending = (async () => {
+        try {
+          const envPath = await getFirstBinaryPath("wechat-devtools-cli");
+          if (envPath) {
+            resolvedPath = envPath;
+          }
+        } catch (error) {
+          const reason = error instanceof Error ? error.message : String(error);
+          logger_default.warn(`\u83B7\u53D6 Linux wechat-devtools-cli \u8DEF\u5F84\u5931\u8D25\uFF1A${reason}`);
+        } finally {
+          attempted = true;
+        }
+        return resolvedPath;
+      })();
+    }
+    return pending;
+  };
+}
+var linuxCliResolver = createLinuxCliResolver();
+var WINDOWS_DEFAULT_CLI = "C:\\Program Files (x86)\\Tencent\\\u5FAE\u4FE1web\u5F00\u53D1\u8005\u5DE5\u5177\\cli.bat";
+var DARWIN_DEFAULT_CLI = "/Applications/wechatwebdevtools.app/Contents/MacOS/cli";
+var cliPathResolvers = {
+  [SupportedPlatformsMap.Windows_NT]: async () => WINDOWS_DEFAULT_CLI,
+  [SupportedPlatformsMap.Darwin]: async () => DARWIN_DEFAULT_CLI,
+  [SupportedPlatformsMap.Linux]: linuxCliResolver
+};
+async function getDefaultCliPath(targetOs = operatingSystemName) {
+  if (!isOperatingSystemSupported(targetOs)) {
+    return void 0;
+  }
+  const resolver = cliPathResolvers[targetOs];
+  const resolvedPath = await resolver();
+  return resolvedPath;
+}
+async function getFirstBinaryPath(command) {
+  const envPath = process3.env.PATH || "";
+  const pathDirs = envPath.split(path3.delimiter);
+  for (const dir of pathDirs) {
+    const fullPath = path3.join(dir, command);
+    try {
+      await fs3.access(fullPath, fs3.constants.X_OK);
+      return fullPath;
+    } catch {
+      continue;
+    }
+  }
+  return void 0;
+}
+
+// src/config/resolver.ts
+import fs4 from "fs-extra";
+async function getConfig() {
+  if (await fs4.pathExists(defaultCustomConfigFilePath)) {
+    try {
+      const config = await fs4.readJSON(defaultCustomConfigFilePath);
+      const cliPath = typeof config.cliPath === "string" ? config.cliPath.trim() : "";
+      const locale = config.locale === "zh" || config.locale === "en" ? config.locale : void 0;
+      if (cliPath) {
+        logger_default.info(`\u5168\u5C40\u914D\u7F6E\u6587\u4EF6\u8DEF\u5F84\uFF1A${colors.green(defaultCustomConfigFilePath)}`);
+        logger_default.info(`\u81EA\u5B9A\u4E49 CLI \u8DEF\u5F84\uFF1A${colors.green(cliPath)}`);
+        return {
+          cliPath,
+          locale,
+          source: "custom"
+        };
+      }
+      logger_default.warn("\u81EA\u5B9A\u4E49\u914D\u7F6E\u6587\u4EF6\u7F3A\u5C11\u6709\u6548\u7684 CLI \u8DEF\u5F84\uFF0C\u5C06\u5C1D\u8BD5\u4F7F\u7528\u9ED8\u8BA4\u8DEF\u5F84\u3002");
+    } catch (error) {
+      const reason = error instanceof Error ? error.message : String(error);
+      logger_default.warn(`\u89E3\u6790\u81EA\u5B9A\u4E49\u914D\u7F6E\u5931\u8D25\uFF0C\u5C06\u5C1D\u8BD5\u4F7F\u7528\u9ED8\u8BA4\u8DEF\u5F84\u3002\u539F\u56E0\uFF1A${reason}`);
+    }
+  }
+  const fallbackPath = await getDefaultCliPath();
+  if (fallbackPath) {
+    return {
+      cliPath: fallbackPath,
+      locale: void 0,
+      source: "default"
+    };
+  }
+  return {
+    cliPath: "",
+    locale: void 0,
+    source: "missing"
+  };
+}
+async function getConfiguredLocale() {
+  const config = await readCustomConfig();
+  return config.locale;
+}
+
+// src/cli/resolver.ts
+import fs5 from "fs-extra";
+async function resolveCliPath() {
+  const config = await getConfig();
+  if (!config.cliPath) {
+    return { cliPath: null, source: config.source };
+  }
+  const exists = await fs5.pathExists(config.cliPath);
+  return {
+    cliPath: exists ? config.cliPath : null,
+    source: config.source
+  };
+}
+
+// src/cli/config-command.ts
+import fs6 from "fs-extra";
+async function handleConfigCommand(argv) {
+  const action = argv[0];
+  if (!action) {
+    await promptForCliPath();
+    return;
+  }
+  if (action === "lang" || action === "set-lang") {
+    const nextLocale = argv[1];
+    if (nextLocale !== "zh" && nextLocale !== "en") {
+      throw new Error(i18nText(
+        "\u8BF7\u4F7F\u7528 weapp config lang <zh|en> \u5207\u6362\u8BED\u8A00",
+        "Use weapp config lang <zh|en> to switch language"
+      ));
+    }
+    await createLocaleConfig(nextLocale);
+    logger_default.info(i18nText(
+      `\u8BED\u8A00\u5DF2\u5207\u6362\u4E3A\uFF1A${nextLocale === "zh" ? "\u4E2D\u6587" : "\u82F1\u6587"}`,
+      `Language switched to: ${nextLocale}`
+    ));
+    return;
+  }
+  if (action === "show") {
+    const config = await readCustomConfig();
+    logger_default.info(i18nText(
+      `\u914D\u7F6E\u6587\u4EF6\u8DEF\u5F84\uFF1A${colors.green(defaultCustomConfigFilePath)}`,
+      `Config file: ${colors.green(defaultCustomConfigFilePath)}`
+    ));
+    console.log(JSON.stringify(config, null, 2));
+    return;
+  }
+  if (action === "get") {
+    const key = argv[1];
+    if (key !== "cliPath" && key !== "locale") {
+      throw new Error(i18nText(
+        "\u4EC5\u652F\u6301\u8BFB\u53D6\u914D\u7F6E\u9879\uFF1AcliPath | locale",
+        "Supported keys: cliPath | locale"
+      ));
+    }
+    const config = await readCustomConfig();
+    const value = config[key];
+    if (typeof value === "string") {
+      console.log(value);
+      return;
+    }
+    console.log("");
+    return;
+  }
+  if (action === "set") {
+    const key = argv[1];
+    const value = argv.slice(2).join(" ").trim();
+    if (!value) {
+      throw new Error(i18nText(
+        "\u8BF7\u63D0\u4F9B\u914D\u7F6E\u503C\uFF0C\u4F8B\u5982\uFF1Aweapp config set locale en",
+        "Please provide a value, e.g. weapp config set locale en"
+      ));
+    }
+    if (key === "cliPath") {
+      await createCustomConfig({ cliPath: value });
+      logger_default.info(i18nText("CLI \u8DEF\u5F84\u5DF2\u66F4\u65B0\u3002", "CLI path updated."));
+      return;
+    }
+    if (key === "locale") {
+      if (value !== "zh" && value !== "en") {
+        throw new Error(i18nText(
+          "locale \u4EC5\u652F\u6301 zh \u6216 en",
+          "locale only supports zh or en"
+        ));
+      }
+      await createLocaleConfig(value);
+      logger_default.info(i18nText(
+        `\u8BED\u8A00\u5DF2\u5207\u6362\u4E3A\uFF1A${value === "zh" ? "\u4E2D\u6587" : "\u82F1\u6587"}`,
+        `Language switched to: ${value}`
+      ));
+      return;
+    }
+    throw new Error(i18nText(
+      "\u4EC5\u652F\u6301\u8BBE\u7F6E\u914D\u7F6E\u9879\uFF1AcliPath | locale",
+      "Supported keys for set: cliPath | locale"
+    ));
+  }
+  if (action === "unset") {
+    const key = argv[1];
+    if (key !== "cliPath" && key !== "locale") {
+      throw new Error(i18nText(
+        "\u4EC5\u652F\u6301\u6E05\u9664\u914D\u7F6E\u9879\uFF1AcliPath | locale",
+        "Supported keys for unset: cliPath | locale"
+      ));
+    }
+    await removeCustomConfigKey(key);
+    logger_default.info(i18nText(
+      `\u5DF2\u6E05\u9664\u914D\u7F6E\u9879\uFF1A${key}`,
+      `Config key cleared: ${key}`
+    ));
+    return;
+  }
+  if (action === "doctor") {
+    const rawConfig = await readCustomConfig();
+    const hasConfigFile = await fs6.pathExists(defaultCustomConfigFilePath);
+    const resolvedCli = await resolveCliPath();
+    const hasCustomCli = typeof rawConfig.cliPath === "string" && rawConfig.cliPath.length > 0;
+    const hasValidCli = Boolean(resolvedCli.cliPath);
+    const locale = rawConfig.locale ?? "zh";
+    const report = {
+      configFile: defaultCustomConfigFilePath,
+      configFileExists: hasConfigFile,
+      cliPath: rawConfig.cliPath ?? null,
+      cliPathValid: hasValidCli,
+      locale,
+      source: resolvedCli.source
+    };
+    logger_default.info(i18nText("\u914D\u7F6E\u8BCA\u65AD\u7ED3\u679C\uFF1A", "Configuration diagnostics:"));
+    console.log(JSON.stringify(report, null, 2));
+    if (!hasConfigFile) {
+      logger_default.warn(i18nText(
+        "\u672A\u627E\u5230\u914D\u7F6E\u6587\u4EF6\uFF0C\u53EF\u6267\u884C weapp config \u8FDB\u884C\u521D\u59CB\u5316\u3002",
+        "Config file not found. Run `weapp config` to initialize."
+      ));
+    }
+    if (hasCustomCli && !hasValidCli) {
+      logger_default.warn(i18nText(
+        "\u68C0\u6D4B\u5230\u914D\u7F6E\u7684 cliPath \u4E0D\u53EF\u7528\uFF0C\u8BF7\u6267\u884C weapp config set cliPath <path> \u4FEE\u590D\u3002",
+        "Configured cliPath is not available. Run `weapp config set cliPath <path>` to fix it."
+      ));
+    }
+    return;
+  }
+  if (action === "export") {
+    const outputPath = argv[1];
+    const config = await readCustomConfig();
+    if (outputPath) {
+      await fs6.writeJSON(outputPath, config, { spaces: 2, encoding: "utf8" });
+      logger_default.info(i18nText(
+        `\u914D\u7F6E\u5DF2\u5BFC\u51FA\u5230\uFF1A${colors.green(outputPath)}`,
+        `Config exported to: ${colors.green(outputPath)}`
+      ));
+      return;
+    }
+    console.log(JSON.stringify(config, null, 2));
+    return;
+  }
+  if (action === "import") {
+    const inputPath = argv[1];
+    if (!inputPath) {
+      throw new Error(i18nText(
+        "\u8BF7\u63D0\u4F9B\u5BFC\u5165\u6587\u4EF6\u8DEF\u5F84\uFF0C\u4F8B\u5982\uFF1Aweapp config import ./weapp-config.json",
+        "Please provide import file path, e.g. weapp config import ./weapp-config.json"
+      ));
+    }
+    const imported = await fs6.readJSON(inputPath);
+    if (!imported || typeof imported !== "object") {
+      throw new Error(i18nText(
+        "\u5BFC\u5165\u6587\u4EF6\u683C\u5F0F\u65E0\u6548\uFF1A\u5E94\u4E3A JSON \u5BF9\u8C61",
+        "Invalid import file format: expected a JSON object"
+      ));
+    }
+    const candidate = imported;
+    const cliPath = typeof candidate.cliPath === "string" ? candidate.cliPath : void 0;
+    const locale = candidate.locale === "zh" || candidate.locale === "en" ? candidate.locale : void 0;
+    await overwriteCustomConfig({ cliPath, locale });
+    logger_default.info(i18nText(
+      `\u914D\u7F6E\u5DF2\u4ECE ${colors.green(inputPath)} \u5BFC\u5165`,
+      `Config imported from ${colors.green(inputPath)}`
+    ));
+    return;
+  }
+  throw new Error(i18nText(
+    "\u652F\u6301\u7684 config \u5B50\u547D\u4EE4\uFF1Alang | set-lang | show | get | set | unset | doctor | import | export",
+    "Supported config subcommands: lang | set-lang | show | get | set | unset | doctor | import | export"
+  ));
+}
+
+// src/utils/argv.ts
+import process4 from "process";
+function ensurePathArgument(argv, optionIndex) {
+  const paramIdx = optionIndex + 1;
+  const param = argv[paramIdx];
+  if (param && !param.startsWith("-")) {
+    argv[paramIdx] = resolvePath(param);
+  } else {
+    argv.splice(paramIdx, 0, process4.cwd());
+  }
+  return argv;
+}
+function transformArgv(argv, transforms) {
+  return transforms.reduce((current, transform) => transform(current), [
+    ...argv
+  ]);
+}
+function createAlias(entry) {
+  return (input3) => {
+    const argv = [...input3];
+    let optionIndex = argv.indexOf(entry.find);
+    if (optionIndex > -1) {
+      argv.splice(optionIndex, 1, entry.replacement);
+    } else {
+      optionIndex = argv.indexOf(entry.replacement);
+    }
+    if (optionIndex === -1) {
+      return argv;
+    }
+    return ensurePathArgument(argv, optionIndex);
+  };
+}
+function createPathCompat(option) {
+  return (input3) => {
+    const argv = [...input3];
+    const optionIndex = argv.indexOf(option);
+    if (optionIndex === -1) {
+      return argv;
+    }
+    return ensurePathArgument(argv, optionIndex);
+  };
+}
+
+// src/utils/exec.ts
+import process5 from "process";
+async function execute(cliPath, argv, options = {}) {
+  const {
+    pipeStdout = true,
+    pipeStderr = true
+  } = options;
+  const { execa } = await import("execa");
+  const task = execa(cliPath, argv);
+  if (pipeStdout) {
+    task?.stdout?.pipe(process5.stdout);
+  }
+  if (pipeStderr) {
+    task?.stderr?.pipe(process5.stderr);
+  }
+  return await task;
+}
+
+// src/cli/minidev.ts
+var MINIDEV_COMMAND = "minidev";
+function isCommandNotFound(error) {
+  return Boolean(
+    error && typeof error === "object" && "code" in error && error.code === "ENOENT"
+  );
+}
+async function runMinidev(argv) {
+  try {
+    await execute(MINIDEV_COMMAND, [...argv]);
+  } catch (error) {
+    if (isCommandNotFound(error)) {
+      logger_default.error("\u672A\u68C0\u6D4B\u5230\u652F\u4ED8\u5B9D\u5C0F\u7A0B\u5E8F CLI\uFF1Aminidev");
+      logger_default.warn("\u8BF7\u5148\u5B89\u88C5 minidev\uFF0C\u53EF\u4F7F\u7528\u4EE5\u4E0B\u4EFB\u4E00\u547D\u4EE4\uFF1A");
+      logger_default.info(`- ${colors.green("pnpm add -g minidev")}`);
+      logger_default.info(`- ${colors.green("npm install -g minidev")}`);
+      logger_default.info(`- ${colors.green("yarn global add minidev")}`);
+      return;
+    }
+    throw error;
+  }
+}
+
+// src/cli/retry.ts
+import process6 from "process";
+import { emitKeypressEvents } from "readline";
+var LOGIN_REQUIRED_PATTERNS = [
+  /code\s*[:=]\s*10/i,
+  /需要重新登录/,
+  /need\s+re-?login/i,
+  /re-?login/i
+];
+function isWechatIdeLoginRequiredError(error) {
+  const text = extractExecutionErrorText(error);
+  if (!text) {
+    return false;
+  }
+  return LOGIN_REQUIRED_PATTERNS.some((pattern) => pattern.test(text));
+}
+function extractExecutionErrorText(error) {
+  if (!error || typeof error !== "object") {
+    return "";
+  }
+  const parts = [];
+  const candidate = error;
+  for (const field of [candidate.message, candidate.shortMessage, candidate.stderr, candidate.stdout]) {
+    if (typeof field === "string" && field.trim()) {
+      parts.push(field);
+    }
+  }
+  return parts.join("\n");
+}
+function formatWechatIdeLoginRequiredError(error) {
+  const text = extractExecutionErrorText(error);
+  const code = text.match(/code\s*[:=]\s*(\d+)/i)?.[1];
+  const message = extractLoginRequiredMessage(text);
+  const lines = ["\u5FAE\u4FE1\u5F00\u53D1\u8005\u5DE5\u5177\u8FD4\u56DE\u767B\u5F55\u9519\u8BEF\uFF1A"];
+  if (code) {
+    lines.push(`- code: ${code}`);
+  }
+  if (message) {
+    lines.push(`- message: ${message}`);
+  }
+  if (!code && !message) {
+    lines.push("- message: \u9700\u8981\u91CD\u65B0\u767B\u5F55");
+  }
+  return lines.join("\n");
+}
+function createWechatIdeLoginRequiredExitError(error, reason) {
+  const summary = formatWechatIdeLoginRequiredError(error);
+  const message = reason ? `${reason}
+${summary}` : summary;
+  const loginError = new Error(message);
+  loginError.name = "WechatIdeLoginRequiredError";
+  loginError.code = 10;
+  loginError.exitCode = 10;
+  return loginError;
+}
+function extractLoginRequiredMessage(text) {
+  if (!text) {
+    return "";
+  }
+  if (/需要重新登录/.test(text)) {
+    return "\u9700\u8981\u91CD\u65B0\u767B\u5F55";
+  }
+  const englishMatch = text.match(/need\s+re-?login|re-?login/i);
+  if (englishMatch?.[0]) {
+    return englishMatch[0].toLowerCase();
+  }
+  const firstLine = text.split(/\r?\n/).map((line) => line.trim()).find((line) => Boolean(line) && !line.startsWith("at "));
+  if (!firstLine) {
+    return "";
+  }
+  return firstLine.replace(/^\[error\]\s*/i, "").replace(/^error\s*:\s*/i, "").slice(0, 120);
+}
+async function waitForRetryKeypress(options = {}) {
+  const { timeoutMs = 3e4 } = options;
+  if (!process6.stdin.isTTY) {
+    return "cancel";
+  }
+  emitKeypressEvents(process6.stdin);
+  const hasSetRawMode = typeof process6.stdin.setRawMode === "function";
+  if (hasSetRawMode) {
+    process6.stdin.setRawMode(true);
+  }
+  process6.stdin.resume();
+  return new Promise((resolve) => {
+    let settled = false;
+    const normalizedTimeoutMs = Number.isFinite(timeoutMs) && timeoutMs > 0 ? timeoutMs : 3e4;
+    const timeout = setTimeout(() => {
+      done("timeout");
+    }, normalizedTimeoutMs);
+    const cleanup = () => {
+      clearTimeout(timeout);
+      process6.stdin.off("keypress", onKeypress);
+      if (hasSetRawMode) {
+        process6.stdin.setRawMode(false);
+      }
+      process6.stdin.pause();
+    };
+    const done = (value) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      cleanup();
+      resolve(value);
+    };
+    const onKeypress = (_str, key) => {
+      if (!key) {
+        return;
+      }
+      if (key.ctrl && key.name === "c") {
+        done("cancel");
+        return;
+      }
+      if (key.name === "r") {
+        done("retry");
+        return;
+      }
+      if (key.name === "q" || key.name === "escape") {
+        done("cancel");
+      }
+    };
+    process6.stdin.on("keypress", onKeypress);
+  });
+}
+function formatRetryHotkeyPrompt(timeoutMs = 3e4) {
+  const highlight = (key) => highlightHotkey(key);
+  const timeoutSeconds = Math.max(1, Math.ceil(timeoutMs / 1e3));
+  return i18nText(
+    `\u6309 ${highlight("r")} \u91CD\u8BD5\uFF0C\u6309 ${highlight("q")} / ${highlight("Esc")} / ${highlight("Ctrl+C")} \u9000\u51FA\uFF08${timeoutSeconds}s \u5185\u65E0\u8F93\u5165\u5C06\u81EA\u52A8\u5931\u8D25\uFF09\u3002`,
+    `Press ${highlight("r")} to retry, ${highlight("q")} / ${highlight("Esc")} / ${highlight("Ctrl+C")} to cancel (auto fail in ${timeoutSeconds}s).`
+  );
+}
+function highlightHotkey(key) {
+  return colors.bold(colors.green(key));
+}
+
+// src/cli/run-login.ts
+import process7 from "process";
+async function runWechatCliWithRetry(cliPath, argv) {
+  const loginRetryOptions = resolveLoginRetryOptions(argv);
+  const runtimeArgv = stripLoginRetryControlFlags(argv);
+  let retryCount = 0;
+  while (true) {
+    try {
+      const result = await execute(cliPath, runtimeArgv, {
+        pipeStdout: false,
+        pipeStderr: false
+      });
+      if (!isWechatIdeLoginRequiredError(result)) {
+        flushExecutionOutput(result);
+        return;
+      }
+      const action = await promptLoginRetry(result, loginRetryOptions, retryCount);
+      if (action === "retry") {
+        retryCount += 1;
+        logger_default.info(i18nText("\u6B63\u5728\u91CD\u8BD5\u8FDE\u63A5\u5FAE\u4FE1\u5F00\u53D1\u8005\u5DE5\u5177...", "Retrying to connect Wechat DevTools..."));
+        continue;
+      }
+      throw createWechatIdeLoginRequiredExitError(result);
+    } catch (error) {
+      if (!isWechatIdeLoginRequiredError(error)) {
+        throw error;
+      }
+      const action = await promptLoginRetry(error, loginRetryOptions, retryCount);
+      if (action === "retry") {
+        retryCount += 1;
+        logger_default.info(i18nText("\u6B63\u5728\u91CD\u8BD5\u8FDE\u63A5\u5FAE\u4FE1\u5F00\u53D1\u8005\u5DE5\u5177...", "Retrying to connect Wechat DevTools..."));
+        continue;
+      }
+      throw createWechatIdeLoginRequiredExitError(error);
+    }
+  }
+}
+function resolveLoginRetryOptions(argv) {
+  const nonInteractiveFlag = argv.includes("--non-interactive");
+  const ciMode = process7.env.CI === "true";
+  const nonTtyStdin = !isStdinInteractive();
+  const nonInteractive = nonInteractiveFlag || ciMode || nonTtyStdin;
+  const retryModeRaw = readOptionValue(argv, "--login-retry")?.toLowerCase();
+  const retryMode = normalizeLoginRetryMode(retryModeRaw, nonInteractive);
+  const retryTimeoutRaw = readOptionValue(argv, "--login-retry-timeout");
+  const retryTimeoutMs = normalizeLoginRetryTimeout(retryTimeoutRaw);
+  return {
+    nonInteractive,
+    retryMode,
+    retryTimeoutMs
+  };
+}
+function normalizeLoginRetryMode(value, nonInteractive) {
+  if (value && value !== "never" && value !== "once" && value !== "always") {
+    throw new Error(i18nText(
+      `\u4E0D\u652F\u6301\u7684 --login-retry \u503C: ${value}\uFF08\u4EC5\u652F\u6301 never/once/always\uFF09`,
+      `Invalid --login-retry value: ${value} (supported: never/once/always)`
+    ));
+  }
+  if (value === "never" || value === "once" || value === "always") {
+    return value;
+  }
+  return nonInteractive ? "never" : "always";
+}
+function normalizeLoginRetryTimeout(value) {
+  if (!value) {
+    return 3e4;
+  }
+  const parsed = Number.parseInt(value, 10);
+  if (!Number.isFinite(parsed) || parsed <= 0) {
+    throw new Error(i18nText(
+      `\u65E0\u6548\u7684 --login-retry-timeout \u503C: ${value}\uFF08\u5FC5\u987B\u4E3A\u6B63\u6574\u6570\uFF09`,
+      `Invalid --login-retry-timeout value: ${value} (must be a positive integer)`
+    ));
+  }
+  return parsed;
+}
+function isStdinInteractive() {
+  return Boolean(process7.stdin && process7.stdin.isTTY);
+}
+function stripLoginRetryControlFlags(argv) {
+  let next = removeOption(argv, "--login-retry");
+  next = removeOption(next, "--login-retry-timeout");
+  next = removeOption(next, "--non-interactive");
+  return next;
+}
+async function promptLoginRetry(errorLike, options, retryCount) {
+  const { nonInteractive, retryMode, retryTimeoutMs } = options;
+  logger_default.error(i18nText(
+    "\u68C0\u6D4B\u5230\u5FAE\u4FE1\u5F00\u53D1\u8005\u5DE5\u5177\u767B\u5F55\u72B6\u6001\u5931\u6548\uFF0C\u8BF7\u5148\u767B\u5F55\u540E\u91CD\u8BD5\u3002",
+    "Wechat DevTools login has expired. Please login and retry."
+  ));
+  logger_default.warn(i18nText(
+    "\u8BF7\u5148\u6253\u5F00\u5FAE\u4FE1\u5F00\u53D1\u8005\u5DE5\u5177\u5B8C\u6210\u767B\u5F55\u3002",
+    "Please open Wechat DevTools and complete login first."
+  ));
+  logger_default.warn(formatWechatIdeLoginRequiredError(errorLike));
+  if (nonInteractive) {
+    logger_default.error(i18nText(
+      "\u5F53\u524D\u4E3A\u975E\u4EA4\u4E92\u6A21\u5F0F\uFF0C\u68C0\u6D4B\u5230\u767B\u5F55\u5931\u6548\u540E\u76F4\u63A5\u5931\u8D25\u3002",
+      "Non-interactive mode enabled, failing immediately on login expiration."
+    ));
+    return "cancel";
+  }
+  const shouldAllowRetry = retryMode === "always" || retryMode === "once" && retryCount < 1;
+  if (!shouldAllowRetry) {
+    logger_default.info(i18nText("\u5F53\u524D\u91CD\u8BD5\u7B56\u7565\u4E0D\u5141\u8BB8\u7EE7\u7EED\u91CD\u8BD5\u3002", "Current retry policy does not allow further retries."));
+    return "cancel";
+  }
+  logger_default.info(formatRetryHotkeyPrompt(retryTimeoutMs));
+  const action = await waitForRetryKeypress({ timeoutMs: retryTimeoutMs });
+  if (action === "timeout") {
+    logger_default.error(i18nText(
+      `\u7B49\u5F85\u767B\u5F55\u91CD\u8BD5\u8F93\u5165\u8D85\u65F6\uFF08${retryTimeoutMs}ms\uFF09\uFF0C\u5DF2\u81EA\u52A8\u53D6\u6D88\u3002`,
+      `Retry prompt timed out (${retryTimeoutMs}ms), canceled automatically.`
+    ));
+    return "cancel";
+  }
+  if (action !== "retry") {
+    logger_default.info(i18nText(
+      "\u5DF2\u53D6\u6D88\u91CD\u8BD5\u3002\u5B8C\u6210\u767B\u5F55\u540E\u8BF7\u91CD\u65B0\u6267\u884C\u5F53\u524D\u547D\u4EE4\u3002",
+      "Retry canceled. Please run the command again after login."
+    ));
+    return "cancel";
+  }
+  return "retry";
+}
+function flushExecutionOutput(result) {
+  if (!result || typeof result !== "object") {
+    return;
+  }
+  const candidate = result;
+  if (typeof candidate.stdout === "string" && candidate.stdout) {
+    process7.stdout.write(candidate.stdout);
+  }
+  if (typeof candidate.stderr === "string" && candidate.stderr) {
+    process7.stderr.write(candidate.stderr);
+  }
+}
+
+// src/cli/wechat-command-schema.ts
+function validateWechatCliCommandArgs(argv) {
+  const command = argv[0];
+  if (!command) {
+    return;
+  }
+  validatePortOption(argv);
+  validateExtAppidDependency(argv);
+  if (command === "upload") {
+    const version = readOptionValue(argv, "--version") || readOptionValue(argv, "-v");
+    const desc = readOptionValue(argv, "--desc") || readOptionValue(argv, "-d");
+    if (!isNonEmptyText(version) || !isNonEmptyText(desc)) {
+      throw new Error(i18nText(
+        "upload \u547D\u4EE4\u7F3A\u5C11\u5FC5\u586B\u53C2\u6570\uFF1A--version/-v \u548C --desc/-d",
+        "upload command requires both --version/-v and --desc/-d"
+      ));
+    }
+  }
+  if (command === "preview") {
+    validateProjectLocator(command, argv);
+    const qrFormat = readOptionValue(argv, "--qr-format") || readOptionValue(argv, "-f");
+    if (!qrFormat) {
+      return;
+    }
+    if (!["terminal", "image", "base64"].includes(qrFormat.toLowerCase())) {
+      throw new Error(i18nText(
+        `preview \u547D\u4EE4\u7684\u4E8C\u7EF4\u7801\u683C\u5F0F\u65E0\u6548: ${qrFormat}\uFF08\u4EC5\u652F\u6301 terminal/image/base64\uFF09`,
+        `Invalid preview qr format: ${qrFormat} (supported: terminal/image/base64)`
+      ));
+    }
+  }
+  if (command === "upload" || command === "auto" || command === "auto-preview") {
+    validateProjectLocator(command, argv);
+  }
+}
+function validatePortOption(argv) {
+  const port = readOptionValue(argv, "--port");
+  if (!port) {
+    return;
+  }
+  const parsed = Number.parseInt(port, 10);
+  if (!Number.isFinite(parsed) || parsed <= 0) {
+    throw new Error(i18nText(
+      `\u65E0\u6548\u7684 --port \u503C: ${port}\uFF08\u5FC5\u987B\u4E3A\u6B63\u6574\u6570\uFF09`,
+      `Invalid --port value: ${port} (must be a positive integer)`
+    ));
+  }
+}
+function validateProjectLocator(command, argv) {
+  const projectPath = readOptionValue(argv, "--project");
+  const appid = readOptionValue(argv, "--appid");
+  if (isNonEmptyText(projectPath) || isNonEmptyText(appid)) {
+    return;
+  }
+  throw new Error(i18nText(
+    `${command} \u547D\u4EE4\u9700\u8981\u63D0\u4F9B --project \u6216 --appid`,
+    `${command} command requires --project or --appid`
+  ));
+}
+function validateExtAppidDependency(argv) {
+  const extAppid = readOptionValue(argv, "--ext-appid");
+  if (!isNonEmptyText(extAppid)) {
+    return;
+  }
+  const projectPath = readOptionValue(argv, "--project");
+  if (isNonEmptyText(projectPath)) {
+    return;
+  }
+  const appid = readOptionValue(argv, "--appid");
+  if (isNonEmptyText(appid)) {
+    return;
+  }
+  throw new Error(i18nText(
+    "--ext-appid \u9700\u8981\u548C --appid \u4E00\u8D77\u4F7F\u7528\uFF08\u5F53\u672A\u63D0\u4F9B --project \u65F6\uFF09",
+    "--ext-appid requires --appid when --project is not provided"
+  ));
+}
+function isNonEmptyText(value) {
+  return typeof value === "string" && value.trim().length > 0;
+}
+
+// src/cli/run.ts
+var MINIDEV_NAMESPACE = /* @__PURE__ */ new Set(["alipay", "ali", "minidev"]);
+var ALIPAY_PLATFORM_ALIASES = /* @__PURE__ */ new Set(["alipay", "ali", "minidev"]);
+var ARG_TRANSFORMS = [
+  createAlias({ find: "-p", replacement: "--project" }),
+  createPathCompat("--result-output"),
+  createPathCompat("-r"),
+  createPathCompat("--qr-output"),
+  createPathCompat("-o"),
+  createPathCompat("--info-output"),
+  createPathCompat("-i")
+];
+async function parse(argv) {
+  validateLocaleOption(argv);
+  const configuredLocale = await getConfiguredLocale();
+  configureLocaleFromArgv(argv, configuredLocale);
+  const command = argv[0];
+  if (command && MINIDEV_NAMESPACE.has(command)) {
+    await runMinidev(argv.slice(1));
+    return;
+  }
+  if (command && isAutomatorCommand(command)) {
+    await runAutomatorCommand(command, argv.slice(1));
+    return;
+  }
+  if (command === "help") {
+    const targetCommand = argv[1];
+    if (targetCommand === "screenshot") {
+      printScreenshotHelp();
+      return;
+    }
+    if (isAutomatorCommand(targetCommand)) {
+      await runAutomatorCommand(targetCommand, ["--help"]);
+      return;
+    }
+  }
+  const formattedArgv = transformArgv(argv, ARG_TRANSFORMS);
+  if (shouldDelegateOpenToMinidev(formattedArgv)) {
+    await runMinidev(createMinidevOpenArgv(formattedArgv));
+    return;
+  }
+  if (command === "config") {
+    await handleConfigCommand(argv.slice(1));
+    return;
+  }
+  if (!isOperatingSystemSupported(operatingSystemName)) {
+    logger_default.warn(i18nText(
+      `\u5FAE\u4FE1web\u5F00\u53D1\u8005\u5DE5\u5177\u4E0D\u652F\u6301\u5F53\u524D\u5E73\u53F0\uFF1A${operatingSystemName} !`,
+      `Wechat Web DevTools CLI is not supported on current platform: ${operatingSystemName}!`
+    ));
+    return;
+  }
+  validateWechatCliCommandArgs(formattedArgv);
+  const { cliPath, source } = await resolveCliPath();
+  if (!cliPath) {
+    const message = source === "custom" ? i18nText(
+      "\u5728\u5F53\u524D\u81EA\u5B9A\u4E49\u8DEF\u5F84\u4E2D\u672A\u627E\u5230\u5FAE\u4FE1web\u5F00\u53D1\u8005\u547D\u4EE4\u884C\u5DE5\u5177\uFF0C\u8BF7\u91CD\u65B0\u6307\u5B9A\u8DEF\u5F84\u3002",
+      "Cannot find Wechat Web DevTools CLI in custom path, please reconfigure it."
+    ) : i18nText(
+      `\u672A\u68C0\u6D4B\u5230\u5FAE\u4FE1web\u5F00\u53D1\u8005\u547D\u4EE4\u884C\u5DE5\u5177\uFF0C\u8BF7\u6267\u884C ${colors.bold(colors.green("weapp-ide-cli config"))} \u6307\u5B9A\u8DEF\u5F84\u3002`,
+      `Wechat Web DevTools CLI not found, please run ${colors.bold(colors.green("weapp-ide-cli config"))} to configure it.`
+    );
+    logger_default.warn(message);
+    await promptForCliPath();
+    return;
+  }
+  await runWechatCliWithRetry(cliPath, formattedArgv);
+}
+function shouldDelegateOpenToMinidev(argv) {
+  if (argv[0] !== "open") {
+    return false;
+  }
+  const platform = readOptionValue(argv, "--platform");
+  if (!platform) {
+    return false;
+  }
+  return ALIPAY_PLATFORM_ALIASES.has(platform.toLowerCase());
+}
+function createMinidevOpenArgv(argv) {
+  const nextArgv = [...argv];
+  nextArgv[0] = "ide";
+  return removeOption(nextArgv, "--platform");
+}
+
+export {
+  parseAutomatorArgs,
+  readOptionValue,
+  removeOption,
+  printScreenshotHelp,
+  parseScreenshotArgs,
+  AUTOMATOR_COMMAND_NAMES,
+  isAutomatorCommand,
+  runAutomatorCommand,
+  getAutomatorCommandHelp,
+  WECHAT_CLI_COMMAND_NAMES,
+  MINIDEV_NAMESPACE_COMMAND_NAMES,
+  CONFIG_COMMAND_NAME,
+  WEAPP_IDE_TOP_LEVEL_COMMAND_NAMES,
+  isWeappIdeTopLevelCommand,
+  resolvePath,
+  defaultCustomConfigDirPath,
+  defaultCustomConfigFilePath,
+  createCustomConfig,
+  createLocaleConfig,
+  removeCustomConfigKey,
+  overwriteCustomConfig,
+  readCustomConfig,
+  promptForCliPath,
+  SupportedPlatformsMap,
+  isOperatingSystemSupported,
+  operatingSystemName,
+  getDefaultCliPath,
+  getConfig,
+  getConfiguredLocale,
+  resolveCliPath,
+  handleConfigCommand,
+  transformArgv,
+  createAlias,
+  createPathCompat,
+  execute,
+  runMinidev,
+  isWechatIdeLoginRequiredError,
+  extractExecutionErrorText,
+  formatWechatIdeLoginRequiredError,
+  createWechatIdeLoginRequiredExitError,
+  waitForRetryKeypress,
+  formatRetryHotkeyPrompt,
+  runWechatCliWithRetry,
+  validateWechatCliCommandArgs,
+  parse
+};