@lark-apaas/miaoda-cli 0.1.29 → 0.1.31

package/dist/utils/sandbox-skills.js

@@ -0,0 +1,271 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractLaneFromTgzKey = extractLaneFromTgzKey;
+exports.syncSandboxSkills = syncSandboxSkills;
+exports.validateSandboxSyncOpts = validateSandboxSyncOpts;
+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");
+const file_ops_1 = require("../utils/file-ops");
+const PACKAGE_BY_TYPE = {
+    miaoda: '@lark-apaas/coding-miaoda-sandbox-skills',
+    'miaoda-modern': '@lark-apaas/coding-miaoda-sandbox-skills',
+    'miaoda-design': '@lark-apaas/coding-miaoda-sandbox-skills',
+    openclaw: '@lark-apaas/coding-openclaw-sandbox-skills',
+};
+/**
+ * 目标根目录下**永不删除**的控制文件（对齐 `update-skills.sh` 的删除白名单）：
+ *   - `.keep`        沙箱级「冻结 skills」开关，存在即整体跳过同步（见 {@link syncSandboxSkills}）
+ *   - `.config`      沙箱级 tgzKey 覆盖，feida-ai 的 `enableConfigFileOverride` 读它
+ *                    （`getKeepFileTgzKey` → `.agent/skills/.config`），删了会让版本钉死失效
+ *   - `.last-update` 同步时间戳，feida-ai freshness 检查读它；每轮末尾会重写，列进来只是语义完备
+ */
+const PRESERVED_ENTRIES = new Set(['.keep', '.config', '.last-update']);
+/** `.keep` 存在时整体跳过同步的标记文件名，语义同 `update-skills.sh:149`。 */
+const KEEP_FILE = '.keep';
+/**
+ * rsync 式对齐：删掉目标里「源包已不提供」的顶层条目，对齐 `update-skills.sh:196-218`。
+ *
+ * 与整目录清空的区别（后者是本函数取代的旧实现）：
+ *   - 保住 {@link PRESERVED_ENTRIES} 里的控制文件
+ *   - 保住 `steering/` 子树 —— 它由 handler 层的 syncCodingSteering 独占管理
+ *     （`update-skills.sh:207` 平铺型分支同样明确「归 miaoda CLI 管，update.sh 不删不覆盖」）
+ *
+ * 只处理顶层：源包内容本身就是「一个 skill 一个顶层目录」，逐文件比对没有额外收益。
+ */
+function pruneStaleEntries(skillsRoot, sourceTopEntries) {
+    if (!node_fs_1.default.existsSync(skillsRoot))
+        return [];
+    const deleted = [];
+    for (const entry of node_fs_1.default.readdirSync(skillsRoot)) {
+        if (PRESERVED_ENTRIES.has(entry) || entry === 'steering')
+            continue;
+        if (sourceTopEntries.has(entry))
+            continue;
+        const target = node_path_1.default.join(skillsRoot, entry);
+        try {
+            // forceRemove 的 chmod→rm -rf→rmSync 三层兜底对文件同样适用：
+            // 老 update.sh 以 root 跑过、且会 chmod -R 锁只读，直接 rmSync 会 EACCES
+            (0, file_ops_1.forceRemove)(target);
+            deleted.push(entry);
+        }
+        catch (err) {
+            (0, logger_1.debug)(`sandbox-skills: prune ${entry} failed: ${err.message}`);
+        }
+    }
+    return deleted;
+}
+// 合并包内的业务线子目录（miaoda / miaoda-modern / miaoda-design）；shared 单独处理。
+const BUSINESS_LINE_BY_TYPE = {
+    miaoda: 'miaoda',
+    'miaoda-modern': 'miaoda-modern',
+    'miaoda-design': 'miaoda-design',
+    openclaw: null, // openclaw 独立包，直接展平
+};
+/**
+ * 从 TCC skillsUpdateTgzKey 反推 lane 名。
+ *   skills_versions/all_feat-xxx.tgz  → feat-xxx
+ *   skills_versions/all_feat_xxx.tgz  → feat-xxx  (_ sanitize → -)
+ *   skills_versions/all_latest.tgz    → null（走 @latest）
+ *   任何 all_<X>.tgz                  → <X> 里 _ 全部转 -
+ *
+ * **宽进严出**：正则允许 `_` 匹配（兼容老 miaoda-skills 时代 TOS key 含 `_` 的存量 TCC
+ * 命名），但返回时 sanitize 成 `-` —— 对齐 publish-sandbox-skills.sh 侧只发 `-` 版
+ * lane 的现实（npm SemVer pre-release 只允许 `[A-Za-z0-9-]`，不允许 `_`）。
+ * 存量 TCC 里如果有 `all_feat_xxx.tgz` 这种命名，反推出 `feat-xxx` 后能正确命中
+ * npm 上实际发出的 `@lane-feat-xxx` 包，而不是静默 fallback 到 @latest。
+ *
+ * 用 nullable 而不是空字符串 —— 让调用方能判断"没 lane 就走 latest"。
+ */
+function extractLaneFromTgzKey(tgzKey) {
+    if (tgzKey === undefined || tgzKey === '') {
+        return null;
+    }
+    const match = /(?:^|\/)all_([A-Za-z0-9][A-Za-z0-9_-]*)\.tgz$/.exec(tgzKey);
+    if (match === null) {
+        return null;
+    }
+    const lane = match[1].replace(/_/g, '-');
+    if (lane === 'latest') {
+        return null;
+    }
+    return lane;
+}
+/**
+ * 主流程：按 type 拉包 + sync 到目标目录。
+ *
+ * sync 策略：**rsync 式对齐**，逐条对应线上真实跑的 `update-skills.sh`（不是
+ * `cp-skills.sh`——那个脚本线上不执行，日志里的 `copied/skipped/deleted` 出自前者）：
+ *   1. 目标目录有 `.keep` → 整体跳过（`update-skills.sh:149`）
+ *   2. 覆盖式写入源包提供的顶层条目
+ *   3. 删掉源包已不提供的顶层条目（{@link pruneStaleEntries}），但保住
+ *      {@link PRESERVED_ENTRIES} 与 `steering/`
+ *
+ * 不用整目录清空：那会删掉 `.config`（沙箱级 tgzKey 覆盖）、`.keep`（冻结开关）
+ * 和 handler 层刚写的 `steering/`，而老链路对这三者都有保护。
+ */
+function syncSandboxSkills(opts) {
+    const targetDir = node_path_1.default.resolve(opts.targetDir ?? process.cwd());
+    const packageName = PACKAGE_BY_TYPE[opts.type];
+    const businessLine = BUSINESS_LINE_BY_TYPE[opts.type];
+    const lane = extractLaneFromTgzKey(opts.tgzKey);
+    // ---- lane 拉包 ----
+    // 新姿势（2026-08 迁离 lane-<X> dist-tag 之后）：
+    //   TCC 里的 X（比如 `feat-migrate-skills-from-miaoda-skills-20260805143512`）
+    //   包含 branch + timestamp，`pickLaneVersion` 走 `npm view <pkg> versions --json`
+    //   过滤 `endsWith('-alpha.' + X)`（因 X 含 timestamp 全局唯一，唯一命中或 0 命中）。
+    //   0 命中 → fallback @latest（对齐旧 TCC 值找不到、灰度切换期间的兜底语义）。
+    //   `pickLaneVersion` 内部对 `npm view` 报错 / 无匹配都返回 null，绝不 throw ——
+    //   目标就是"不挂掉"。
+    let fetched;
+    const laneVersion = lane === null ? null : (0, npm_pack_1.pickLaneVersion)(packageName, lane, opts.registry);
+    if (lane !== null && laneVersion === null) {
+        (0, logger_1.debug)(`sandbox-skills: no npm version matched -alpha.${lane}, fallback to @latest ` +
+            `(TCC 里的 X 可能是老 lane dist-tag 命名 / 已 unpublish / npm view 挂 / 网络断)`);
+    }
+    const primaryVersion = laneVersion ?? 'latest';
+    try {
+        (0, logger_1.debug)(`sandbox-skills: fetching ${packageName}@${primaryVersion}`);
+        fetched = (0, npm_pack_1.fetchNpmPackage)({
+            packageName,
+            version: primaryVersion,
+            registry: opts.registry,
+        });
+    }
+    catch (err) {
+        if (primaryVersion === 'latest') {
+            throw err;
+        }
+        (0, logger_1.debug)(`sandbox-skills: pack ${primaryVersion} failed, fallback to @latest (err: ${err.message})`);
+        fetched = (0, npm_pack_1.fetchNpmPackage)({
+            packageName,
+            version: 'latest',
+            registry: opts.registry,
+        });
+    }
+    try {
+        // 计算 skill 目标根目录：
+        //   - openclaw → <targetDir>/skills/（跟老 cp-skills.sh 的 openclaw 分支对齐，落 $WORKSPACE_DIR/agent/skills）
+        //   - 其它 →     <targetDir>/.agent/skills/
+        const skillsRoot = opts.type === 'openclaw'
+            ? node_path_1.default.join(targetDir, 'skills')
+            : node_path_1.default.join(targetDir, '.agent', 'skills');
+        // `.keep` 短路：对齐 update-skills.sh:149-152，沙箱侧放了这个文件即表示
+        // 「我手改过 skills，别覆盖我」，整体跳过同步（含 steering —— 调用方看到
+        // skipped 就不该再往下写）。
+        if (node_fs_1.default.existsSync(node_path_1.default.join(skillsRoot, KEEP_FILE))) {
+            (0, logger_1.debug)(`sandbox-skills: ${KEEP_FILE} found in ${skillsRoot}, skip sync`);
+            return {
+                packageName,
+                version: fetched.version,
+                lane,
+                syncedTop: [],
+                deleted: [],
+                skippedByKeepFile: true,
+                targetDir: skillsRoot,
+            };
+        }
+        // 写入前解锁，对齐 update-skills.sh:160-165：
+        //   上一轮同步末尾会 chmod -R a=rX 锁只读（见 file-ops 的 lockDirReadonly），
+        //   不先解锁，下面 fs.cpSync 覆盖已存在的 skill 目录必 EACCES。
+        // 只加 u+w（不动 g/o），与老链路一致；owner 是沙箱当前用户，无需 sudo。
+        (0, file_ops_1.unlockDirForWrite)(skillsRoot);
+        node_fs_1.default.mkdirSync(skillsRoot, { recursive: true });
+        const syncedTop = [];
+        // 源包提供的全部顶层条目 —— prune 的保留集。与 syncedTop 分开维护：syncedTop 是
+        // 「本轮实际写入」，用于对外汇报；prune 只能依据「源包提供了什么」来判断 stale，
+        // 两者一旦哪天再次分叉（比如某分支又加了跳过写入的条件），拿 syncedTop 当保留集
+        // 就会把没重写的条目误判成 stale 删掉、下一轮再写回来，反复抖动。
+        const sourceTop = new Set();
+        if (businessLine !== null) {
+            // 合并包 miaoda/miaoda-modern/miaoda-design：cp <extractDir>/<business-line>/* 到 target
+            const sourceDir = node_path_1.default.join(fetched.extractDir, businessLine);
+            if (node_fs_1.default.existsSync(sourceDir)) {
+                for (const entry of node_fs_1.default.readdirSync(sourceDir)) {
+                    const from = node_path_1.default.join(sourceDir, entry);
+                    const to = node_path_1.default.join(skillsRoot, entry);
+                    sourceTop.add(entry);
+                    node_fs_1.default.cpSync(from, to, { recursive: true });
+                    syncedTop.push(entry);
+                }
+            }
+            else {
+                (0, logger_1.debug)(`sandbox-skills: source dir ${sourceDir} not found in package (skipped)`);
+            }
+            // shared：合并包内 shared/* 到 target。**无条件覆盖**，逐字对齐老 build.sh:42-52 ——
+            // 那里业务线先 `cp -r`（:33-34）、shared 后 `cp -r`（:47），后写覆盖前写，
+            // 即同名时 **shared 赢**。当前包里两边无同名交集，但语义得跟老链路一致。
+            //
+            // 早期这里写成「`fs.existsSync(to)` 就 continue」，有两个问题：
+            //   1. 同名优先级反了（变成业务线赢）；
+            //   2. 更严重 —— existsSync 分不清「本轮业务线刚写的」和「上一轮 shared 自己写的」，
+            //      于是 shared skill 首次落盘后就永久冻结，包里再更新也同步不到已有沙箱
+            //      （沙箱磁盘跨会话保留，每次 update-skills 都会命中 existsSync）。
+            const sharedDir = node_path_1.default.join(fetched.extractDir, 'shared');
+            if (node_fs_1.default.existsSync(sharedDir)) {
+                for (const entry of node_fs_1.default.readdirSync(sharedDir)) {
+                    const from = node_path_1.default.join(sharedDir, entry);
+                    const to = node_path_1.default.join(skillsRoot, entry);
+                    sourceTop.add(entry);
+                    node_fs_1.default.cpSync(from, to, { recursive: true });
+                    syncedTop.push(entry);
+                }
+            }
+        }
+        else {
+            // openclaw 独立包：直接把包内所有 skill 目录（除 package.json 等元文件外）平铺到 skillsRoot
+            for (const entry of node_fs_1.default.readdirSync(fetched.extractDir)) {
+                if (entry === 'package.json' || entry === 'README.md' || entry === 'LICENSE')
+                    continue;
+                const from = node_path_1.default.join(fetched.extractDir, entry);
+                const stat = node_fs_1.default.statSync(from);
+                if (!stat.isDirectory())
+                    continue;
+                const to = node_path_1.default.join(skillsRoot, entry);
+                sourceTop.add(entry);
+                node_fs_1.default.cpSync(from, to, { recursive: true });
+                syncedTop.push(entry);
+            }
+        }
+        // rsync 式收尾：删掉源包已不提供的顶层条目（对齐 update-skills.sh 的 deleted）。
+        // 保留集用 sourceTop（源包提供的全部）而非 syncedTop（本轮实际写入的）——原因见
+        // sourceTop 声明处的注释：否则 shared skill 会被反复删了又写。
+        const deleted = pruneStaleEntries(skillsRoot, sourceTop);
+        // 写 .last-update 时间戳（对齐老 update-skills.sh；供 feida-ai freshness 检查用）
+        const lastUpdatePath = node_path_1.default.join(skillsRoot, '.last-update');
+        node_fs_1.default.writeFileSync(lastUpdatePath, String(Date.now()));
+        return {
+            packageName,
+            version: fetched.version,
+            lane,
+            deleted,
+            skippedByKeepFile: false,
+            syncedTop,
+            targetDir: skillsRoot,
+        };
+    }
+    finally {
+        fetched.cleanup();
+    }
+}
+/**
+ * 参数校验：type 白名单 + tgzKey 格式（避免非法值透传到 npm 包名）。
+ */
+function validateSandboxSyncOpts(opts) {
+    const validTypes = ['miaoda', 'miaoda-modern', 'miaoda-design', 'openclaw'];
+    if (opts.type === undefined || !validTypes.includes(opts.type)) {
+        throw new error_1.AppError('SKILLS_INVALID_TYPE', `--type must be one of: ${validTypes.join(', ')} (got: ${opts.type ?? 'undefined'})`);
+    }
+    if (opts.tgzKey !== undefined && opts.tgzKey !== '') {
+        // 校验 tgz key 大致格式（前缀 skills_versions/ + all_ + 允许字符 + .tgz）；避免非法值影响 lane 反推
+        if (!/^[A-Za-z0-9/_\-.]+\.tgz$/.test(opts.tgzKey)) {
+            throw new error_1.AppError('SKILLS_INVALID_TGZ_KEY', `--tgz-key value looks invalid: ${opts.tgzKey}`);
+        }
+    }
+    return { type: opts.type, tgzKey: opts.tgzKey };
+}

package/package.json

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