@lark-apaas/miaoda-cli 0.1.39-alpha.facb70e → 0.1.39-alpha.fc0f733

package/README.md

@@ -52,6 +52,22 @@ miaoda file ls --output json
 
 完整命令通过 `miaoda --help` 或 `miaoda <domain> --help` 查看。
 
+## 全栈应用的 MCP UI 检查
+
+`miaoda app sync` 为 `nestjs-react-fullstack` 应用同步 `scripts/lint.js`，在
+`tsconfig.node.json` 中追加 `server/mcp/ui` 排除项，并保留现有配置及继承的排除路径。
+根 `eslint.config.js` / `.mjs` / `.cjs` 会增量追加 UI 全局忽略，直接 ESLint 调用和编辑器检查均生效。
+迁移不执行配置文件；无法静态识别的自定义导出保留并提示手动补齐。
+已知模板版本的 `type:check`、`eslint` 命令会迁移到独立检查入口；自定义命令保留并提示。
+
+- `npm run type:check`：检查服务端、客户端及 MCP UI。
+- `npm run type:check:mcp-ui` / `npm run eslint:mcp-ui`：单独检查 MCP UI。
+- `npm run lint -- --files <files...>`：按改动文件选择检查范围。
+
+同步不会生成 MCP UI 目录。开发 MCP UI 时，由 Agent 按 MCP 指南创建
+`server/mcp/ui/tsconfig.json` 和根目录 `eslint.mcp-ui.config.cjs`。
+没有 UI 源码时跳过独立检查；存在 UI 源码但缺少配置时明确报错。
+
 ## 打包可本地访问的静态产物
 
 `miaoda app pack`（默认 `--mode standalone`）把当前应用构建成一份自包含静态产物，可脱离妙搭平台本地打开。

package/dist/config/sync-configs/nestjs-react-fullstack.js

@@ -159,6 +159,43 @@ exports.SYNC_CONFIG = {
             to: `npx -y ${fullstack_cli_pin_1.FULLSTACK_CLI_PIN_SPEC} sync --disable-gen-openapi`,
             ifStartsWith: 'npx -y @lark-apaas/fullstack-cli sync',
         },
+        { type: 'eslint-ignore', to: 'eslint.config.js', pattern: 'server/mcp/ui/**' },
+        { type: 'eslint-ignore', to: 'eslint.config.mjs', pattern: 'server/mcp/ui/**' },
+        { type: 'eslint-ignore', to: 'eslint.config.cjs', pattern: 'server/mcp/ui/**' },
+        // MCP UI 使用独立浏览器配置；仅迁移已知模板命令，不生成 UI 目录或配置。
+        {
+            type: 'typescript-exclude',
+            to: 'tsconfig.node.json',
+            path: 'server/mcp/ui',
+        },
+        {
+            type: 'add-script',
+            name: 'type:check:mcp-ui',
+            command: 'node ./scripts/lint.js --typecheck-mcp-ui',
+            overwrite: false,
+        },
+        {
+            type: 'add-script',
+            name: 'eslint:mcp-ui',
+            command: 'node ./scripts/lint.js --eslint-mcp-ui',
+            overwrite: false,
+        },
+        {
+            type: 'patch-script',
+            name: 'type:check',
+            to: 'node ./scripts/lint.js --typecheck',
+            ifEquals: [
+                'concurrently -n "server,client" -c "blue,green" "npm run type:check:server" "npm run type:check:client"',
+                'concurrently "npm run type:check:server" "npm run type:check:client"',
+                'concurrently "npm run type:check:client" "npm run type:check:server"',
+            ],
+        },
+        {
+            type: 'patch-script',
+            name: 'eslint',
+            to: 'eslint . --quiet --ignore-pattern "server/mcp/ui/**"',
+            ifEquals: ['eslint . --quiet', 'eslint .'],
+        },
         // ===== miaoda-cli 本地开发新增规则（fullstack-cli sync 不会执行） =====
         // M1. scripts.dev:local —— 本地用户绕过沙箱判定直接跑本地链路（npm run dev:local）。
         //     dev.sh 在 MIAODA_DEP_CACHE_DIR 非空时跑 dev.js（沙箱保活）、否则 exec dev-local.js；显式 dev:local

package/dist/utils/eslint-ignore.js

@@ -0,0 +1,169 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addEslintGlobalIgnore = addEslintGlobalIgnore;
+const node_fs_1 = __importDefault(require("node:fs"));
+const typescript_1 = __importDefault(require("typescript"));
+const error_1 = require("./error");
+/** 只解析源码，不加载用户配置；用局部插入保留自定义规则和注释。 */
+function addEslintGlobalIgnore(filename, pattern) {
+    if (!node_fs_1.default.existsSync(filename))
+        return { changed: false };
+    const source = node_fs_1.default.readFileSync(filename, 'utf8');
+    const file = typescript_1.default.createSourceFile(filename, source, typescript_1.default.ScriptTarget.Latest, true, typescript_1.default.ScriptKind.JS);
+    const diagnostics = file
+        .parseDiagnostics;
+    if (diagnostics.length)
+        throw new error_1.AppError('INVALID_CONFIG', `Invalid ESLint configuration: ${filename}`);
+    const variables = new Map();
+    const declarations = new Map();
+    const aliasReferences = new Set();
+    const resolvedAliases = new Set();
+    const exportTargets = new Set();
+    const helpers = new Set();
+    const namespaces = new Set();
+    const exports = [];
+    const moduleName = (node) => {
+        if (!typescript_1.default.isCallExpression(node) ||
+            !typescript_1.default.isIdentifier(node.expression) ||
+            node.expression.text !== 'require')
+            return;
+        const arg = node.arguments.at(0);
+        return arg && typescript_1.default.isStringLiteral(arg) ? arg.text : undefined;
+    };
+    for (const statement of file.statements) {
+        if (typescript_1.default.isImportDeclaration(statement) && typescript_1.default.isStringLiteral(statement.moduleSpecifier)) {
+            const module = statement.moduleSpecifier.text;
+            const clause = statement.importClause;
+            if (module === 'typescript-eslint' && clause?.name)
+                namespaces.add(clause.name.text);
+            const bindings = clause?.namedBindings;
+            if (bindings && typescript_1.default.isNamespaceImport(bindings) && module === 'typescript-eslint')
+                namespaces.add(bindings.name.text);
+            if (bindings && typescript_1.default.isNamedImports(bindings)) {
+                for (const element of bindings.elements) {
+                    const name = element.propertyName?.text ?? element.name.text;
+                    if ((module === 'eslint/config' && name === 'defineConfig') ||
+                        (module === 'typescript-eslint' && name === 'config'))
+                        helpers.add(element.name.text);
+                }
+            }
+        }
+        if (typescript_1.default.isVariableStatement(statement) && statement.declarationList.flags & typescript_1.default.NodeFlags.Const) {
+            for (const declaration of statement.declarationList.declarations) {
+                if (!declaration.initializer)
+                    continue;
+                const module = moduleName(declaration.initializer);
+                if (typescript_1.default.isIdentifier(declaration.name)) {
+                    variables.set(declaration.name.text, declaration.initializer);
+                    declarations.set(declaration.name.text, declaration.name);
+                    if (module === 'typescript-eslint')
+                        namespaces.add(declaration.name.text);
+                }
+                else if (typescript_1.default.isObjectBindingPattern(declaration.name)) {
+                    for (const element of declaration.name.elements) {
+                        const name = element.propertyName ?? element.name;
+                        if (!typescript_1.default.isIdentifier(name) || !typescript_1.default.isIdentifier(element.name))
+                            continue;
+                        if ((module === 'eslint/config' && name.text === 'defineConfig') ||
+                            (module === 'typescript-eslint' && name.text === 'config'))
+                            helpers.add(element.name.text);
+                    }
+                }
+            }
+        }
+        if (typescript_1.default.isExportAssignment(statement) && !statement.isExportEquals)
+            exports.push(statement.expression);
+        if (typescript_1.default.isExpressionStatement(statement) && typescript_1.default.isBinaryExpression(statement.expression)) {
+            const { left, right, operatorToken } = statement.expression;
+            if (operatorToken.kind === typescript_1.default.SyntaxKind.EqualsToken &&
+                typescript_1.default.isPropertyAccessExpression(left) &&
+                typescript_1.default.isIdentifier(left.expression) &&
+                left.expression.text === 'module' &&
+                left.name.text === 'exports') {
+                exports.push(right);
+                exportTargets.add(left);
+            }
+        }
+    }
+    function unwrap(node, seen = new Set()) {
+        if (typescript_1.default.isParenthesizedExpression(node))
+            return unwrap(node.expression, seen);
+        if (typescript_1.default.isIdentifier(node) && !seen.has(node.text)) {
+            const value = variables.get(node.text);
+            if (value) {
+                resolvedAliases.add(node.text);
+                aliasReferences.add(node);
+                seen.add(node.text);
+                return unwrap(value, seen);
+            }
+        }
+        return node;
+    }
+    const root = exports.length === 1 ? unwrap(exports[0]) : undefined;
+    // const 只固定变量绑定，不能保证数组不被 pop/push 或传给其他函数修改。
+    // 有额外引用时保留原配置，避免改变初始化数组影响用户后续操作。
+    function checkReferences(node) {
+        if (typescript_1.default.isIdentifier(node) &&
+            resolvedAliases.has(node.text) &&
+            declarations.get(node.text) !== node &&
+            !aliasReferences.has(node))
+            return true;
+        // module["exports"]、(module).exports、module 别名也可能修改导出数组。
+        if (typescript_1.default.isIdentifier(node) &&
+            node.text === 'module' &&
+            !(typescript_1.default.isPropertyAccessExpression(node.parent) &&
+                node.parent.expression === node &&
+                exportTargets.has(node.parent)))
+            return true;
+        return typescript_1.default.forEachChild(node, (child) => checkReferences(child) || undefined) ?? false;
+    }
+    const unsafeReference = checkReferences(file);
+    const isHelper = (node) => {
+        const callee = node.expression;
+        return typescript_1.default.isIdentifier(callee)
+            ? helpers.has(callee.text)
+            : typescript_1.default.isPropertyAccessExpression(callee) &&
+                typescript_1.default.isIdentifier(callee.expression) &&
+                namespaces.has(callee.expression.text) &&
+                callee.name.text === 'config';
+    };
+    const entries = root && typescript_1.default.isArrayLiteralExpression(root)
+        ? root.elements
+        : root && typescript_1.default.isCallExpression(root) && isHelper(root)
+            ? root.arguments
+            : undefined;
+    if (!entries || unsafeReference) {
+        return {
+            changed: false,
+            warning: `Cannot safely migrate ${filename}; add ${JSON.stringify(pattern)} to its global ignores manually.`,
+        };
+    }
+    // 只认真正的全局 ignores；带 files/rules 的局部忽略不能阻止服务端配置匹配 UI。
+    // 仅检查最后一个配置，确保此前的否定规则或动态配置无法撤销新增忽略。
+    const last = entries.at(-1);
+    if (last && typescript_1.default.isObjectLiteralExpression(last)) {
+        const props = last.properties;
+        const nameOf = (p) => p.name && (typescript_1.default.isIdentifier(p.name) || typescript_1.default.isStringLiteral(p.name)) ? p.name.text : undefined;
+        if (new Set(props.map(nameOf)).size === props.length &&
+            props.every((p) => typescript_1.default.isPropertyAssignment(p) && ['ignores', 'name'].includes(nameOf(p) ?? ''))) {
+            const ignores = props.find((p) => nameOf(p) === 'ignores');
+            if (ignores &&
+                typescript_1.default.isPropertyAssignment(ignores) &&
+                typescript_1.default.isArrayLiteralExpression(ignores.initializer)) {
+                const patterns = ignores.initializer.elements;
+                if (patterns.length &&
+                    patterns.every(typescript_1.default.isStringLiteral) &&
+                    patterns[patterns.length - 1].text === pattern)
+                    return { changed: false };
+            }
+        }
+    }
+    const eol = source.includes('\r\n') ? '\r\n' : '\n';
+    const position = last ? last.end : entries.pos;
+    const addition = `${last ? ',' : ''}${eol}  { ignores: [${JSON.stringify(pattern)}] }`;
+    node_fs_1.default.writeFileSync(filename, source.slice(0, position) + addition + source.slice(position));
+    return { changed: true };
+}

package/dist/utils/sync-rule.js

@@ -43,6 +43,8 @@ const jsonc = __importStar(require("jsonc-parser"));
 const file_ops_1 = require("./file-ops");
 const merge_json_1 = require("./merge-json");
 const logger_1 = require("./logger");
+const typescript_exclude_1 = require("./typescript-exclude");
+const eslint_ignore_1 = require("./eslint-ignore");
 /**
  * 顺序执行 SyncRule[]，逐条 apply。一条 rule 报错不影响后续 rule（catch + 记录），最终
  * 在 handler 层决定是否整体 fail。
@@ -106,6 +108,24 @@ function applyOne(rule, opts) {
         case 'patch-script': {
             return applyPatchScript(rule, targetDir, logPrefix);
         }
+        case 'eslint-ignore': {
+            const result = (0, eslint_ignore_1.addEslintGlobalIgnore)(node_path_1.default.join(targetDir, rule.to), rule.pattern);
+            if (result.warning)
+                (0, logger_1.log)(logPrefix, `  ⚠ ${result.warning}`);
+            if (result.changed)
+                (0, logger_1.log)(logPrefix, `  ✓ ${rule.to} (global ignore ${rule.pattern})`);
+            return {
+                rule,
+                action: result.changed ? 'patched' : result.warning ? 'skipped' : 'noop',
+                path: rule.to,
+                detail: result.warning,
+            };
+        }
+        case 'typescript-exclude': {
+            const changed = (0, typescript_exclude_1.excludeTypeScriptPath)(node_path_1.default.join(targetDir, rule.to), rule.path);
+            (0, logger_1.log)(logPrefix, `  ${changed ? '✓' : '○'} ${rule.to} (exclude ${rule.path})`);
+            return { rule, action: changed ? 'patched' : 'noop', path: rule.to };
+        }
         case 'merge-json': {
             return applyMergeJson(rule, sourceRoot, targetDir, logPrefix);
         }
@@ -215,7 +235,10 @@ function applyPatchScript(rule, targetDir, logPrefix) {
         (0, logger_1.log)(logPrefix, `  ○ scripts.${rule.name} (already patched)`);
         return { rule, action: 'noop', path: 'package.json' };
     }
-    if (!current.startsWith(rule.ifStartsWith)) {
+    const matches = rule.ifEquals
+        ? rule.ifEquals.includes(current)
+        : rule.ifStartsWith !== undefined && current.startsWith(rule.ifStartsWith);
+    if (!matches) {
         (0, logger_1.log)(logPrefix, `  ⚠ scripts.${rule.name} customized, skip patch`);
         return { rule, action: 'skipped', path: 'package.json' };
     }

package/dist/utils/typescript-exclude.js

@@ -0,0 +1,62 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.excludeTypeScriptPath = excludeTypeScriptPath;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const typescript_1 = __importDefault(require("typescript"));
+const jsonc_parser_1 = require("jsonc-parser");
+const error_1 = require("./error");
+/** 追加排除项，保留 JSONC 注释和继承的排除路径；不创建缺失的配置。 */
+function excludeTypeScriptPath(filename, excludedPath) {
+    if (!node_fs_1.default.existsSync(filename))
+        return false;
+    const source = node_fs_1.default.readFileSync(filename, 'utf8');
+    const errors = [];
+    const raw = (0, jsonc_parser_1.parse)(source, errors, { allowTrailingComma: true });
+    if (errors.length || !raw || typeof raw !== 'object' || Array.isArray(raw)) {
+        throw new error_1.AppError('INVALID_CONFIG', `Invalid TypeScript configuration: ${filename}`);
+    }
+    const parsed = typescript_1.default.getParsedCommandLineOfConfigFile(filename, {}, {
+        ...typescript_1.default.sys,
+        onUnRecoverableConfigFileDiagnostic: (diagnostic) => {
+            throw new error_1.AppError('INVALID_CONFIG', typescript_1.default.flattenDiagnosticMessageText(diagnostic.messageText, '\n'));
+        },
+    });
+    // 初始化中的空工程允许迁移，其他错误不能被静默忽略。
+    const diagnostics = parsed?.errors.filter((d) => d.code !== 18003 && d.code !== 18002) ?? [];
+    if (!parsed || diagnostics.length) {
+        throw new error_1.AppError('INVALID_CONFIG', `Cannot migrate ${filename}: ${diagnostics.map((d) => typescript_1.default.flattenDiagnosticMessageText(d.messageText, '\n')).join('; ')}`);
+    }
+    const effective = parsed.raw;
+    const excludes = effective.exclude ?? [
+        'node_modules',
+        'bower_components',
+        'jspm_packages',
+        ...[parsed.options.outDir, parsed.options.declarationDir]
+            .filter((p) => Boolean(p))
+            .map((p) => node_path_1.default.relative(node_path_1.default.dirname(filename), p).split(node_path_1.default.sep).join('/')),
+    ];
+    if (!Array.isArray(excludes) || excludes.some((p) => typeof p !== 'string')) {
+        throw new error_1.AppError('INVALID_CONFIG', `Invalid exclude array: ${filename}`);
+    }
+    const paths = excludes;
+    if (paths.includes(excludedPath))
+        return false;
+    const ownExclude = raw.exclude;
+    const formattingOptions = {
+        insertSpaces: true,
+        tabSize: 2,
+        eol: source.includes('\r\n') ? '\r\n' : '\n',
+    };
+    const edits = Array.isArray(ownExclude)
+        ? (0, jsonc_parser_1.modify)(source, ['exclude', ownExclude.length], excludedPath, {
+            formattingOptions,
+            isArrayInsertion: true,
+        })
+        : (0, jsonc_parser_1.modify)(source, ['exclude'], [...paths, excludedPath], { formattingOptions });
+    node_fs_1.default.writeFileSync(filename, (0, jsonc_parser_1.applyEdits)(source, edits));
+    return true;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lark-apaas/miaoda-cli",
-  "version": "0.1.39-alpha.facb70e",
+  "version": "0.1.39-alpha.fc0f733",
   "description": "Miaoda 平台命令行工具，面向 Agent 调用",
   "type": "commonjs",
   "bin": {
@@ -33,7 +33,8 @@
     "jsonc-parser": "^3.3.1",
     "ora": "^5.4.1",
     "picocolors": "^1.1.1",
-    "which": "^7.0.0"
+    "which": "^7.0.0",
+    "typescript": "^5.8.3"
   },
   "devDependencies": {
     "@types/cross-spawn": "^6.0.6",
@@ -51,7 +52,6 @@
     "prettier": "^3.8.3",
     "tsc-alias": "^1.8.11",
     "tsx": "^4.19.4",
-    "typescript": "^5.8.3",
     "vitest": "^4.1.4",
     "xml2js": "^0.6.2"
   },

package/upgrade/templates/nestjs-react-fullstack/templates/scripts/lint.js

@@ -18,19 +18,31 @@ function runCommand(command, args) {
       shell: false,
     });
 
-    child.on('close', (code) => resolve(code || 0));
+    child.on('close', (code) => resolve(code ?? 1));
     child.on('error', () => resolve(1));
   });
 }
 
+// 串行依次执行每个任务，全部跑完后再聚合退出码：
+// 降低并发资源占用、让各任务输出按顺序清晰可读，同时保留“一次暴露所有 lint 问题”的行为。
+async function runTasksSerially(taskSpecs) {
+  let exitCode = 0;
+  for (const [command, args] of taskSpecs) {
+    const code = await runCommand(command, args);
+    if (code !== 0) {
+      exitCode = 1;
+    }
+  }
+  return exitCode;
+}
+
 function normalizeProjectFile(filePath) {
   const absolutePath = path.isAbsolute(filePath)
     ? filePath
     : path.resolve(cwd, filePath);
 
   if (!fs.existsSync(absolutePath)) {
-    console.warn(`[lint] Skip missing file: ${filePath}`);
-    return null;
+    console.log(`[lint] Deleted file: ${filePath}; checking affected projects`);
   }
 
   const relativePath = path.relative(cwd, absolutePath);
@@ -94,17 +106,92 @@ function canRunStylelint() {
   return STYLELINT_CONFIG_FILES.some(file => fs.existsSync(path.join(cwd, file)));
 }
 
+const UI_DIR = 'server/mcp/ui';
+const UI_TYPECHECK = 'node ./scripts/lint.js --typecheck';
+
+function isUiFile(file) {
+  return file.startsWith(`${UI_DIR}/`);
+}
+
+function uiSourceFiles() {
+  const files = [];
+  function visit(relative) {
+    const absolute = path.join(cwd, relative);
+    if (!fs.existsSync(absolute)) return;
+    if (fs.lstatSync(absolute).isSymbolicLink()) {
+      throw new Error(`MCP UI 检查不支持符号链接: ${relative}`);
+    }
+    for (const entry of fs.readdirSync(absolute, { withFileTypes: true })) {
+      if (['node_modules', 'dist', '.git'].includes(entry.name)) continue;
+      const file = `${relative}/${entry.name}`;
+      if (entry.isSymbolicLink()) throw new Error(`MCP UI 检查不支持符号链接: ${file}`);
+      if (entry.isDirectory()) visit(file);
+      else if (isEslintTarget(file) && !/\.d\.(?:ts|mts|cts)$/.test(file)) files.push(file);
+    }
+  }
+  visit(UI_DIR);
+  return files.sort();
+}
+
+function uiTasks({ types = true, eslint = true } = {}) {
+  const sources = uiSourceFiles();
+  if (!sources.length) return [];
+  const tasks = [];
+  if (types) {
+    const config = `${UI_DIR}/tsconfig.json`;
+    if (!fs.existsSync(path.join(cwd, config))) {
+      throw new Error(`MCP UI 缺少 ${config}，请按 mcp-guide 补齐独立浏览器 TypeScript 配置。`);
+    }
+    const ts = require('typescript');
+    const parsed = ts.getParsedCommandLineOfConfigFile(path.join(cwd, config), {}, {
+      ...ts.sys,
+      onUnRecoverableConfigFileDiagnostic: d => { throw new Error(ts.flattenDiagnosticMessageText(d.messageText, '\n')); },
+    });
+    if (!parsed || parsed.errors.length) throw new Error(`MCP UI TypeScript 配置无效: ${config}`);
+    const included = new Set(parsed.fileNames.map(file => path.resolve(file)));
+    const missing = sources.filter(file => !included.has(path.resolve(cwd, file)));
+    if (missing.length) throw new Error(`MCP UI TypeScript 配置未覆盖源码: ${missing.join(', ')}；请检查 include/exclude，JS 源码需开启 allowJs。`);
+    tasks.push([getBinName('npx'), ['--no-install', 'tsc', '--noEmit', '-p', config]]);
+  }
+  if (eslint) {
+    const config = ['eslint.mcp-ui.config.js', 'eslint.mcp-ui.config.cjs', 'eslint.mcp-ui.config.mjs']
+      .find(file => fs.existsSync(path.join(cwd, file)));
+    if (!config) throw new Error('MCP UI 缺少独立 ESLint 配置，请按 mcp-guide 创建 eslint.mcp-ui.config.cjs。');
+    tasks.push([getBinName('npx'), ['--no-install', 'eslint', '--config', config, '--quiet', '--max-warnings', '0', ...sources]]);
+  }
+  return tasks;
+}
+
+function packageScripts() {
+  return JSON.parse(fs.readFileSync(path.join(cwd, 'package.json'), 'utf8')).scripts || {};
+}
+
+async function runTypeCheck() {
+  const scripts = packageScripts();
+  const tasks = ['type:check:server', 'type:check:client'].map(name => {
+    if (!scripts[name]) throw new Error(`缺少 scripts.${name}，请保留应用原有类型检查命令。`);
+    return [getBinName('npm'), ['run', name]];
+  });
+  tasks.push(...uiTasks({ eslint: false }));
+  process.exit(await runTasksSerially(tasks));
+}
+
 async function runDefaultLint() {
-  const commands = ['npm run eslint', 'npm run type:check'];
+  const taskSpecs = [
+    [getBinName('npm'), ['run', 'eslint']],
+    [getBinName('npm'), ['run', 'type:check']],
+  ];
+
+  // Customized type:check remains untouched; ensure full lint still checks UI.
+  taskSpecs.push(...uiTasks({ types: packageScripts()['type:check'] !== UI_TYPECHECK }));
 
   if (canRunStylelint()) {
-    commands.push('npm run stylelint');
+    taskSpecs.push([getBinName('npm'), ['run', 'stylelint']]);
   } else {
     console.warn('[lint] Skip stylelint: missing scripts.stylelint or stylelint config');
   }
 
-  const code = await runCommand(getBinName('npx'), ['concurrently', ...commands]);
-  process.exit(code);
+  process.exit(await runTasksSerially(taskSpecs));
 }
 
 async function runSelectiveLint(inputFiles) {
@@ -117,15 +204,20 @@ async function runSelectiveLint(inputFiles) {
     process.exit(0);
   }
 
-  const eslintFiles = normalizedFiles.filter(isEslintTarget);
-  const stylelintFiles = normalizedFiles.filter(isStylelintTarget);
+  const eslintFiles = normalizedFiles.filter(file => fs.existsSync(path.join(cwd, file)) && isEslintTarget(file) && !isUiFile(file) && !file.startsWith('eslint.mcp-ui.config.'));
+  const stylelintFiles = normalizedFiles.filter(file => fs.existsSync(path.join(cwd, file)) && isStylelintTarget(file));
   const typeCheckFiles = normalizedFiles.filter(isTypeCheckTarget);
 
   const clientTypeFiles = [];
   const serverTypeFiles = [];
+  const rootConfigChanged = normalizedFiles.some(file => /^tsconfig(?:\.[^/]*)?\.json$/.test(file));
+  if (rootConfigChanged) { clientTypeFiles.push('config'); serverTypeFiles.push('config'); }
+  let checkUi = rootConfigChanged || normalizedFiles.some(file => isUiFile(file) || file.startsWith('shared/') || file.startsWith('eslint.mcp-ui.config.'));
 
   for (const filePath of typeCheckFiles) {
-    if (filePath.startsWith('client/')) {
+    if (isUiFile(filePath)) {
+      checkUi = true;
+    } else if (filePath.startsWith('client/')) {
       clientTypeFiles.push(filePath);
     } else if (filePath.startsWith('server/')) {
       serverTypeFiles.push(filePath);
@@ -135,36 +227,46 @@ async function runSelectiveLint(inputFiles) {
     }
   }
 
-  const tasks = [];
+  const taskSpecs = [];
 
   if (eslintFiles.length > 0) {
-    tasks.push(runCommand(getBinName('npx'), ['eslint', '--quiet', ...eslintFiles]));
+    taskSpecs.push([getBinName('npx'), ['eslint', '--quiet', ...eslintFiles]]);
   }
 
   if (stylelintFiles.length > 0 && !canRunStylelint()) {
     console.warn('[lint] Skip stylelint: missing scripts.stylelint or stylelint config');
   } else if (stylelintFiles.length > 0) {
-    tasks.push(runCommand(getBinName('npx'), ['stylelint', '--quiet', ...stylelintFiles]));
+    taskSpecs.push([getBinName('npx'), ['stylelint', '--quiet', ...stylelintFiles]]);
   }
 
   if (clientTypeFiles.length > 0) {
-    tasks.push(runCommand(getBinName('npm'), ['run', 'type:check:client']));
+    taskSpecs.push([getBinName('npm'), ['run', 'type:check:client']]);
   }
 
   if (serverTypeFiles.length > 0) {
-    tasks.push(runCommand(getBinName('npm'), ['run', 'type:check:server']));
+    taskSpecs.push([getBinName('npm'), ['run', 'type:check:server']]);
   }
 
-  if (tasks.length === 0) {
+  if (checkUi) taskSpecs.push(...uiTasks());
+
+  if (taskSpecs.length === 0) {
     console.log('[lint] No supported files matched for lint');
     process.exit(0);
   }
 
-  const results = await Promise.all(tasks);
-  process.exit(results.some(code => code !== 0) ? 1 : 0);
+  process.exit(await runTasksSerially(taskSpecs));
 }
 
 async function main() {
+  const args = process.argv.slice(2);
+  const modes = ['--typecheck', '--typecheck-mcp-ui', '--eslint-mcp-ui'];
+  if (args.length && !(args[0] === '--files' && args.length > 1) && !(args.length === 1 && modes.includes(args[0]))) {
+    throw new Error('用法: lint.js [--files <paths...> | --typecheck | --typecheck-mcp-ui | --eslint-mcp-ui]');
+  }
+  if (args[0] === '--files' && args.slice(1).some(arg => arg.startsWith('--'))) throw new Error('--files 不可与其他检查模式混用');
+  if (args.includes('--typecheck')) return runTypeCheck();
+  if (args.includes('--typecheck-mcp-ui')) return process.exit(await runTasksSerially(uiTasks({ eslint: false })));
+  if (args.includes('--eslint-mcp-ui')) return process.exit(await runTasksSerially(uiTasks({ types: false })));
   const files = parseFilesArg(process.argv.slice(2));
   if (files === null) {
     await runDefaultLint();