@thinkingai/ae-cli 6.0.32 → 6.0.34

package/dist/index.js

@@ -4,33 +4,43 @@ import {
 import {
   TeAgentApiError,
   TeAgentCredentialsError
-} from "./chunk-R77JT7XD.js";
+} from "./chunk-4Q5TNP4Q.js";
+import {
+  getLocalCliPackageInfo
+} from "./chunk-VTWMIC5L.js";
 import {
   CapabilityGatewayError,
   executeCapability,
   uploadInputFileBytes
-} from "./chunk-I4A62X3N.js";
+} from "./chunk-HQ2A7ITL.js";
 import {
+  formatCapabilityMissCompatHint,
+  notifyIfUpdateAvailable,
   printError,
-  printOutput
-} from "./chunk-TNW2CI4W.js";
-import {
-  PermissionError
-} from "./chunk-NOO24N7W.js";
+  printOutput,
+  runHostCompatCheck
+} from "./chunk-IMMGMU54.js";
 import {
   clearCliToken,
   getCliToken
-} from "./chunk-2NDGFQHW.js";
+} from "./chunk-E7UXXHO3.js";
 import {
   SecureStoreAuthError,
   resolveHost
-} from "./chunk-AJTH7LT3.js";
+} from "./chunk-IR4ZLVPW.js";
 import {
   getActiveHost,
   getConfigDir,
-  logger,
   safeJsonParse
-} from "./chunk-YCLVYFK7.js";
+} from "./chunk-V6FR6WTW.js";
+import {
+  CliValidationError,
+  CommunityReportError,
+  PermissionError
+} from "./chunk-24BAVOX3.js";
+import {
+  logger
+} from "./chunk-LYVNONC4.js";
 
 // src/index.ts
 import { Command as CommanderCommand } from "commander";
@@ -49,7 +59,11 @@ async function runCommand(cmd, opts, globalOpts) {
   try {
     const ctx = createRuntimeContext(cmd, opts, globalOpts);
     const cmdName = cmd.resource ? `${cmd.service} ${cmd.resource} ${cmd.command}` : `${cmd.service} ${cmd.command}`;
-    logger.command(cmdName, opts);
+    logger.command(
+      cmdName,
+      opts,
+      cmd.flags.filter((flag) => flag.sensitive).map((flag) => flag.name)
+    );
     const missingRequired = cmd.flags.filter((flag) => {
       if (!flag.required) return false;
       const val = opts[camelCase(flag.name)];
@@ -99,6 +113,16 @@ async function runCommand(cmd, opts, globalOpts) {
         }
       }
     }
+    for (const flag of cmd.flags) {
+      if (flag.type !== "string") continue;
+      const val = opts[camelCase(flag.name)];
+      if (val === void 0 || val === null || val === "") continue;
+      const error = stringFlagValidationError(flag, String(val));
+      if (error) {
+        printError("validation", error.message, error.hint);
+        process.exit(1);
+      }
+    }
     if (globalOpts.validate && globalOpts.dryRun) {
       printError(
         "validation",
@@ -146,13 +170,25 @@ async function runCommand(cmd, opts, globalOpts) {
       process.exit(1);
     }
     const message = err.message || String(err);
-    logger.error(`Command failed: ${message}`);
-    if (err instanceof TeAgentCredentialsError) {
+    if (!(err instanceof CommunityReportError)) {
+      logger.error(`Command failed: ${message}`);
+    }
+    if (err instanceof CliValidationError) {
+      printError(
+        "validation",
+        message,
+        err.hint,
+        err.code,
+        err.location ? { location: err.location } : void 0
+      );
+    } else if (err instanceof TeAgentCredentialsError) {
       printError("config", message, err.hint);
     } else if (err instanceof PermissionError) {
       printError("permission", message);
     } else if (err instanceof CapabilityGatewayError) {
       printError("api", message, err.hint ?? capabilityGatewayHint(err), err.code, err.meta);
+    } else if (err instanceof CommunityReportError) {
+      printError("api", message, err.hint, err.code, err.meta, { log: false });
     } else if (err instanceof SecureStoreAuthError) {
       printError("auth", message, "Run: ae-cli auth login");
     } else if (err instanceof TeAgentApiError) {
@@ -171,15 +207,33 @@ async function runCommand(cmd, opts, globalOpts) {
     process.exit(1);
   }
 }
+function stringFlagValidationError(flag, value) {
+  if (flag.type !== "string") return void 0;
+  if (flag.minLength !== void 0 && value.length < flag.minLength) {
+    return { message: `--${flag.name} must contain at least ${flag.minLength} characters` };
+  }
+  if (flag.maxLength !== void 0 && value.length > flag.maxLength) {
+    return { message: `--${flag.name} must not exceed ${flag.maxLength} characters (got: ${value.length})` };
+  }
+  if (flag.pattern !== void 0 && !new RegExp(flag.pattern).test(value)) {
+    return { message: `--${flag.name} has an invalid format`, hint: `Expected pattern: ${flag.pattern}` };
+  }
+  return void 0;
+}
 function capabilityGatewayHint(err) {
   if (err.code === "UPLOAD_NOT_EXIST" && (err.meta?.capability_id === "engage-setting.config-table.save" || err.meta?.capability_id === "engage-setting.config-table.update-data")) {
     return "Run config-table upload first with the same --project-id and --request-id, then retry this command within 10 minutes. The upload cache is consumed after a successful save/update.";
   }
+  const compatExtra = formatCapabilityMissCompatHint();
   if (err.code === "CAPABILITY_NOT_FOUND") {
-    return "The current host does not expose this capability. Do not retry with different parameters; use a supported command path or ask the platform/backend owner to enable the capability.";
+    const base = "The current host does not expose this capability. Do not retry with different parameters; use a supported command path or ask the platform/backend owner to enable the capability.";
+    return compatExtra ? `${base}
+${compatExtra}` : base;
   }
   if (err.httpStatus === 404 && !err.code) {
-    return "The current host returned 404 for this capability route. Do not keep retrying the same command; verify the backend route/capability deployment.";
+    const base = "The current host returned 404 for this capability route. Do not keep retrying the same command; verify the backend route/capability deployment.";
+    return compatExtra ? `${base}
+${compatExtra}` : base;
   }
   return void 0;
 }
@@ -192,10 +246,17 @@ function createRuntimeContext(cmd, opts, globalOpts) {
   let _clientModule = null;
   async function getClient() {
     if (!_clientModule) {
-      _clientModule = await import("./client-2643Z5AG.js");
+      _clientModule = await import("./client-PP5FETMW.js");
     }
     return _clientModule;
   }
+  let _communityReportModule = null;
+  async function getCommunityReportClient() {
+    if (!_communityReportModule) {
+      _communityReportModule = await import("./community-report-client-KK2QBANO.js");
+    }
+    return _communityReportModule;
+  }
   const ctx = {
     str(name) {
       return String(opts[camelCase(name)] ?? "");
@@ -223,14 +284,18 @@ function createRuntimeContext(cmd, opts, globalOpts) {
         process.exit(1);
       }
     },
-    async api(method, path5, params, data) {
+    async api(method, path4, params, data) {
       const client = await getClient();
       if (method.toUpperCase() === "GET") {
-        return client.httpGet(path5, params, ctx.host());
+        return client.httpGet(path4, params, ctx.host());
       } else {
-        return client.httpRequest(method, path5, params, data, ctx.host());
+        return client.httpRequest(method, path4, params, data, ctx.host());
       }
     },
+    async communityReport(endpoint, rawBody) {
+      const client = await getCommunityReportClient();
+      return client.communityReport(endpoint, rawBody);
+    },
     async querySql(projectId, sql) {
       const client = await getClient();
       return client.querySql(projectId, sql, ctx.host());
@@ -240,7 +305,7 @@ function createRuntimeContext(cmd, opts, globalOpts) {
       return client.queryReportData(projectId, reportId, qp, eventModel, options, ctx.host());
     },
     async token() {
-      const { getToken } = await import("./auth-MEJ642P4.js");
+      const { getToken } = await import("./auth-ENM3FE6L.js");
       return getToken(ctx.host());
     },
     host() {
@@ -309,9 +374,16 @@ function registerCommands(program2, commands) {
           sub.option(flagStr, flag.desc);
         }
       }
-      sub.option("--host <url>", "Override active AE host URL for this command");
+      if (cmd.usesAeHost !== false) {
+        sub.option("--host <url>", "Override active AE host URL for this command");
+      }
       sub.option("--format <format>", "Output format: json | table. Default: json.");
       sub.option("--jq <expr>", "jq 1.8 filter over command payload, applied before output envelope wrapping.");
+      if (cmd.helpText) {
+        sub.addHelpText("after", `
+${cmd.helpText}
+`);
+      }
       sub.action(async (opts) => {
         const globalOpts = extractGlobalOptions(program2);
         if (opts.host) globalOpts.host = opts.host;
@@ -356,150 +428,9 @@ function extractGlobalOptions(program2) {
   };
 }
 
-// src/core/update-check.ts
-import fs from "fs";
-import path from "path";
-var CONFIG_DIR = path.join(process.env.HOME || "", ".ae-cli");
-var CACHE_FILE = path.join(CONFIG_DIR, "update-check.json");
-var CHECK_INTERVAL_MS = 24 * 60 * 60 * 1e3;
-var FETCH_TIMEOUT_MS = 3e3;
-var REGISTRY_BY_PACKAGE = {
-  "@thinkingai/ae-cli": "https://registry.npmjs.org"
-};
-var UPDATE_CHECK_PACKAGE = "@thinkingai/ae-cli";
-function isUpdateCheckEnabled(packageName) {
-  return packageName === UPDATE_CHECK_PACKAGE;
-}
-var DEFAULT_REGISTRY = "https://registry.npmjs.org";
-function parseVersion(version2) {
-  const core = version2.trim().split("-")[0];
-  return core.split(".").map((part) => {
-    const n = Number.parseInt(part, 10);
-    return Number.isFinite(n) ? n : 0;
-  });
-}
-function isNewer(latest, current) {
-  const a = parseVersion(latest);
-  const b = parseVersion(current);
-  const len = Math.max(a.length, b.length, 3);
-  for (let i = 0; i < len; i += 1) {
-    const av = a[i] ?? 0;
-    const bv = b[i] ?? 0;
-    if (av > bv) return true;
-    if (av < bv) return false;
-  }
-  return false;
-}
-function resolveRegistry(packageName) {
-  if (REGISTRY_BY_PACKAGE[packageName]) {
-    return REGISTRY_BY_PACKAGE[packageName];
-  }
-  const envRegistry = process.env.npm_config_registry?.replace(/\/$/, "");
-  return envRegistry || DEFAULT_REGISTRY;
-}
-function buildInstallCommand(packageName, registry) {
-  const base = `npm install -g ${packageName}@latest`;
-  if (registry === DEFAULT_REGISTRY) {
-    return base;
-  }
-  return `${base} --registry=${registry}`;
-}
-function shouldSkipUpdateCheck(argv = process.argv) {
-  if (process.env.AE_CLI_NO_UPDATE_CHECK === "1") return true;
-  if (process.env.CI === "true" || process.env.CI === "1") return true;
-  return argv.slice(2).some((arg) => {
-    if (arg === "--no-update-check") return true;
-    if (arg === "--version" || arg === "-V" || arg === "--help" || arg === "-h") return true;
-    return false;
-  });
-}
-function ensureConfigDir() {
-  if (!fs.existsSync(CONFIG_DIR)) {
-    fs.mkdirSync(CONFIG_DIR, { recursive: true });
-  }
-}
-function readCache() {
-  try {
-    if (!fs.existsSync(CACHE_FILE)) return null;
-    const raw = fs.readFileSync(CACHE_FILE, "utf8");
-    const data = JSON.parse(raw);
-    if (!data.packageName || !data.latestVersion || !data.lastCheckedAt) return null;
-    return data;
-  } catch {
-    return null;
-  }
-}
-function writeCache(cache) {
-  try {
-    ensureConfigDir();
-    fs.writeFileSync(CACHE_FILE, JSON.stringify(cache, null, 2));
-  } catch {
-  }
-}
-function cacheIsStale(cache, packageName) {
-  if (!cache || cache.packageName !== packageName) return true;
-  const age = Date.now() - new Date(cache.lastCheckedAt).getTime();
-  return age >= CHECK_INTERVAL_MS;
-}
-function printUpdateNotice(current, latest, installCommand) {
-  process.stderr.write(`[ae-cli] Update available: ${current} \u2192 ${latest}
-`);
-  process.stderr.write(`         Run: ${installCommand}
-`);
-}
-async function fetchLatestVersion(packageName, registry) {
-  const url = `${registry.replace(/\/$/, "")}/${encodeURIComponent(packageName)}`;
-  const controller = new AbortController();
-  const timer = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
-  try {
-    const resp = await fetch(url, {
-      signal: controller.signal,
-      headers: { Accept: "application/json" }
-    });
-    if (!resp.ok) return null;
-    const data = await resp.json();
-    const latest = data["dist-tags"]?.latest;
-    return typeof latest === "string" && latest.trim() ? latest.trim() : null;
-  } catch {
-    return null;
-  } finally {
-    clearTimeout(timer);
-  }
-}
-async function refreshCache(pkg2, registry) {
-  const latest = await fetchLatestVersion(pkg2.name, registry);
-  if (!latest) return readCache();
-  const cache = {
-    packageName: pkg2.name,
-    currentVersion: pkg2.version,
-    latestVersion: latest,
-    lastCheckedAt: (/* @__PURE__ */ new Date()).toISOString()
-  };
-  writeCache(cache);
-  return cache;
-}
-function maybeNotifyFromCache(pkg2, cache, registry) {
-  if (!cache || cache.packageName !== pkg2.name) return;
-  if (!isNewer(cache.latestVersion, pkg2.version)) return;
-  printUpdateNotice(pkg2.version, cache.latestVersion, buildInstallCommand(pkg2.name, registry));
-}
-function notifyIfUpdateAvailable(pkg2) {
-  if (!isUpdateCheckEnabled(pkg2.name)) return;
-  if (shouldSkipUpdateCheck()) return;
-  const registry = resolveRegistry(pkg2.name);
-  const cache = readCache();
-  maybeNotifyFromCache(pkg2, cache, registry);
-  if (!cacheIsStale(cache, pkg2.name)) return;
-  void refreshCache(pkg2, registry).then((fresh) => {
-    if (!fresh) return;
-    if (cache && fresh.latestVersion === cache.latestVersion) return;
-    maybeNotifyFromCache(pkg2, fresh, registry);
-  });
-}
-
 // src/commands/tracking/plan.ts
 import { readFile, writeFile, cp } from "fs/promises";
-import path3, { resolve as resolve2 } from "path";
+import path2, { resolve as resolve2 } from "path";
 
 // src/tracking/xlsx/write.ts
 import ExcelJS from "exceljs";
@@ -719,13 +650,13 @@ function allHeaderNames(key) {
 
 // src/tracking/i18n/resources/xlsx/types.ts
 var PROP_TYPE_DISPLAY = {
-  string: { zh: "\u6587\u672C", en: "string", ja: "\u30B9\u30C8\u30EA\u30F3\u30B0", ko: "string" },
-  number: { zh: "\u6570\u503C", en: "number", ja: "\u6570\u5024", ko: "number" },
-  bool: { zh: "\u5E03\u5C14", en: "boolean", ja: "\u30D6\u30FC\u30EB\u5024", ko: "boolean" },
-  datetime: { zh: "\u65F6\u95F4", en: "datetime", ja: "\u6642\u9593", ko: "time" },
-  object: { zh: "\u5BF9\u8C61", en: "object", ja: "\u30AA\u30D6\u30B8\u30A7\u30AF\u30C8", ko: "object" },
-  array_row: { zh: "\u5BF9\u8C61\u7EC4", en: "object[]", ja: "\u30AA\u30D6\u30B8\u30A7\u30AF\u30C8\u914D\u5217", ko: "object_array" },
-  array_string: { zh: "\u5217\u8868", en: "string[]", ja: "\u914D\u5217", ko: "string_array" }
+  string: { zh: "\u6587\u672C", en: "String", ja: "\u30B9\u30C8\u30EA\u30F3\u30B0", ko: "String" },
+  number: { zh: "\u6570\u503C", en: "Number", ja: "\u6570\u5024", ko: "Number" },
+  bool: { zh: "\u5E03\u5C14", en: "Boolean", ja: "\u30D6\u30FC\u30EB\u5024", ko: "Boolean" },
+  datetime: { zh: "\u65F6\u95F4", en: "Date", ja: "\u6642\u9593", ko: "Date" },
+  object: { zh: "\u5BF9\u8C61", en: "Row", ja: "\u30AA\u30D6\u30B8\u30A7\u30AF\u30C8", ko: "Row" },
+  array_row: { zh: "\u5BF9\u8C61\u7EC4", en: "Array Row", ja: "\u30AA\u30D6\u30B8\u30A7\u30AF\u30C8\u30B0\u30EB\u30FC\u30D7", ko: "Array Row" },
+  array_string: { zh: "\u5217\u8868", en: "List", ja: "\u30EA\u30B9\u30C8", ko: "List" }
 };
 function typeToDisplay(type, locale) {
   return PROP_TYPE_DISPLAY[type][locale];
@@ -739,24 +670,29 @@ for (const [canonical, locales] of Object.entries(PROP_TYPE_DISPLAY)) {
 var ALIASES = {
   // zh alias（行业模板）
   "\u5B57\u7B26\u4E32": "string",
-  "\u5BF9\u8C61": "object",
-  // en alias
-  "String": "string",
-  "Number": "number",
-  "Boolean": "bool",
+  // en alias（旧值兼容 — 2026-07-15 前生成的老 xlsx）
+  "string": "string",
+  "number": "number",
+  "boolean": "bool",
+  "datetime": "datetime",
+  "object": "object",
+  "object[]": "array_row",
+  "string[]": "array_string",
+  // en 额外 alias
   "Bool": "bool",
   "DateTime": "datetime",
   "Time": "datetime",
   "Object": "object",
-  "Row": "object",
   "Object Array": "array_row",
-  "List": "array_string",
   "String Array": "array_string",
   // ja alias
   "\u6587\u5B57\u5217": "string",
   "\u30C6\u30AD\u30B9\u30C8": "string",
   "\u30D6\u30FC\u30EB": "bool",
   "\u65E5\u6642": "datetime",
+  // ja 旧值兼容
+  "\u30AA\u30D6\u30B8\u30A7\u30AF\u30C8\u914D\u5217": "array_row",
+  "\u914D\u5217": "array_string",
   // ko alias
   "\uD14D\uC2A4\uD2B8": "string",
   "\uBB38\uC790\uC5F4": "string",
@@ -764,7 +700,11 @@ var ALIASES = {
   "\uBD80\uC6B8": "bool",
   "\uB0A0\uC9DC\uC2DC\uAC04": "datetime",
   "\uAC1D\uCCB4 \uBC30\uC5F4": "array_row",
-  "\uB9AC\uC2A4\uD2B8": "array_string"
+  "\uB9AC\uC2A4\uD2B8": "array_string",
+  // ko 旧值兼容
+  "time": "datetime",
+  "object_array": "array_row",
+  "string_array": "array_string"
 };
 Object.assign(ALL_DISPLAY_TO_TYPE, ALIASES);
 function displayToType(raw) {
@@ -844,6 +784,193 @@ function t(key, params, locale) {
   return node;
 }
 
+// src/tracking/xlsx/tag-priority.ts
+var TAG_PRIORITY = {
+  // Account lifecycle
+  "Basic": 1,
+  // Core gameplay
+  "Battle": 10,
+  "Stage": 11,
+  "Dungeon": 12,
+  "Gacha": 13,
+  // Progression & economy
+  "Growth": 20,
+  "Resource": 21,
+  // Monetization
+  "Ads": 30,
+  "Payment": 31,
+  "Subscription": 32,
+  // Supporting systems
+  "Shop": 40,
+  "Quest": 41,
+  "Achievement": 42,
+  "Check-in": 43,
+  "Leaderboard": 44,
+  "Guild": 45,
+  "Social": 46,
+  // Genre-specific (game)
+  "Building": 50,
+  "Alliance": 51,
+  "Equipment": 52,
+  "Trade": 53,
+  "Revive": 54,
+  "Slots": 55,
+  "Lottery": 56,
+  "Reward": 57,
+  // Non-game
+  "Discovery": 60,
+  "Product": 61,
+  "Order": 62,
+  "After-sales": 63,
+  "Content": 64,
+  "Interaction": 65,
+  "Relationship": 66,
+  "Live": 67,
+  "Onboarding": 68,
+  "Course": 69,
+  "Enrollment": 70,
+  "Quiz": 71,
+  "Creation": 72,
+  "Material": 73,
+  "Export": 74,
+  "Playback": 75,
+  "Withdraw": 76
+};
+var DEFAULT_TAG_PRIORITY = 80;
+var CANONICAL_TAG = {
+  // zh
+  "\u57FA\u7840\u4E8B\u4EF6": "Basic",
+  "\u6218\u6597": "Battle",
+  "\u5173\u5361": "Stage",
+  "\u526F\u672C": "Dungeon",
+  "\u62BD\u5361": "Gacha",
+  "\u517B\u6210": "Growth",
+  "\u6210\u957F": "Growth",
+  "\u8D44\u6E90": "Resource",
+  "\u5E7F\u544A": "Ads",
+  "\u652F\u4ED8": "Payment",
+  "\u8BA2\u9605": "Subscription",
+  "\u5546\u57CE": "Shop",
+  "\u4EFB\u52A1": "Quest",
+  "\u6210\u5C31": "Achievement",
+  "\u7B7E\u5230": "Check-in",
+  "\u6392\u884C\u699C": "Leaderboard",
+  "\u516C\u4F1A": "Guild",
+  "\u793E\u4EA4": "Social",
+  "\u5EFA\u7B51": "Building",
+  "\u8054\u76DF": "Alliance",
+  "\u88C5\u5907": "Equipment",
+  "\u4EA4\u6613": "Trade",
+  "\u590D\u6D3B": "Revive",
+  "\u62BD\u5956": "Lottery",
+  "\u5956\u52B1": "Reward",
+  "\u63D0\u73B0": "Withdraw",
+  "\u53D1\u73B0": "Discovery",
+  "\u5546\u54C1": "Product",
+  "\u8BA2\u5355": "Order",
+  "\u552E\u540E": "After-sales",
+  "\u5185\u5BB9": "Content",
+  "\u4E92\u52A8": "Interaction",
+  "\u5173\u7CFB": "Relationship",
+  "\u76F4\u64AD": "Live",
+  "\u5F15\u5BFC": "Onboarding",
+  "\u8BFE\u7A0B": "Course",
+  "\u62A5\u540D": "Enrollment",
+  "\u6D4B\u9A8C": "Quiz",
+  "\u521B\u4F5C": "Creation",
+  "\u7D20\u6750": "Material",
+  "\u5BFC\u51FA": "Export",
+  "\u5185\u5BB9\u64AD\u653E": "Playback",
+  // ja
+  "\u57FA\u672C\u30A4\u30D9\u30F3\u30C8": "Basic",
+  "\u6226\u95D8": "Battle",
+  "\u30B9\u30C6\u30FC\u30B8": "Stage",
+  "\u30C0\u30F3\u30B8\u30E7\u30F3": "Dungeon",
+  "\u30AC\u30C1\u30E3": "Gacha",
+  "\u80B2\u6210": "Growth",
+  "\u30EA\u30BD\u30FC\u30B9": "Resource",
+  "\u5E83\u544A": "Ads",
+  "\u652F\u6255\u3044": "Payment",
+  "\u30B5\u30D6\u30B9\u30AF\u30EA\u30D7\u30B7\u30E7\u30F3": "Subscription",
+  "\u30B7\u30E7\u30C3\u30D7": "Shop",
+  "\u30AF\u30A8\u30B9\u30C8": "Quest",
+  "\u5B9F\u7E3E": "Achievement",
+  "\u30C1\u30A7\u30C3\u30AF\u30A4\u30F3": "Check-in",
+  "\u30E9\u30F3\u30AD\u30F3\u30B0": "Leaderboard",
+  "\u30AE\u30EB\u30C9": "Guild",
+  "\u30BD\u30FC\u30B7\u30E3\u30EB": "Social",
+  "\u5EFA\u7BC9": "Building",
+  "\u540C\u76DF": "Alliance",
+  "\u88C5\u5099": "Equipment",
+  "\u30C8\u30EC\u30FC\u30C9": "Trade",
+  "\u5FA9\u6D3B": "Revive",
+  "\u30B9\u30ED\u30C3\u30C8": "Slots",
+  "\u62BD\u9078": "Lottery",
+  "\u5831\u916C": "Reward",
+  "\u5F15\u304D\u51FA\u3057": "Withdraw",
+  "\u767A\u898B": "Discovery",
+  "\u6CE8\u6587": "Order",
+  "\u30A2\u30D5\u30BF\u30FC\u30B5\u30FC\u30D3\u30B9": "After-sales",
+  "\u30B3\u30F3\u30C6\u30F3\u30C4": "Content",
+  "\u30A4\u30F3\u30BF\u30E9\u30AF\u30B7\u30E7\u30F3": "Interaction",
+  "\u95A2\u4FC2": "Relationship",
+  "\u30E9\u30A4\u30D6": "Live",
+  "\u30AA\u30F3\u30DC\u30FC\u30C7\u30A3\u30F3\u30B0": "Onboarding",
+  "\u30B3\u30FC\u30B9": "Course",
+  "\u7533\u3057\u8FBC\u307F": "Enrollment",
+  "\u30AF\u30A4\u30BA": "Quiz",
+  "\u5275\u4F5C": "Creation",
+  "\u30A8\u30AF\u30B9\u30DD\u30FC\u30C8": "Export",
+  "\u518D\u751F": "Playback",
+  // ko
+  "\uAE30\uBCF8 \uC774\uBCA4\uD2B8": "Basic",
+  "\uC804\uD22C": "Battle",
+  "\uC2A4\uD14C\uC774\uC9C0": "Stage",
+  "\uB358\uC804": "Dungeon",
+  "\uAC00\uCC60": "Gacha",
+  "\uC721\uC131": "Growth",
+  "\uB9AC\uC18C\uC2A4": "Resource",
+  "\uAD11\uACE0": "Ads",
+  "\uACB0\uC81C": "Payment",
+  "\uAD6C\uB3C5": "Subscription",
+  "\uC0C1\uC810": "Shop",
+  "\uD018\uC2A4\uD2B8": "Quest",
+  "\uC5C5\uC801": "Achievement",
+  "\uCD9C\uC11D\uCCB4\uD06C": "Check-in",
+  "\uB9AC\uB354\uBCF4\uB4DC": "Leaderboard",
+  "\uAE38\uB4DC": "Guild",
+  "\uC18C\uC15C": "Social",
+  "\uAC74\uC124": "Building",
+  "\uC5F0\uB9F9": "Alliance",
+  "\uC7A5\uBE44": "Equipment",
+  "\uAC70\uB798": "Trade",
+  "\uBD80\uD65C": "Revive",
+  "\uC2AC\uB86F": "Slots",
+  "\uCD94\uCCA8": "Lottery",
+  "\uBCF4\uC0C1": "Reward",
+  "\uCD9C\uAE08": "Withdraw",
+  "\uBC1C\uACAC": "Discovery",
+  "\uC0C1\uD488": "Product",
+  "\uC8FC\uBB38": "Order",
+  "A/S": "After-sales",
+  "\uCF58\uD150\uCE20": "Content",
+  "\uC778\uD130\uB799\uC158": "Interaction",
+  "\uAD00\uACC4": "Relationship",
+  "\uB77C\uC774\uBE0C": "Live",
+  "\uC628\uBCF4\uB529": "Onboarding",
+  "\uCF54\uC2A4": "Course",
+  "\uC2E0\uCCAD": "Enrollment",
+  "\uD034\uC988": "Quiz",
+  "\uCC3D\uC791": "Creation",
+  "\uC18C\uC7AC": "Material",
+  "\uB0B4\uBCF4\uB0B4\uAE30": "Export",
+  "\uC7AC\uC0DD": "Playback"
+};
+function getTagPriority(tag) {
+  const canonical = CANONICAL_TAG[tag] ?? tag;
+  return TAG_PRIORITY[canonical] ?? DEFAULT_TAG_PRIORITY;
+}
+
 // src/tracking/xlsx/write.ts
 var PLATFORM_TO_XLSX = {
   "client": "client",
@@ -854,6 +981,49 @@ var VALID_PROP_TYPES = /* @__PURE__ */ new Set(["string", "number", "bool", "dat
 var VALID_UPDATE_TYPES = /* @__PURE__ */ new Set(["user_set", "user_setOnce", "user_add"]);
 var SNAKE_CASE_RE = /^[a-z][a-z0-9_]*$/;
 var PROP_NAME_RE = /^[a-zA-Z#][a-zA-Z0-9_.]*$/;
+var MIN_COL_WIDTH = 10;
+var PADDING = 3;
+function isWideChar(code) {
+  return code >= 19968 && code <= 40959 || // CJK Unified Ideographs
+  code >= 13312 && code <= 19903 || // CJK Ext-A
+  code >= 12352 && code <= 12447 || // Hiragana
+  code >= 12448 && code <= 12543 || // Katakana
+  code >= 44032 && code <= 55215 || // Hangul
+  code >= 65280 && code <= 65519;
+}
+function displayWidth(s) {
+  let w = 0;
+  for (const ch of s) {
+    w += isWideChar(ch.charCodeAt(0)) ? 2 : 1;
+  }
+  return w;
+}
+function autoFitSheet(ws, maxWidth = 55) {
+  const colCount = ws.columnCount;
+  if (colCount === 0) return;
+  for (let i = 1; i <= colCount; i++) {
+    const col = ws.getColumn(i);
+    let maxDisplay = 0;
+    let needsWrap = false;
+    col.eachCell({ includeEmpty: false }, (cell) => {
+      const text = String(cell.value ?? "");
+      if (!text) return;
+      const dw = displayWidth(text);
+      if (dw > maxDisplay) maxDisplay = dw;
+    });
+    if (maxDisplay === 0) {
+      col.width = MIN_COL_WIDTH;
+      continue;
+    }
+    const capped = maxDisplay + PADDING > maxWidth;
+    col.width = Math.max(MIN_COL_WIDTH, Math.min(maxWidth, maxDisplay + PADDING));
+    if (capped) {
+      col.eachCell({ includeEmpty: false }, (cell) => {
+        cell.alignment = { ...cell.alignment, wrapText: true };
+      });
+    }
+  }
+}
 function validateDraft(d) {
   const errors = [];
   const eventNames = /* @__PURE__ */ new Set();
@@ -1027,7 +1197,26 @@ async function writeDraftXlsx(d, outPath, locale = "zh") {
     headerName("prop_desc", locale)
   ]);
   const propByName = new Map(d.event_properties.map((p) => [p.name, p]));
-  for (const evt of d.events) {
+  const autotrackEvents = d.events.filter((e) => e.source === "autotrack");
+  const businessEvents = d.events.filter((e) => e.source !== "autotrack");
+  const tagGroups = /* @__PURE__ */ new Map();
+  const tagOrder = [];
+  for (const evt of businessEvents) {
+    const tag = evt.event_tag || "";
+    if (!tagGroups.has(tag)) {
+      tagGroups.set(tag, []);
+      tagOrder.push(tag);
+    }
+    tagGroups.get(tag).push(evt);
+  }
+  tagOrder.sort((a, b) => getTagPriority(a) - getTagPriority(b));
+  const sorted = [...autotrackEvents];
+  for (const tag of tagOrder) {
+    for (const evt of tagGroups.get(tag)) {
+      sorted.push(evt);
+    }
+  }
+  for (const evt of sorted) {
     const startRow = eventSheet.rowCount + 1;
     const platformStr = evt.platform ? PLATFORM_TO_XLSX[evt.platform] : "";
     if (evt.prop_names.length === 0) {
@@ -1062,9 +1251,17 @@ async function writeDraftXlsx(d, outPath, locale = "zh") {
         for (const col of ["A", "B", "C", "D", "E"]) {
           eventSheet.mergeCells(`${col}${startRow}:${col}${endRow}`);
         }
+        for (let r = startRow; r <= endRow; r++) {
+          const row = eventSheet.getRow(r);
+          for (const col of ["A", "B", "C", "D", "E"]) {
+            const cell = row.getCell(col);
+            cell.alignment = { ...cell.alignment, vertical: "middle" };
+          }
+        }
       }
     }
   }
+  autoFitSheet(eventSheet, 50);
   const commonSheet = workbook.addWorksheet(sheetName("common_props", locale));
   commonSheet.addRow([
     headerName("common_prop_name", locale),
@@ -1080,6 +1277,7 @@ async function writeDraftXlsx(d, outPath, locale = "zh") {
       prop.desc ?? ""
     ]);
   }
+  autoFitSheet(commonSheet, 50);
   const userSheet = workbook.addWorksheet(sheetName("user_data", locale));
   userSheet.addRow([
     headerName("user_prop_name", locale),
@@ -1100,6 +1298,7 @@ async function writeDraftXlsx(d, outPath, locale = "zh") {
       prop.prop_tag ?? ""
     ]);
   }
+  autoFitSheet(userSheet, 50);
   const userIdSheet = workbook.addWorksheet(sheetName("user_id", locale));
   userIdSheet.addRow([
     headerName("user_id_prop_name", locale),
@@ -1109,13 +1308,14 @@ async function writeDraftXlsx(d, outPath, locale = "zh") {
   ]);
   userIdSheet.addRow(["#account_id", t("user_id.account_id_display", {}, locale), t("user_id.system_property", {}, locale), t("user_id.set_to", { field: d.meta.user_identity?.account_id_field ?? "account ID" }, locale)]);
   userIdSheet.addRow(["#distinct_id", t("user_id.distinct_id_display", {}, locale), t("user_id.system_property", {}, locale), t("user_id.auto_generated", {}, locale)]);
+  autoFitSheet(userIdSheet, 50);
   await workbook.xlsx.writeFile(outPath);
 }
 
 // src/core/tracking-client.ts
 var DEBUG_BASE = "/v1/ta/bury/manage/debug";
 var TRACK_LOCAL_HOST = "http://localhost:8992";
-var TRACK_CAPABILITY_DOMAIN = "";
+var TRACK_CAPABILITY_DOMAIN = "analysis";
 var TRACK_PROGRAM_QUERY = "track.program.query";
 var TRACK_PROGRAM_DELETE = "track.program.delete";
 var TRACK_PROGRAM_EXCEL_SAVE = "track.program.excel_save";
@@ -1307,8 +1507,8 @@ var TrackingClient = class {
     }
     return env;
   }
-  async debugGet(path5, params) {
-    const data = await this.requestJson(`${DEBUG_BASE}${path5}`, { ...params, "@t": Date.now() });
+  async debugGet(path4, params) {
+    const data = await this.requestJson(`${DEBUG_BASE}${path4}`, { ...params, "@t": Date.now() });
     return data;
   }
   async listDevice(projectId) {
@@ -1334,7 +1534,7 @@ var TrackingClient = class {
   }
 };
 async function createTrackingClient(host) {
-  return new TrackingClient(TRACK_LOCAL_HOST);
+  return new TrackingClient(host || TRACK_LOCAL_HOST);
 }
 
 // src/tracking/te-plan/fetch.ts
@@ -1384,8 +1584,8 @@ function normalize2(data) {
 }
 
 // src/tracking/plan/draft.ts
-import fs2 from "fs";
-import path2 from "path";
+import fs from "fs";
+import path from "path";
 
 // src/tracking/plan/autotrack.ts
 var TAG = {
@@ -1713,6 +1913,43 @@ function fixDisplayNameDuplicates(draft) {
   }
   return fixed;
 }
+function fixCrossPoolDisplayNameInconsistency(draft) {
+  const fixed = [];
+  const commonProps = draft.common_event_properties ?? [];
+  const eventProps = draft.event_properties ?? [];
+  for (const cp2 of commonProps) {
+    if (!cp2.display_name) continue;
+    const ep = eventProps.find((p) => p.name === cp2.name);
+    if (!ep) continue;
+    if (ep.display_name && ep.display_name !== cp2.display_name) {
+      const oldName = ep.display_name;
+      ep.display_name = cp2.display_name;
+      fixed.push(
+        `Aligned display_name for "${cp2.name}" in event_properties: "${oldName}" \u2192 "${cp2.display_name}" (from common_event_properties)`
+      );
+    }
+  }
+  return fixed;
+}
+function fixEventPlatforms(draft) {
+  const fixed = [];
+  const mode = draft.meta.sdk_integration_mode;
+  if (mode !== "client_only" && mode !== "server_only") return fixed;
+  const targetPlatform = mode === "client_only" ? "client" : "server";
+  let count = 0;
+  for (const event of draft.events) {
+    if (!event.platform) {
+      event.platform = targetPlatform;
+      count++;
+    }
+  }
+  if (count > 0) {
+    fixed.push(
+      `Auto-filled platform="${targetPlatform}" for ${count} event(s) based on sdk_integration_mode="${mode}"`
+    );
+  }
+  return fixed;
+}
 function fixEventPropNameInvalid(draft, errors) {
   const invalidNames = /* @__PURE__ */ new Set();
   for (const error of errors) {
@@ -1790,6 +2027,14 @@ function validateAndFix(draft) {
   if (displayFixes.length > 0) {
     fixed.push(t("fix.display_name_dedup"));
   }
+  const crossPoolFixes = fixCrossPoolDisplayNameInconsistency(draft);
+  if (crossPoolFixes.length > 0) {
+    fixed.push(`Cross-pool display_name consistency: ${crossPoolFixes.length} property(s) aligned`);
+  }
+  const platformFixes = fixEventPlatforms(draft);
+  if (platformFixes.length > 0) {
+    fixed.push(...platformFixes);
+  }
   const compositeChildren = /* @__PURE__ */ new Map();
   const evProps = draft.event_properties ?? draft.common_properties ?? [];
   for (const prop of evProps) {
@@ -1947,10 +2192,13 @@ async function listTrackingTemplates() {
     for (const f of entries) {
       if (!f.endsWith(".xlsx")) continue;
       const base = f.replace(/\.xlsx$/i, "");
+      const xlsxPath = resolve(dir, f);
       const mdPath = resolve(dir, base + ".md");
       const hasMd = existsSync3(mdPath);
       found.push({
-        path: hasMd ? mdPath : resolve(dir, f),
+        path: hasMd ? mdPath : xlsxPath,
+        xlsxPath,
+        ...hasMd ? { mdPath } : {},
         name: base,
         hasMd
       });
@@ -1984,23 +2232,23 @@ function resolveTrackingHost(program2, opts) {
   }
   return host;
 }
-function isExistingDirectory(path5) {
-  if (!existsSync4(path5)) return false;
+function isExistingDirectory(path4) {
+  if (!existsSync4(path4)) return false;
   try {
-    return statSync(path5).isDirectory();
+    return statSync(path4).isDirectory();
   } catch {
     return false;
   }
 }
-function assertOutputFilePath(path5, optionName = "--out") {
-  const trimmed = path5.trim();
+function assertOutputFilePath(path4, optionName = "--out") {
+  const trimmed = path4.trim();
   if (trimmed.endsWith("/") || trimmed.endsWith("\\") || isExistingDirectory(trimmed)) {
     console.error(t("error.output_path_is_directory", { path: trimmed, option: optionName }));
     process.exit(1);
   }
 }
-function assertInputFilePath(path5, optionName = "--in") {
-  const trimmed = path5.trim();
+function assertInputFilePath(path4, optionName = "--in") {
+  const trimmed = path4.trim();
   if (!existsSync4(trimmed)) {
     console.error(t("error.input_path_not_found", { path: trimmed, option: optionName }));
     process.exit(1);
@@ -2070,7 +2318,7 @@ function registerPlan(cmd, rootProgram) {
       console.log(t("plan.validate_passed"));
     } catch (e) {
       const errorMsg = e instanceof Error ? e.message : String(e);
-      console.log(t("plan.validate_failed") + "\n" + errorMsg);
+      console.error(t("plan.validate_failed") + "\n" + errorMsg);
       if (opts.fix) {
         console.log("\n" + t("plan.attempting_auto_fix") + "...");
         const fixed = validateAndFix(draft);
@@ -2082,11 +2330,15 @@ function registerPlan(cmd, rootProgram) {
             validateDraft(draft);
             console.log(t("plan.validate_passed_after_fix"));
           } catch (e2) {
-            console.log(t("plan.validate_still_errors_after_fix", { error: e2 instanceof Error ? e2.message : String(e2) }));
+            console.error(t("plan.validate_still_errors_after_fix", { error: e2 instanceof Error ? e2.message : String(e2) }));
+            process.exitCode = 1;
           }
         } else {
           console.log(t("plan.no_auto_fix_available"));
+          process.exitCode = 1;
         }
+      } else {
+        process.exitCode = 1;
       }
     }
   });
@@ -2147,7 +2399,7 @@ function registerPlan(cmd, rootProgram) {
       lastRes = await client.uploadProgramExcel({
         projectId: opts.project,
         file,
-        filename: path3.basename(opts.xlsx),
+        filename: path2.basename(opts.xlsx),
         lang: locale
       });
       console.log(JSON.stringify(lastRes, null, 2));
@@ -2352,7 +2604,7 @@ async function detectProject(cwd) {
 
 // src/tracking/xlsx/read.ts
 import XLSXMod from "xlsx";
-import path4 from "path";
+import path3 from "path";
 var XLSX = XLSXMod.default ?? XLSXMod;
 var VALID_PROP_TYPES2 = /* @__PURE__ */ new Set(["string", "number", "bool", "datetime", "object", "array_row", "array_string"]);
 var VALID_UPDATE_TYPES2 = /* @__PURE__ */ new Set(["user_set", "user_setOnce", "user_add"]);
@@ -2639,6 +2891,22 @@ function parseUserDataSheet(rows, source, sheetName2) {
   }
   return props;
 }
+function fillDownMergedCells(rows, merges) {
+  for (const merge of merges) {
+    const { s, e } = merge;
+    const topLeftValue = rows[s.r]?.[s.c];
+    if (topLeftValue === null || topLeftValue === void 0) continue;
+    for (let r = s.r; r <= e.r; r++) {
+      if (!rows[r]) continue;
+      for (let c = s.c; c <= e.c; c++) {
+        if (r === s.r && c === s.c) continue;
+        if (rows[r][c] === null || rows[r][c] === void 0) {
+          rows[r][c] = topLeftValue;
+        }
+      }
+    }
+  }
+}
 async function readTemplateXlsx(filePath) {
   let wb;
   try {
@@ -2646,7 +2914,7 @@ async function readTemplateXlsx(filePath) {
   } catch (err) {
     throw new Error(t("error.xlsx_read_failed", { path: filePath, error: String(err) }));
   }
-  const planName = path4.basename(filePath, path4.extname(filePath));
+  const planName = path3.basename(filePath, path3.extname(filePath));
   const source = "template";
   let events = [];
   let event_properties = [];
@@ -2661,6 +2929,10 @@ async function readTemplateXlsx(filePath) {
       raw: false,
       defval: null
     });
+    const merges = ws["!merges"];
+    if (merges && merges.length > 0) {
+      fillDownMergedCells(rows, merges);
+    }
     if (allSheetNames("event_data").includes(sName)) {
       const result = parseEventSheet(rows, source, sName);
       events = result.events;
@@ -2942,6 +3214,9 @@ function registerCode(cmd) {
     const templatePath = opts.templateName ? (await resolveTrackingTemplateByName(opts.templateName)).path : opts.template;
     assertInputFilePath(templatePath, opts.templateName ? "--template-name" : "--template");
     const draft = templatePath.endsWith(".md") ? await readTemplateMd(templatePath) : await readTemplateXlsx(templatePath);
+    if (!templatePath.endsWith(".md") && draft.events.length === 0) {
+      process.stderr.write(t("code.xlsx_import_empty_warning", { path: templatePath }) + "\n");
+    }
     const inferredMode = inferSdkMode(draft.events);
     if (inferredMode) {
       draft.meta.sdk_integration_mode = inferredMode;
@@ -3069,11 +3344,19 @@ function registerLang(cmd, _rootProgram) {
 
 // src/commands/tracking/index.ts
 function registerTracking(program2) {
-  const tracking = program2.command("tracking").description("AE tracking plan lifecycle (xlsx, debug, wiki)");
-  registerPlan(tracking.command("plan"), program2);
-  registerCode(tracking.command("code"));
-  registerWiki(tracking.command("wiki"));
-  registerLang(tracking.command("lang"), program2);
+  const tracking = getOrCreateCommand(program2, "tracking", "AE tracking plan lifecycle (xlsx, debug, wiki)");
+  registerPlan(getOrCreateCommand(tracking, "plan", "manage AE tracking plans"), program2);
+  registerCode(getOrCreateCommand(tracking, "code", "tracking code commands"));
+  registerWiki(getOrCreateCommand(tracking, "wiki", "tracking wiki commands"));
+  registerLang(getOrCreateCommand(tracking, "lang", "tracking language commands"), program2);
+}
+function getOrCreateCommand(parent, name, description) {
+  const existing = parent.commands.find((command) => command.name() === name);
+  if (existing) {
+    existing.description(description);
+    return existing;
+  }
+  return parent.command(name).description(description);
 }
 
 // src/index.ts
@@ -3093,52 +3376,52 @@ program.name("ae-cli").version(version).description("CLI tool for ThinkingAI (AE
 async function loadCommands() {
   const commands = [];
   try {
-    const teAnalysis = await import("./te-analysis-PUVF5IF4.js");
+    const teAnalysis = await import("./te-analysis-Q7AZCDU4.js");
     commands.push(...teAnalysis.default);
   } catch {
   }
   try {
-    const teMeta = await import("./te-meta-UUROEODR.js");
+    const teMeta = await import("./te-meta-VHCN4Q62.js");
     commands.push(...teMeta.default);
   } catch {
   }
   try {
-    const teCommon = await import("./te-common-VUX3VOXZ.js");
+    const teCommon = await import("./te-common-ST3QPSXJ.js");
     commands.push(...teCommon.default);
   } catch {
   }
   try {
-    const engage = await import("./te-engage-QBCCME22.js");
+    const engage = await import("./te-engage-BMJ6UOUU.js");
     commands.push(...engage.default);
   } catch {
   }
   try {
-    const community = await import("./te-community-TSKJ652U.js");
+    const community = await import("./te-community-X2AHXGCA.js");
     commands.push(...community.default);
   } catch {
   }
   try {
-    const dataops = await import("./te-dataops-F36T656A.js");
+    const dataops = await import("./te-dataops-OA7I6HBG.js");
     commands.push(...dataops.default);
   } catch {
   }
   try {
-    const teKb = await import("./te-kb-AYCODNU6.js");
+    const teKb = await import("./te-kb-E7NSCBRB.js");
     commands.push(...teKb.default);
   } catch {
   }
   try {
-    const teTeam = await import("./te-team-OKCOX7OE.js");
+    const teTeam = await import("./te-team-PDKKW7Q5.js");
     commands.push(...teTeam.default);
   } catch {
   }
   try {
-    const teAgent = await import("./te-agent-FCCWUDTJ.js");
+    const teAgent = await import("./te-agent-K2OWMZXT.js");
     commands.push(...teAgent.default);
   } catch {
   }
   try {
-    const metadata = await import("./metadata-FCLDBXX2.js");
+    const metadata = await import("./metadata-3M5F2AED.js");
     commands.push(...metadata.default);
   } catch {
   }
@@ -3146,48 +3429,50 @@ async function loadCommands() {
 }
 async function registerAuthCommands() {
   try {
-    const { registerAuth } = await import("./auth-7H3HAAJ3.js");
+    const { registerAuth } = await import("./auth-UPGUOKTW.js");
     registerAuth(program);
   } catch {
   }
 }
 async function registerConfigCommands() {
   try {
-    const { registerConfig } = await import("./config-7UZWDE74.js");
+    const { registerConfig } = await import("./config-RCCGHHYA.js");
     registerConfig(program);
   } catch {
   }
 }
 async function registerApiCommand() {
   try {
-    const { registerApi } = await import("./raw-CN542NGT.js");
+    const { registerApi } = await import("./raw-TPB7KSZO.js");
     registerApi(program);
   } catch {
   }
 }
 async function registerCapabilityCommands() {
   try {
-    const { registerCapability } = await import("./capability-SCRFGODD.js");
+    const { registerCapability } = await import("./capability-AJC5CBRT.js");
     registerCapability(program);
   } catch {
   }
 }
 async function registerSyncCommand() {
   try {
-    const { registerSync } = await import("./sync-ERNHDPB5.js");
+    const { registerSync } = await import("./sync-EFJKFZK2.js");
     registerSync(program);
   } catch {
   }
 }
 async function registerModelCommand() {
   try {
-    const { registerModel } = await import("./model-T3KZJWLW.js");
+    const { registerModel } = await import("./model-OYQLXCQY.js");
     registerModel(program);
   } catch {
   }
 }
 async function main() {
+  const pkgInfo = getLocalCliPackageInfo();
   notifyIfUpdateAvailable({ name: pkg.name, version: pkg.version });
+  await runHostCompatCheck(pkgInfo);
   const commands = await loadCommands();
   registerCommands(program, commands);
   await registerAuthCommands();