@lark-apaas/miaoda-cli 0.1.22 → 0.1.24

package/dist/services/deploy/modern/patch/source-scan.js

@@ -0,0 +1,58 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EXCLUDES = void 0;
+exports.listSourceFiles = listSourceFiles;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+// 与模板 scripts/build.sh 的 rsync EXCLUDES 对齐：这些名字（任意层级 basename）不进产物/不计入路由。
+exports.EXCLUDES = new Set([
+    '.git',
+    'node_modules',
+    'dist',
+    'scripts',
+    'package.json',
+    'package-lock.json',
+    'pnpm-lock.yaml',
+    'yarn.lock',
+    '.gitignore',
+    '.npmrc',
+    '.agent',
+    '.agents',
+    'skills',
+    '.env',
+    '.env.local',
+    'README.md',
+    '.DS_Store',
+    '.spark',
+]);
+/**
+ * 递归列出 root 下所有文件的相对 posix 路径，跳过 EXCLUDES（任意层级 basename），
+ * 用 statSync 判定目录/文件以 follow 符号链接（含指向目录的软链），断链等无法 stat 的条目跳过。
+ */
+function listSourceFiles(root) {
+    const out = [];
+    const walk = (dir, rel) => {
+        for (const entry of node_fs_1.default.readdirSync(dir, { withFileTypes: true })) {
+            if (exports.EXCLUDES.has(entry.name))
+                continue;
+            const childRel = rel ? `${rel}/${entry.name}` : entry.name;
+            const abs = node_path_1.default.join(dir, entry.name);
+            let isDir;
+            try {
+                isDir = node_fs_1.default.statSync(abs).isDirectory();
+            }
+            catch {
+                continue;
+            }
+            if (isDir)
+                walk(abs, childRel);
+            else
+                out.push(childRel);
+        }
+    };
+    walk(root, '');
+    return out;
+}

package/dist/services/deploy/modern/pipelines/design-local.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.designLocalPublishPipeline = designLocalPublishPipeline;
+const spark_meta_1 = require("../../../../utils/spark-meta");
+const error_1 = require("../../../../utils/error");
+const logger_1 = require("../../../../utils/logger");
+const index_1 = require("../atoms/index");
+/**
+ * design（design_local_deploy）本地构建 + 本地部署 pipeline。
+ *
+ * 与 client 版差异：build 走 buildDesignOutput（CLI 闭环，不跑 npm run build）、upload 走 uploadDesignArtifacts（version+latest
+ * 双写、latest 精确镜像）、不注册插件能力（design-html 无 capability）。其余复用同一套 atom。
+ */
+async function designLocalPublishPipeline(opts) {
+    const ctx = (0, index_1.prepareDeployContext)(opts.projectDir, opts.appId);
+    (0, logger_1.log)('deploy', 'Pre-releasing...');
+    const pre = await (0, index_1.preRelease)(ctx.appId, ctx.templateKey);
+    (0, logger_1.log)('deploy', `pre_release_id=${pre.preReleaseID} version=${pre.version}`);
+    if (pre.data === undefined) {
+        throw new error_1.AppError('DEPLOY_PRE_RELEASE_DATA_MISSING', 'preRelease did not return a `data` map — backend tcc may not be configured for current template_key');
+    }
+    const data = pre.data;
+    // dist 是本地构建产物，部署动作结束（无论成败）都清掉，不在用户项目里留产物。
+    try {
+        if (!opts.skipBuild) {
+            (0, index_1.buildDesignOutput)({ projectDir: ctx.projectDir });
+        }
+        (0, logger_1.log)('deploy', 'Creating local release...');
+        const release = await (0, index_1.createLocalRelease)(ctx.appId, pre.version, {
+            checkPointVersion: opts.checkPointVersion,
+            commitID: opts.commitID,
+        });
+        try {
+            await (0, index_1.uploadDesignArtifacts)({ projectDir: ctx.projectDir, data });
+            await (0, index_1.finalizeLocalRelease)(ctx.appId, release.releaseID, index_1.LocalReleaseStatus.Finished);
+        }
+        catch (err) {
+            await (0, index_1.finalizeLocalRelease)(ctx.appId, release.releaseID, index_1.LocalReleaseStatus.Failed);
+            throw err;
+        }
+        if (release.onlineUrl !== undefined && release.onlineUrl !== '') {
+            (0, spark_meta_1.writeSparkMeta)(ctx.projectDir, { appUrl: release.onlineUrl });
+        }
+        (0, logger_1.log)('deploy', 'Deployed successfully');
+        return {
+            appId: ctx.appId,
+            version: pre.version,
+            url: release.onlineUrl ?? '',
+            releaseID: release.releaseID,
+            preReleaseID: pre.preReleaseID,
+        };
+    }
+    finally {
+        (0, index_1.cleanDesignDist)(ctx.projectDir);
+    }
+}

package/dist/services/deploy/modern/pipelines/index.js

@@ -1,5 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.localBuildLocalPublishPipeline = void 0;
+exports.designLocalPublishPipeline = exports.localBuildLocalPublishPipeline = void 0;
 var local_1 = require("./local");
 Object.defineProperty(exports, "localBuildLocalPublishPipeline", { enumerable: true, get: function () { return local_1.localBuildLocalPublishPipeline; } });
+var design_local_1 = require("./design-local");
+Object.defineProperty(exports, "designLocalPublishPipeline", { enumerable: true, get: function () { return design_local_1.designLocalPublishPipeline; } });

package/dist/services/deploy/modern/protocol.js

@@ -33,6 +33,13 @@ exports.DataKey = {
     // downloadURLPrefix 替代原 static_cdn_prefix 注入 build env。
     /** dist/output_static 上传凭证（仅当目录存在时使用） */
     OUTPUT_STATIC_PAAS_STORAGE_CREDENTIAL: 'output_static_paas_storage_credential',
+    // ── design 部署专用（design_local_deploy） ──
+    /** 覆盖整个 {app_id} 文件夹的上传凭证（形态同 TosUploadCredential） */
+    OUTPUT_ALL_TOS_UPLOAD_CREDENTIAL: 'output_all_tos_upload_credential',
+    /** version/备份份真实路径（后端已替换 {app_id}/{version}） */
+    OUTPUT_BACKUP_PATH: 'output_backup_path',
+    /** latest 份真实路径（后端已替换 {app_id}/latest） */
+    OUTPUT_LATEST_PATH: 'output_latest_path',
 };
 /** 取必传 key，缺失抛 AppError（带 key 名，便于后端 tcc 配置排查） */
 function requireDataKey(data, key) {

package/dist/services/deploy/modern/run.js

@@ -1,13 +1,19 @@
 "use strict";
 // modern deploy 主入口（dispatch 层）。
 //
-// 当前阶段（Scope A）只接入"本地构建 + 本地部署"一条 pipeline；
-// 后续接入"本地构建 + 远端部署 / 远端构建 + 远端部署"时，在此处按 template_key
-// 或显式 flag 选不同 pipeline。pipeline 之间彼此独立、不共享中间状态。
+// 按 templateKey 选 pipeline：design_local_deploy → design pipeline，其余 → client pipeline。
+// 仅为路由轻量解析 templateKey（读 meta.stack + 映射），不跑前置检查——前置检查在各
+// pipeline 内部的 prepareDeployContext 里做。client 分支与原行为完全一致。
+// pipeline 之间彼此独立、不共享中间状态。
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.runModernDeploy = runModernDeploy;
+const spark_meta_1 = require("../../../utils/spark-meta");
+const template_key_map_1 = require("./template-key-map");
 const index_1 = require("./pipelines/index");
 async function runModernDeploy(opts) {
-    // 暂只支持本地构建 + 本地部署
+    const stack = (0, spark_meta_1.readSparkMeta)(opts.projectDir).stack ?? '';
+    if ((0, template_key_map_1.resolveTemplateKey)(stack) === template_key_map_1.DESIGN_LOCAL_DEPLOY) {
+        return (0, index_1.designLocalPublishPipeline)(opts);
+    }
     return (0, index_1.localBuildLocalPublishPipeline)(opts);
 }

package/dist/services/deploy/modern/template-key-map.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.DESIGN_LOCAL_DEPLOY = void 0;
 exports.resolveTemplateKey = resolveTemplateKey;
 /**
  * 本地 stack 短名 → 后端发布模板 key 的映射。
@@ -10,9 +11,12 @@ exports.resolveTemplateKey = resolveTemplateKey;
  * 未来出现需要走别的 templateKey 的 stack，再在表里加一行覆盖默认。
  */
 const DEFAULT_TEMPLATE_KEY = 'client_local_deploy';
+/** design 部署 templateKey（run.ts 据此分流到 design pipeline） */
+exports.DESIGN_LOCAL_DEPLOY = 'design_local_deploy';
 const TEMPLATE_KEY_MAP = {
     'vite-react': DEFAULT_TEMPLATE_KEY,
     html: DEFAULT_TEMPLATE_KEY,
+    'design-html': exports.DESIGN_LOCAL_DEPLOY,
 };
 /**
  * 把本地 stack 短名映射到后端 templateKey；未配置的 stack 走默认 client_local_deploy。

package/dist/services/registry/index.js

@@ -0,0 +1,293 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.REGISTRY_SUPPORTED_STACKS = exports.REGISTRY_BY_RUNTIME = exports.STACK_RUNTIME = void 0;
+exports.resolveRegistryPackage = resolveRegistryPackage;
+exports.loadRegistry = loadRegistry;
+exports.extractUsageBlock = extractUsageBlock;
+exports.parseDependsOn = parseDependsOn;
+exports.tokenMatches = tokenMatches;
+exports.resolveDependencyClosure = resolveDependencyClosure;
+exports.planAdd = planAdd;
+exports.applyAdd = applyAdd;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const npm_pack_1 = require("../../utils/npm-pack");
+const error_1 = require("../../utils/error");
+const logger_1 = require("../../utils/logger");
+/**
+ * 解析链：stack → runtime → registry 包名。
+ *
+ * registry 包按 **运行时（runtime）** 命名分发（而非 stack）：多个 stack 可共享同一 runtime
+ * 的同一份 registry。runtime 不引入新的 meta 字段，从已有的 `.spark/meta.json.stack` 推得。
+ *   STACK_RUNTIME:        stack → runtime（design-html 跑在 buildless 运行时）
+ *   REGISTRY_BY_RUNTIME:  runtime → registry 包名
+ * 任一步查不到都明确报错（stack 无对应 runtime / runtime 无对应 registry）。
+ */
+exports.STACK_RUNTIME = {
+    'design-html': 'buildless',
+};
+exports.REGISTRY_BY_RUNTIME = {
+    buildless: '@lark-apaas/coding-registry-buildless',
+};
+/** 有对应 registry 的 stack 列表（stack 有 runtime 且该 runtime 有 registry 包）。 */
+exports.REGISTRY_SUPPORTED_STACKS = Object.keys(exports.STACK_RUNTIME).filter((stack) => Boolean(exports.REGISTRY_BY_RUNTIME[exports.STACK_RUNTIME[stack]]));
+/**
+ * stack → registry 包名。走 STACK_RUNTIME → REGISTRY_BY_RUNTIME 两跳。
+ * stack 无对应 runtime，或 runtime 无对应 registry，均抛 AppError。
+ */
+function resolveRegistryPackage(stack) {
+    const runtime = exports.STACK_RUNTIME[stack];
+    if (!runtime) {
+        throw new error_1.AppError('REGISTRY_STACK_UNSUPPORTED', `stack "${stack}" 没有对应的 runtime`, {
+            next_actions: [`支持 registry 的 stack：${exports.REGISTRY_SUPPORTED_STACKS.join(', ') || '(none)'}`],
+        });
+    }
+    const packageName = exports.REGISTRY_BY_RUNTIME[runtime];
+    if (!packageName) {
+        throw new error_1.AppError('REGISTRY_RUNTIME_UNSUPPORTED', `runtime "${runtime}"（来自 stack "${stack}"）没有对应的 registry 包`);
+    }
+    return packageName;
+}
+const USAGE_BEGIN = '/* BEGIN USAGE */';
+const USAGE_END = '/* END USAGE */';
+/**
+ * 拉取并解析某 stack 的 registry 包。
+ *
+ * 复用 fetchNpmPackage（npm pack + tar -xzf + 临时目录），与 template / steering 同一套
+ * tarball 基建。包内布局约定（SDK 文件**平铺在包根**，无外层 registry/ 目录）：
+ *   package/<subdir>/<sdk-file>    ← 按目录组织的 SDK 文件，每个以 USAGE 块开头
+ *     （scripts/ · components/ · stylesheets/ 等；CLI 不约束子目录名）
+ *
+ * 从包根递归扫整棵树，判定含 USAGE 块的为 SDK 条目（package.json / README / LICENSE 等无
+ * USAGE 块的文件自然跳过），解析其 USAGE 原文 + Depends。
+ * 调用方用完 **必须** 调 result.cleanup() 清理临时目录。
+ */
+function loadRegistry(opts) {
+    const packageName = resolveRegistryPackage(opts.stack);
+    const effectiveVersion = opts.version ?? 'latest';
+    (0, logger_1.log)('registry', `Fetching ${packageName}@${effectiveVersion}...`);
+    const fetched = (0, npm_pack_1.fetchNpmPackage)({ packageName, version: effectiveVersion });
+    try {
+        // 扫描根 = 包根（fetchNpmPackage 的 extractDir 即 tarball 内 package/ 目录）
+        const registryRoot = fetched.extractDir;
+        const entries = scanEntries(registryRoot);
+        return {
+            entries,
+            registryRoot,
+            version: fetched.version,
+            cleanup: () => {
+                fetched.cleanup();
+            },
+        };
+    }
+    catch (err) {
+        fetched.cleanup();
+        throw err;
+    }
+}
+/**
+ * 可作为 SDK 条目的代码文件扩展名白名单。
+ * 只扫代码文件 —— README.md / LICENSE / package.json 等不在此列，避免文档里出现的
+ * USAGE 字面量（如 README 解释 `/* BEGIN USAGE *​/` 格式）被误判为 SDK 条目。
+ */
+const SDK_FILE_EXTENSIONS = new Set(['.js', '.jsx', '.mjs', '.cjs', '.ts', '.tsx', '.css']);
+/**
+ * 条目所在的顶层目录白名单。只有包根下这几个目录（任意深度）里的代码文件才算条目，
+ * 包根直放的文件（eslint.config.js 等）、其它顶层目录（lib/ 等）一律排除——
+ * 避免 USAGE 可选后把工程配置 / 非 SDK 代码误判为条目。
+ */
+const SDK_TOP_DIRS = new Set(['components', 'scripts', 'stylesheets']);
+/**
+ * 从包根递归扫整棵树，提取 SDK 条目。条目判据：
+ *   1. 在白名单顶层目录下（SDK_TOP_DIRS，任意深度）；
+ *   2. 是代码文件（SDK_FILE_EXTENSIONS）。
+ * USAGE 块**可选**：有则解析描述 + Depends，无则 usage 为空、dependsOn 为空——仍是条目。
+ * name（去扩展名 basename）**不要求唯一**：同名的不同文件全部收录为独立条目，由 relPath
+ * （树内唯一）区分；寻址 / 拉取由 tokenMatches + resolveDependencyClosure 处理（同名 → 全拉）。
+ */
+function scanEntries(registryRoot) {
+    const entries = [];
+    const walk = (dir) => {
+        for (const dirent of node_fs_1.default.readdirSync(dir, { withFileTypes: true })) {
+            const absPath = node_path_1.default.join(dir, dirent.name);
+            if (dirent.isDirectory()) {
+                walk(absPath);
+                continue;
+            }
+            if (!dirent.isFile())
+                continue;
+            // 只扫代码文件，排除 README/LICENSE/package.json 等非 SDK 文件
+            if (!SDK_FILE_EXTENSIONS.has(node_path_1.default.extname(dirent.name).toLowerCase()))
+                continue;
+            // 相对包根的路径，统一用 '/' 分隔（落地时再按平台 join）
+            const relPath = node_path_1.default.relative(registryRoot, absPath).split(node_path_1.default.sep).join('/');
+            // 只认白名单顶层目录下的文件（顶层段 ∈ SDK_TOP_DIRS）
+            if (!SDK_TOP_DIRS.has(relPath.split('/')[0]))
+                continue;
+            const usage = extractUsageBlock(node_fs_1.default.readFileSync(absPath, 'utf-8')) ?? '';
+            entries.push({
+                name: stripExt(dirent.name),
+                relPath,
+                usage,
+                dependsOn: parseDependsOn(usage),
+                absPath,
+            });
+        }
+    };
+    walk(registryRoot);
+    // 按 relPath（唯一）稳定排序，便于 list 输出可预期
+    entries.sort((a, b) => a.relPath.localeCompare(b.relPath));
+    return entries;
+}
+/** 提取 BEGIN/END USAGE 标记之间的原文（含标记行）。无 USAGE 块返回 null。 */
+function extractUsageBlock(content) {
+    const begin = content.indexOf(USAGE_BEGIN);
+    if (begin === -1)
+        return null;
+    const end = content.indexOf(USAGE_END, begin);
+    if (end === -1)
+        return null;
+    return content.slice(begin, end + USAGE_END.length);
+}
+/** 从 USAGE 块文本里解析 `// Depends: <name>` 行（可多行），返回去重后的依赖名列表。 */
+function parseDependsOn(usage) {
+    const deps = [];
+    const seen = new Set();
+    for (const line of usage.split(/\r?\n/)) {
+        const m = /^\s*\/\/\s*Depends:\s*(.+?)\s*$/.exec(line);
+        if (m === null)
+            continue;
+        // 一行内允许逗号 / 空白分隔多个依赖
+        for (const raw of m[1].split(/[\s,]+/)) {
+            const name = raw.trim();
+            if (name !== '' && !seen.has(name)) {
+                seen.add(name);
+                deps.push(name);
+            }
+        }
+    }
+    return deps;
+}
+function stripExt(file) {
+    const ext = node_path_1.default.extname(file);
+    return ext === '' ? file : file.slice(0, -ext.length);
+}
+/**
+ * 一个 token 是否命中某条目。token 可写三种寻址形式（按特异度，任一相等即命中）：
+ *   - relPath：相对包根路径，如 components/foo.jsx（含 '/'）
+ *   - 完整文件名：含扩展名的 basename，如 foo.jsx
+ *   - name：去扩展名的 basename，如 foo
+ * 三种形式无歧义重叠（relPath 含 '/'，basename 不含；完整文件名含原扩展名，name 不含），
+ * 故用一个等值谓词即可。多个条目可同时命中同一 token（同名 → 全拉），由调用方处理。
+ */
+function tokenMatches(entry, token) {
+    if (token === entry.relPath)
+        return true;
+    const fileName = entry.relPath.split('/').pop() ?? '';
+    if (token === fileName)
+        return true;
+    return token === entry.name;
+}
+/**
+ * 解析 Depends 的传递闭包：从 requested token 出发，递归把所有依赖一并纳入。
+ *
+ * token 经 tokenMatches 解析成**一组**条目（同名 → 全拉），逐个展开。返回拓扑序
+ * （依赖在前、被依赖在后），便于按序拷贝。token 零命中抛 REGISTRY_ENTRY_NOT_FOUND；
+ * 检测循环依赖并抛 REGISTRY_CYCLE。visited / onStack / 环检测均以 relPath（唯一）为键，
+ * 故同名（去扩展名）的不同文件互不干扰、不会误判成环。
+ */
+function resolveDependencyClosure(entries, requested) {
+    const ordered = [];
+    const visited = new Set(); // by relPath
+    const onStack = new Set(); // by relPath
+    // token → 命中条目集合；零命中 fail-fast（避免拷半套）
+    const resolveToken = (token, trail) => {
+        const matches = entries.filter((e) => tokenMatches(e, token));
+        if (matches.length === 0) {
+            const via = trail.length > 0 ? `（被 "${trail[trail.length - 1]}" 依赖）` : '';
+            throw new error_1.AppError('REGISTRY_ENTRY_NOT_FOUND', `registry 没有条目 "${token}"${via}`, {
+                next_actions: ['用 `miaoda registry list` 查看可用条目'],
+            });
+        }
+        return matches;
+    };
+    const visit = (entry, trail) => {
+        if (visited.has(entry.relPath))
+            return;
+        if (onStack.has(entry.relPath)) {
+            throw new error_1.AppError('REGISTRY_CYCLE', `registry 条目依赖成环：${[...trail, entry.relPath].join(' -> ')}`);
+        }
+        onStack.add(entry.relPath);
+        for (const depToken of entry.dependsOn) {
+            for (const depEntry of resolveToken(depToken, [...trail, entry.relPath])) {
+                visit(depEntry, [...trail, entry.relPath]);
+            }
+        }
+        onStack.delete(entry.relPath);
+        visited.add(entry.relPath);
+        ordered.push(entry);
+    };
+    for (const token of requested) {
+        for (const entry of resolveToken(token, []))
+            visit(entry, []);
+    }
+    return ordered;
+}
+/**
+ * 规划 add：解析依赖闭包 → 每个条目**拍平为 basename** 落到项目根 → 标记是否已存在。
+ * 纯计算，不落盘（dry-run 与真实 add 共用）。exists 在此快照（落盘前），故闭包内同名
+ * basename 撞车时双方 exists 都为 false、applyAdd 里后者覆盖前者。
+ */
+function planAdd(opts) {
+    const entries = resolveDependencyClosure(opts.entries, opts.names);
+    const files = entries.map((entry) => {
+        const dest = entry.relPath.split('/').pop() ?? entry.relPath; // 拍平为 basename
+        const destAbs = node_path_1.default.join(opts.targetDir, dest);
+        return {
+            entry: entry.name,
+            srcRelPath: entry.relPath,
+            dest,
+            destAbs,
+            srcAbs: entry.absPath,
+            exists: node_fs_1.default.existsSync(destAbs),
+        };
+    });
+    return { entries, files };
+}
+/**
+ * 执行 add 计划：把 SDK 文件**拍平**拷到项目根。
+ *   - 目标已存在且未 overwrite → skip（skip-by-disk 保护用户改动）
+ *   - 目标已存在且 overwrite → 覆盖写
+ *   - 目标不存在 → 写
+ * 闭包内同名 basename 撞车（双方 exists 均为 plan 前快照 false）→ 顺序拷贝、后者覆盖前者，
+ * added 去重只报一次。dryRun=true 时只分类不落盘。不写任何安装记账文件（项目文件树即状态）。
+ */
+function applyAdd(files, opts) {
+    const added = [];
+    const skipped = [];
+    const seen = new Set();
+    const pushUnique = (list, dest) => {
+        if (seen.has(dest))
+            return;
+        seen.add(dest);
+        list.push(dest);
+    };
+    for (const f of files) {
+        if (f.exists && !opts.overwrite) {
+            pushUnique(skipped, f.dest);
+            continue;
+        }
+        if (!opts.dryRun) {
+            if (!node_fs_1.default.existsSync(f.srcAbs)) {
+                throw new error_1.AppError('REGISTRY_FILE_MISSING', `registry 包内缺少文件 ${f.srcRelPath}（条目 "${f.entry}"）`);
+            }
+            node_fs_1.default.mkdirSync(node_path_1.default.dirname(f.destAbs), { recursive: true });
+            node_fs_1.default.copyFileSync(f.srcAbs, f.destAbs);
+        }
+        pushUnique(added, f.dest);
+    }
+    return { added, skipped };
+}

package/dist/utils/http.js

@@ -64,7 +64,7 @@ function createClient(opts) {
  * 默认灰度泳道。当前 miaoda CLI 接入的新接口（modern deploy 等）只在该泳道生效，
  * 缺省走这个。MIAODA_CANARY_HEADER 可显式覆盖；设为空字符串则去掉头。
  */
-const DEFAULT_CANARY_HEADER = 'boe_miaoda_doubao';
+const DEFAULT_CANARY_HEADER = 'boe_miaoda_ccm';
 /**
  * 注入 x-tt-env 小流量头：env 显式设值 > DEFAULT_CANARY_HEADER。
  *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lark-apaas/miaoda-cli",
-  "version": "0.1.22",
+  "version": "0.1.24",
   "description": "Miaoda 平台命令行工具，面向 Agent 调用",
   "type": "commonjs",
   "bin": {