@lark-apaas/miaoda-cli 0.1.24-alpha.bc2625d → 0.1.24-alpha.cb67974

package/dist/api/db/sql-keywords.js

@@ -70,7 +70,6 @@ exports.SQL_KEYWORDS = [
     // DDL
     'CREATE',
     'ALTER',
-    'ENABLE',
     'DROP',
     'TRUNCATE',
     'RENAME',

package/dist/cli/commands/skills/index.js

@@ -21,11 +21,15 @@ function registerSkillsCommands(program) {
 function registerSkillsSync(parent) {
     const cmd = parent
         .command('sync')
-        .description('同步 coding-steering（latest 或指定版本）到 user app')
+        .description('同步 skills 到 user app（默认 coding-steering；带 --type 时走 sandbox-skills）')
         .option('--dir <path>', '项目目录，默认当前目录', '.')
         .option('--version <ver>', 'coding-steering 包版本或 dist-tag，缺省 latest')
         .option('--local', '走本地 dev / agent 输出形态：拷到 .agents/skills 平铺 + 创建 .claude/skills 软链。' +
         '不传时退回老形态：拷到 .agent/skills/steering/<stack>/skills/（跟沙箱端 update-skills.sh 对齐）', false)
+        .option('--type <type>', '走 sandbox-skills 分支：miaoda | miaoda-modern | miaoda-design | openclaw。' +
+        '有值时忽略 --version/--local，改从 @lark-apaas/coding-<pkg>-sandbox 拉对应包写入 .agent/skills/')
+        .option('--tgz-key <key>', '配合 --type 使用；老 TCC skillsUpdateTgzKey 值透传，' +
+        '从 skills_versions/all_<X>.tgz 反推出 dist-tag lane-<X>；缺省走 @latest')
         .addHelpText('after', `
 前置要求
   当前目录（或 --dir）已走过 'miaoda app init'（.spark/meta.json 含 stack）
@@ -56,6 +60,8 @@ JSON 输出
             dir: rawOpts.dir,
             version: rawOpts.version,
             local: rawOpts.local,
+            type: rawOpts.type,
+            tgzKey: rawOpts.tgzKey,
         });
     }));
 }

package/dist/cli/handlers/db/sql.js

@@ -411,19 +411,6 @@ const ISO_TIMESTAMP_RE = /^\d{4}-\d{2}-\d{2}(?:[T ]\d{2}:\d{2}:\d{2}(?:\.\d+)?(?
 const SYNTAX_RE = /syntax error at or near "([^"]+)"/i;
 const RELATION_RE = /relation "([^"]+)" does not exist/i;
 const COLUMN_RE = /column "([^"]+)"(?: of relation "([^"]+)")? does not exist/i;
-const KEYWORD_TYPO_IGNORE_WORDS = new Set([
-    // Legal PostgreSQL terms that are not useful keyword typo candidates.
-    'ROW',
-    'LEVEL',
-    'SECURITY',
-    // Common index access methods used after `USING`.
-    'BTREE',
-    'HASH',
-    'GIST',
-    'SPGIST',
-    'GIN',
-    'BRIN',
-]);
 /**
  * 在错误抛出前富化 next_actions（最多 1 条 hint），按 PG 报错形态分发：
  *
@@ -553,8 +540,6 @@ function findKeywordTypo(sql) {
         const upper = tok.toUpperCase();
         if (sql_keywords_1.SQL_KEYWORDS.includes(upper))
             continue; // 写对的关键字
-        if (KEYWORD_TYPO_IGNORE_WORDS.has(upper))
-            continue;
         const guess = (0, fuzzy_match_1.suggest)(upper, sql_keywords_1.SQL_KEYWORDS);
         if (guess && guess !== upper) {
             return { input: tok, suggest: guess };

package/dist/cli/handlers/skills/sync.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.handleSkillsSync = handleSkillsSync;
 const node_path_1 = __importDefault(require("node:path"));
 const coding_steering_1 = require("../../../utils/coding-steering");
+const sandbox_skills_1 = require("../../../utils/sandbox-skills");
 const spark_meta_1 = require("../../../utils/spark-meta");
 const error_1 = require("../../../utils/error");
 const output_1 = require("../../../utils/output");
@@ -26,6 +27,25 @@ const output_1 = require("../../../utils/output");
 async function handleSkillsSync(opts) {
     await Promise.resolve();
     const targetDir = node_path_1.default.resolve(opts.dir ?? process.cwd());
+    // --type 走 sandbox-skills 分支（迁仓后沙箱内 update-skills.sh 调用），跟本地 dev 的
+    // steering 同步逻辑并列——两条路径的目标 / 拉包 / 目录结构完全不同，用 --type 显式路由。
+    if (opts.type !== undefined && opts.type !== '') {
+        const { type, tgzKey } = (0, sandbox_skills_1.validateSandboxSyncOpts)({ type: opts.type, tgzKey: opts.tgzKey });
+        const result = (0, sandbox_skills_1.syncSandboxSkills)({ type, tgzKey, targetDir });
+        (0, output_1.emit)({
+            data: {
+                mode: 'sandbox',
+                type,
+                packageName: result.packageName,
+                version: result.version,
+                lane: result.lane,
+                syncedTop: result.syncedTop,
+                targetDir: result.targetDir,
+            },
+        });
+        return;
+    }
+    // 原有 coding-steering 同步逻辑（本地 dev / miaoda app init 用）
     const meta = (0, spark_meta_1.readSparkMeta)(targetDir);
     if (meta.stack === undefined || meta.stack === '') {
         throw new error_1.AppError('SKILLS_META_INCOMPLETE', '.spark/meta.json missing stack — run `miaoda app init` first');

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

@@ -19,32 +19,14 @@ exports.EXCLUDES = new Set([
     'yarn.lock',
     '.gitignore',
     '.npmrc',
-    // agent / 编辑器配置目录与指令文件：只服务本地开发，不属于应用资产。
-    // 注意 .claude/skills 在 flat layout 下是指向 ../.agents/skills 的软链，而 listSourceFiles
-    // 会 follow 软链，所以必须按 basename 把 .claude 整个排掉，否则 skills 会从软链侧被带进产物。
     '.agent',
     '.agents',
-    '.claude',
-    '.codex',
-    '.cursor',
-    '.gemini',
-    '.trae',
-    '.windsurf',
-    '.vscode',
-    '.idea',
-    'AGENTS.md',
-    'CLAUDE.md',
-    'GEMINI.md',
     'skills',
     '.env',
     '.env.local',
     'README.md',
     '.DS_Store',
     '.spark',
-    // 本地开发的临时/运行时目录：tmp 里的 .html 是草稿或中间产物，logs 是本地日志，
-    // 两者既不进产物也不该出现在 routes.json。
-    'tmp',
-    'logs',
 ]);
 /**
  * 递归列出 root 下所有文件的相对 posix 路径，跳过 EXCLUDES（任意层级 basename），

package/dist/utils/sandbox-skills.js

@@ -0,0 +1,193 @@
+"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_child_process_1 = require("node:child_process");
+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");
+/**
+ * 覆盖式清空目录：先 shell `rm -rf`，挂了再 fallback 到 fs.rmSync。
+ *
+ * 为什么不直接 fs.rmSync：老沙箱残留的文件可能是**别的用户**写的（例如老 update.sh
+ * 以 root 用户跑，写下 root owned 的 `.last-update`）。`fs.rmSync {force:true}` 只
+ * 吞 ENOENT，遇到 EACCES 直接 throw；而 shell `rm -rf` 对权限的处理更宽松（只要
+ * 对**目录**有写权限就能删掉里面的文件，无视文件本身的 owner/权限）。
+ */
+function forceRemoveDir(dir) {
+    if (!node_fs_1.default.existsSync(dir))
+        return;
+    try {
+        (0, node_child_process_1.execFileSync)('rm', ['-rf', dir], { stdio: ['ignore', 'ignore', 'pipe'] });
+        if (!node_fs_1.default.existsSync(dir))
+            return;
+    }
+    catch (err) {
+        (0, logger_1.debug)(`sandbox-skills: shell rm -rf ${dir} failed: ${err.message}, fallback to fs.rmSync`);
+    }
+    // Fallback（比如沙箱没 rm、或权限受限）：尽力用 Node fs.rmSync
+    node_fs_1.default.rmSync(dir, { recursive: true, force: true });
+}
+const PACKAGE_BY_TYPE = {
+    miaoda: '@lark-apaas/coding-miaoda-sandbox',
+    'miaoda-modern': '@lark-apaas/coding-miaoda-sandbox',
+    'miaoda-design': '@lark-apaas/coding-miaoda-sandbox',
+    openclaw: '@lark-apaas/coding-openclaw-sandbox',
+};
+// 合并包内的业务线子目录（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_latest.tgz   → null（走 @latest）
+ *   任何 all_<X>.tgz                 → <X>
+ *
+ * 用 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];
+    if (lane === 'latest') {
+        return null;
+    }
+    return lane;
+}
+/**
+ * 主流程：按 type 拉包 + sync 到目标目录。
+ *
+ * sync 策略：**覆盖式写入 + 老文件清理**，对齐老 cp-skills.sh 行为
+ * （`rm -rf $TARGET; mkdir -p $TARGET; cp -r ...`）。
+ */
+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 dist-tag；失败 fallback 到 latest（防灰度切换期间 dist-tag 缺失 404）
+    const primaryVersion = lane !== null ? `lane-${lane}` : 'latest';
+    let fetched;
+    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 (lane === null) {
+            throw err;
+        }
+        (0, logger_1.debug)(`sandbox-skills: lane ${primaryVersion} not available, 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');
+        // 覆盖式：清空目标 skill 根目录（对齐 cp-skills.sh 行为，避免遗留老 skill）
+        // 用 forceRemoveDir 兜底：老沙箱可能残留其他用户写的 stale 文件（例如老 update.sh
+        // 以 root 跑，写下 root owned 的 `.last-update`），fs.rmSync {force:true} 遇到 EACCES
+        // 会 throw。见 forceRemoveDir 注释。
+        forceRemoveDir(skillsRoot);
+        node_fs_1.default.mkdirSync(skillsRoot, { recursive: true });
+        const syncedTop = [];
+        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);
+                    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：sync 合并包内 shared/* 到 target（对齐老 build.sh 的 shared 分发行为）
+            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);
+                    if (node_fs_1.default.existsSync(to)) {
+                        // shared 命中已存在的 skill（如同名）— 保留业务线版本，跳过 shared（对齐老 build.sh：shared 是补丁，同名不覆盖）
+                        (0, logger_1.debug)(`sandbox-skills: shared/${entry} conflicts with business-line skill, skipped`);
+                        continue;
+                    }
+                    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);
+                node_fs_1.default.cpSync(from, to, { recursive: true });
+                syncedTop.push(entry);
+            }
+        }
+        // 写 .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,
+            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.24-alpha.bc2625d",
+  "version": "0.1.24-alpha.cb67974",
   "description": "Miaoda 平台命令行工具，面向 Agent 调用",
   "type": "commonjs",
   "bin": {