@open-dy/vibecoding-cli 0.1.6-beta.0 → 0.1.6-beta.1

package/README.md

@@ -16,7 +16,7 @@ vibecoding verify --target taro --auto-start --full
 - `taro`：Taro 主应用、Server，以及项目中存在时的 OpenCard。
 - `opencard`：独立 OpenCard 项目。
 
-主要命令：`dev`、`build`、`lint`、`verify`、`pack`、`docs`、`turbo`、`init-mysql-db`，以及 `validate feed-card|routes|empty|opencard-structure`。
+主要命令：`dev`、`build`、`lint`、`verify`、`pack`、`docs`、`turbo`、`init-mysql-db`，以及 `validate feed-card|routes|empty|opencard-structure|package-size`。
 
 完整 SDK API 文档随 SDK npm 包和 Skill 交付，优先按 `${SKILL_DIR}/sdk-docs/versions.json` 核对版本，再查对应端的 `llms.txt`。`vibecoding docs --target taro`（OpenCard 使用 `--target opencard`，可指定 `--cwd <工程目录>`）只读定位实际安装的 SDK，输出 JSON：依赖键、版本、包位置、包内文档索引及公开类型路径。`ready` 表示包内存在文档索引；`docs-missing` 表示已安装的包没有内置索引，继续查 Skill 文档，版本不一致或信息不足时按 `exports` / `types` 查公开入口。业务导入使用 `imports`，npm 别名以依赖键为前缀，不能换成包的 `name`。包尚不可用时最多等待 `--timeout` 秒（默认 90），超时返回 `SDK_NOT_INSTALLED`，应检查工程安装结果。命令不会安装、重建 SDK 或启动服务。
 
@@ -40,7 +40,7 @@ CLI 内置 Schema 与通用小程序模板支持可选 `BgMusicUrl`；填写时
 
 服务包仅包含 `dist`、生成的 `Dockerfile`、`package.json`、`run.sh` 以及可选的 `sql`、`scripts`。生成 Dockerfile 时按原脚本规则为每条 `COPY package.json` 追加存在的目录，项目源文件不改写。构建/zip 失败保留退出码，临时目录在失败时也会清理。
 
-`verify` 的静态阶段在构建通过后，校验主工程 `server.zip` 的文件数（阈值 `1000`，超限失败），不生成 ZIP 或计算压缩包大小。标准 CLI 模板与打包共享黑名单：任意层级过滤依赖、缓存、测试目录、环境文件和私钥，保留其余业务资源。自定义 `scripts/pack.sh` 支持 `REQUIRED_SERVER_PATHS` / `SERVER_PACK_EXCLUDES` / `SERVER_PACK_EXCLUDE_GLOBS`，兼容旧的 `REQUIRED_SERVER_INCLUDES` / `OPTIONAL_SERVER_INCLUDES`；脚本缺失或无法解析、服务目录或必需文件缺失均失败。`pack` 对普通和封闭域服务应用同一规则，并重写各自的 `.dockerignore`，使 ZIP 与镜像包含相同资源。静态检查不等待 dev 的安装成功日志；自动启动预览后仍等待安装与端口就绪。
+`verify` 的静态阶段在构建通过后，校验主工程 `server.zip` 的文件数（阈值 `1000`，超限失败），不生成 ZIP 或计算服务端压缩包大小。随后对 tt 产物跑 `tma project-size`：落地页 `dist-tt`，存在 OpenCard 时再查 `opencard/dist`，独立 `--target opencard` 查该工程 `dist`。限额为总包 16MB。`tma` 不在 PATH 时安装 `tt-ide-cli@0.1.34`。单独复检用 `vibecoding validate package-size --target taro`，要求产物已存在；`--json` 输出判定结果，`--tma <path>` 指定二进制。标准 CLI 模板与打包共享黑名单：任意层级过滤依赖、缓存、测试目录、环境文件和私钥，保留其余业务资源。自定义 `scripts/pack.sh` 支持 `REQUIRED_SERVER_PATHS` / `SERVER_PACK_EXCLUDES` / `SERVER_PACK_EXCLUDE_GLOBS`，兼容旧的 `REQUIRED_SERVER_INCLUDES` / `OPTIONAL_SERVER_INCLUDES`；脚本缺失或无法解析、服务目录或必需文件缺失均失败。`pack` 对普通和封闭域服务应用同一规则，并重写各自的 `.dockerignore`，使 ZIP 与镜像包含相同资源。静态检查不等待 dev 的安装成功日志；自动启动预览后仍等待安装与端口就绪。
 
 浏览器验收优先使用 `agent-browser-real`，不可用时使用 `agent-browser`。浏览器命令只在验收阶段查找；CDP / 浏览器基础设施失败会报告 `infra_browser` 和 `runtime_status=unverified`，继续以非零退出码结束，页面与业务错误仍按实际错误判定。
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@open-dy/vibecoding-cli",
-  "version": "0.1.6-beta.0",
+  "version": "0.1.6-beta.1",
   "description": "Command orchestration, validation and packaging for Douyin vibecoding Taro and OpenCard projects.",
   "type": "module",
   "bin": {
@@ -43,8 +43,8 @@
     "ajv": "^8.18.0"
   },
   "peerDependencies": {
-    "@open-dy/vibecoding-sdk-taro": "0.1.1-beta.0",
-    "@open-dy/vibecoding-sdk-opencard": "0.1.5-beta.0"
+    "@open-dy/vibecoding-sdk-taro": "0.1.0-beta.0",
+    "@open-dy/vibecoding-sdk-opencard": "0.1.3-beta.0"
   },
   "peerDependenciesMeta": {
     "@open-dy/vibecoding-sdk-taro": {

package/release-provenance.json

@@ -2,12 +2,12 @@
   "schema": 1,
   "producer": "vibecoding-cli",
   "packageName": "@open-dy/vibecoding-cli",
-  "version": "0.1.6-beta.0",
+  "version": "0.1.6-beta.1",
   "source": {
-    "digest": "sha256-f2018ad1f7d7656392315c81128e717ce478aeb75dedecdec706fe0035cb026d",
-    "files": 87
+    "digest": "sha256-ff1ee2d57d7028ec10a7b6e38ff6fa605a076d665d8667ee0c168564b3f7d57e",
+    "files": 88
   },
-  "payload": "sha256-e85c65882947a652f0d0ec0b05ad00afe0a9106143ff44467c80bb045b86879c",
+  "payload": "sha256-fdb8c0900115ffe7138745c6b71545dca209f4a2053a881de779fe2da78f1912",
   "toolchain": {
     "node": "v22.23.1",
     "packageManager": null

package/src/cli.mjs

@@ -20,7 +20,7 @@ Commands:
   build                  Build the selected target
   lint                   Type-check, lint and validate source structure
   verify                 Run static and/or runtime verification
-  validate <name>        Run feed-card, routes, empty or opencard-structure
+  validate <name>        Run feed-card, routes, empty, opencard-structure or package-size
   init-mysql-db          Initialize the Taro server database
   pack                   Build deployment archives
   docs                   Locate the selected project's installed SDK reference
@@ -41,7 +41,9 @@ Options:
   --ports-only           Verify listening ports only
   --auto-start           Start dev once when verify finds missing ports
   --timeout <seconds>    Dev startup / docs dependency wait timeout (default: 90)
-  --frontend-url <url>   Override the primary runtime-check URL`
+  --frontend-url <url>   Override the primary runtime-check URL
+  --json                 Emit JSON from validate package-size
+  --tma <path>           Use an explicit tma binary for package-size`
 
 function assertNoExtra(positionals, count, command) {
   if (positionals.length > count) throw new UsageError(`Unexpected argument for ${command}: ${positionals[count]}`)
@@ -101,7 +103,10 @@ export async function main(argv = process.argv.slice(2)) {
     case 'init-mysql-db': assertNoExtra(positionals, 1, command); return runDatabaseInit(context)
     case 'validate':
       assertNoExtra(positionals, 2, command)
-      return runValidate(context, positionals[1])
+      return runValidate(context, positionals[1], {
+        json: Boolean(flags.json),
+        tmaBin: flags.tma,
+      })
     default: throw new UsageError(`Unknown command: ${command}\n\n${HELP}`)
   }
 }

package/src/commands/build.mjs

@@ -24,7 +24,6 @@ export async function buildTaroFrontend(context, type, options = {}) {
     cwd: context.taroRoot,
     env: taroEnvironment(context.taroRoot, options.env),
     label: `taro ${type} build`,
-    quiet: options.quiet,
   })
   if (type === 'tt' && !options.watch) {
     writeWebConfig(path.join(context.taroRoot, 'dist-tt'))
@@ -46,7 +45,6 @@ export async function buildOpenCard(context, options = {}) {
       ...cardEnvironment,
     }),
     label: 'opencard tt build',
-    quiet: options.quiet,
   })
   if (!options.watch) {
     writeWebConfig(path.join(root, options.env?.TT_OUTPUT_ROOT?.trim() || 'dist'))
@@ -64,7 +62,6 @@ export function buildServer(context, options = {}) {
     cwd: context.taroRoot,
     env: options.env,
     label: 'server build',
-    quiet: options.quiet,
   })
 }
 
@@ -73,7 +70,6 @@ export function buildClosedDomainServer(context, options = {}) {
     cwd: context.taroRoot,
     env: options.env,
     label: 'closed-domain-server build',
-    quiet: options.quiet,
   })
 }
 
@@ -94,7 +90,7 @@ export async function buildPackInputs(context, options = {}) {
   if (context.hasOpenCard) {
     tasks.push({ name: 'opencard', run: () => buildOpenCard(context, options) })
   }
-  await runTasks(tasks, { label: 'pack build', quiet: options.quiet })
+  await runTasks(tasks, { label: 'pack build' })
 }
 
 export async function runBuild(context, options = {}) {
@@ -140,6 +136,6 @@ export async function runBuild(context, options = {}) {
   if (context.hasOpenCard) {
     tasks.push({ name: 'opencard', run: () => buildOpenCard(context, buildOptions) })
   }
-  await runTasks(tasks, { label: 'build', quiet: buildOptions.quiet })
-  validateRoutes(context, { quiet: buildOptions.quiet })
+  await runTasks(tasks, { label: 'build' })
+  validateRoutes(context)
 }

package/src/commands/db.mjs

@@ -10,6 +10,5 @@ export async function runDatabaseInit(context, options = {}) {
     cwd: context.serverRoot,
     env: options.env,
     label: 'database initialization',
-    quiet: options.quiet,
   })
 }

package/src/commands/lint.mjs

@@ -106,21 +106,21 @@ export async function lintOpenCard(context, options = {}) {
     { name: 'opencard-structure', run: async () => validateOpenCardStructure(validationContext) },
     { name: 'opencard-widget-shell', run: async () => validateWidgetShell(validationContext) },
     { name: 'opencard-lynx-css', run: () => runLynxCss(root, options.lintProject) },
-    { name: 'opencard-tsc', run: () => runProcess(tsc, ['--noEmit'], { cwd: root, quiet: options.quiet }) },
+    { name: 'opencard-tsc', run: () => runProcess(tsc, ['--noEmit'], { cwd: root }) },
   ]
   if (eslintSelection.runEslint) {
     tasks.push({
       name: 'opencard-eslint',
-      run: () => runProcess(eslint, eslintArgs, { cwd: root, quiet: options.quiet }),
+      run: () => runProcess(eslint, eslintArgs, { cwd: root }),
     })
   }
-  await runTasks(tasks, { label: 'opencard lint', quiet: options.quiet })
+  await runTasks(tasks, { label: 'opencard lint' })
 }
 
 export async function runLint(context, options = {}) {
   const incremental = options.incremental || process.env.LINT_INCREMENTAL === '1'
   if (context.target === 'opencard') {
-    await lintOpenCard(context, { incremental, quiet: options.quiet })
+    await lintOpenCard(context, { incremental })
     return
   }
 
@@ -142,8 +142,8 @@ export async function runLint(context, options = {}) {
   const tasks = []
   if (full || changed.some((file) => file.startsWith('src/'))) {
     tasks.push(
-      { name: 'taro-tsc', run: () => runProcess(tsc, ['--noEmit'], { cwd: context.root, quiet: options.quiet }) },
-      { name: 'taro-eslint', run: () => runProcess(eslint, eslintArgs, { cwd: context.root, quiet: options.quiet }) },
+      { name: 'taro-tsc', run: () => runProcess(tsc, ['--noEmit'], { cwd: context.root }) },
+      { name: 'taro-eslint', run: () => runProcess(eslint, eslintArgs, { cwd: context.root }) },
     )
   }
   if (full || serverChanged || closedDomainChanged) {
@@ -156,7 +156,7 @@ export async function runLint(context, options = {}) {
     tasks.push({
       name: 'server-lint',
       run: () => runTasks([
-        { name: 'server-tsc', run: () => runProcess(tsc, ['--noEmit'], { cwd: context.serverRoot, quiet: options.quiet }) },
+        { name: 'server-tsc', run: () => runProcess(tsc, ['--noEmit'], { cwd: context.serverRoot }) },
         {
           name: 'server-eslint',
           run: () => runProcess(eslint, [
@@ -164,16 +164,13 @@ export async function runLint(context, options = {}) {
             '--cache-location',
             'node_modules/.cache/eslint/server-src',
             'src/**/*.{js,jsx,ts,tsx}',
-          ], { cwd: context.serverRoot, quiet: options.quiet }),
+          ], { cwd: context.serverRoot }),
         },
-      ], { label: 'server lint', quiet: options.quiet }),
+      ], { label: 'server lint' }),
     })
   }
   if (context.hasOpenCard && (full || changed.some((file) => file.startsWith('opencard/')))) {
-    tasks.push({
-      name: 'opencard-lint',
-      run: () => lintOpenCard(context, { incremental: !full, quiet: options.quiet }),
-    })
+    tasks.push({ name: 'opencard-lint', run: () => lintOpenCard(context, { incremental: !full }) })
   }
-  await runTasks(tasks, { label: 'lint', quiet: options.quiet })
+  await runTasks(tasks, { label: 'lint' })
 }

package/src/commands/validate.mjs

@@ -2,9 +2,10 @@ import { UsageError } from '../core/errors.mjs'
 import { validateFeedCard } from '../validators/feed-card.mjs'
 import { validateNonEmptyTaro } from '../validators/empty-project.mjs'
 import { validateOpenCardStructure } from '../validators/opencard-structure.mjs'
+import { validatePackageSize } from '../validators/package-size.mjs'
 import { validateRoutes } from '../validators/routes.mjs'
 
-export async function runValidate(context, validator) {
+export async function runValidate(context, validator, options = {}) {
   switch (validator) {
     case 'feed-card':
       validateFeedCard(context)
@@ -18,9 +19,11 @@ export async function runValidate(context, validator) {
     case 'opencard-structure':
       validateOpenCardStructure(context)
       return
+    case 'package-size':
+      return validatePackageSize(context, options)
     default:
       throw new UsageError(
-        `Unknown validator: ${validator || '<missing>'}\nAvailable validators: feed-card, routes, empty, opencard-structure`,
+        `Unknown validator: ${validator || '<missing>'}\nAvailable validators: feed-card, routes, empty, opencard-structure, package-size`,
       )
   }
 }

package/src/commands/verify.mjs

@@ -13,6 +13,7 @@ import { runBuild } from './build.mjs'
 import { runDatabaseInit } from './db.mjs'
 import { runLint } from './lint.mjs'
 import { validateServerArtifactFileCount } from '../validators/server-artifact.mjs'
+import { validatePackageSize } from '../validators/package-size.mjs'
 
 const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms))
 const devLauncher = fileURLToPath(new URL('../../bin/vibecoding', import.meta.url))
@@ -33,23 +34,22 @@ async function runStatic(context) {
   validateDependencies(context)
   const env = await readRuntimeEnvironment(context.root)
   const tasks = [
-    { name: 'lint', run: () => runLint(context, { quiet: true }) },
-    { name: 'build', run: () => runBuild(context, { frontendTarget: 'tt', quiet: true }) },
+    { name: 'lint', run: () => runLint(context) },
+    { name: 'build', run: () => runBuild(context, { frontendTarget: 'tt' }) },
   ]
   if (context.target === 'taro') {
     tasks.push(
-      { name: 'database', run: () => runDatabaseInit(context, { env, quiet: true }) },
-      { name: 'feed-card', run: async () => validateFeedCard(context, { quiet: true }) },
+      { name: 'database', run: () => runDatabaseInit(context, { env }) },
+      { name: 'feed-card', run: async () => validateFeedCard(context) },
     )
   }
-  await runTasks(tasks, { label: 'static verification', quiet: true })
+  await runTasks(tasks, { label: 'static verification' })
   if (context.target === 'taro') {
     validateServerArtifactFileCount(context.serverRoot ?? path.join(context.root, 'server'), {
       packScriptPath: path.join(context.root, 'scripts/pack.sh'),
-      quiet: true,
     })
   }
-  console.log('[verify] Static phase passed (all parallel tasks OK).')
+  await validatePackageSize(context)
 }
 
 export function startDevDetached(context, spawnProcess = spawn) {
@@ -625,31 +625,19 @@ export async function runVerify(context, options = {}) {
   options = { timeoutSeconds: 90, ...options, full }
   const frontendUrl = resolveFrontendUrl(context, options)
   parseHttpUrl(frontendUrl, 'frontend')
-  if (full || options.staticOnly) {
-    await runStatic(context)
-  }
-  if (options.staticOnly) {
-    console.log('[verify] --static-only: done.')
-    return
-  }
+  if (full || options.staticOnly) await runStatic(context)
+  if (options.staticOnly) return
 
   await verifyPorts(context, options, frontendUrl)
-  if (options.portsOnly) {
-    console.log('[verify] --ports-only: done.')
-    return
-  }
-  if (full && context.target === 'taro') {
-    await verifyFeedApi(context)
-  }
+  if (options.portsOnly) return
+  if (full && context.target === 'taro') await verifyFeedApi(context)
   if (context.target === 'taro' &&
       existsSync(path.resolve(context.root, '../sar_game/package.json'))) {
     console.log('[vibecoding:verify] SAR game project detected; skipping browser runtime checks')
-    console.log('[verify] All checks passed.')
     return
   }
   await browserCheck(context.root, frontendUrl, context.target)
   if (context.target === 'taro' && context.hasOpenCard) {
     await browserCheck(context.opencardRoot, 'http://localhost:10087/', 'opencard')
   }
-  console.log('[verify] All checks passed.')
 }

package/src/core/args.mjs

@@ -9,10 +9,11 @@ const BOOLEAN_FLAGS = new Set([
   'skip-install',
   'skip-root-install',
   'incremental',
+  'json',
   'help',
 ])
 
-const VALUE_FLAGS = new Set(['target', 'cwd', 'timeout', 'frontend-url', 'scope'])
+const VALUE_FLAGS = new Set(['target', 'cwd', 'timeout', 'frontend-url', 'scope', 'tma'])
 
 export function parseArgs(argv) {
   const positionals = []

package/src/core/runner.mjs

@@ -12,49 +12,28 @@ export function resolveSdkTaroEntry(root) {
   return createRequire(path.join(root, 'package.json')).resolve('@open-dy/vibecoding-sdk-opencard/build/taro-toolchain')
 }
 
-function withCapturedOutput(message, stdout, stderr) {
-  if (!stdout && !stderr) return message
-  const separator = stdout && stderr && !stdout.endsWith('\n') ? '\n' : ''
-  return `${message}\n${stdout}${separator}${stderr}`
-}
-
 export function runProcess(command, args = [], options = {}) {
   const label = options.label ?? path.basename(command)
   return new Promise((resolve, reject) => {
-    const captureOutput = options.quiet && options.stdio === undefined
     const child = spawn(command, args, {
       cwd: options.cwd,
       env: { ...process.env, ...options.env },
-      stdio: captureOutput ? ['ignore', 'pipe', 'pipe'] : (options.stdio ?? 'inherit'),
+      stdio: options.stdio ?? 'inherit',
       detached: options.detached ?? false,
       shell: options.shell ?? false,
     })
-    let stdout = ''
-    let stderr = ''
-    if (captureOutput) {
-      child.stdout.setEncoding('utf8')
-      child.stderr.setEncoding('utf8')
-      child.stdout.on('data', (chunk) => { stdout += chunk })
-      child.stderr.on('data', (chunk) => { stderr += chunk })
-    }
 
     child.on('error', (error) => {
-      reject(new CliError(withCapturedOutput(
-        `${label} failed to start: ${error.message}`,
-        stdout,
-        stderr,
-      )))
+      reject(new CliError(`${label} failed to start: ${error.message}`))
     })
     child.on('exit', (code, signal) => {
       if (code === 0) {
         resolve({ code: 0, signal, child })
         return
       }
-      reject(new CliError(withCapturedOutput(
+      reject(new CliError(
         `${label} failed${signal ? ` with signal ${signal}` : ` with exit code ${code}`}`,
-        stdout,
-        stderr,
-      )))
+      ))
     })
   })
 }
@@ -99,9 +78,9 @@ export function runCaptured(command, args = [], options = {}) {
 export async function runTasks(tasks, options = {}) {
   const results = await Promise.allSettled(
     tasks.map(async ({ name, run }) => {
-      if (!options.quiet) console.log(`[vibecoding] starting ${name}`)
+      console.log(`[vibecoding] starting ${name}`)
       await run()
-      if (!options.quiet) console.log(`[vibecoding] completed ${name}`)
+      console.log(`[vibecoding] completed ${name}`)
       return name
     }),
   )

package/src/validators/feed-card.cjs

@@ -149,7 +149,7 @@ function validateFeedCard(context, options = {}) {
     }
   }
 
-  if (!options.quiet) console.log("All validations passed!");
+  console.log("All validations passed!");
   return { skipped: false };
 }
 

package/src/validators/package-size.mjs

@@ -0,0 +1,248 @@
+import { spawnSync } from 'node:child_process'
+import { accessSync, constants, existsSync, mkdirSync, statSync } from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import { CliError } from '../core/errors.mjs'
+import { runCaptured } from '../core/runner.mjs'
+
+const MB = 1024 * 1024
+export const PACKAGE_SIZE_LIMITS = Object.freeze({
+  totalMax: 16 * MB,
+})
+export const TT_IDE_CLI_SPEC = 'tt-ide-cli@0.1.34'
+const INSTALL_TIMEOUT_MS = 180_000
+const TMA_TIMEOUT_MS = 60_000
+
+export function formatPackageBytes(bytes) {
+  const value = Number(bytes) || 0
+  if (value < 1024) return `${value} B`
+  if (value < MB) return `${(value / 1024).toFixed(1)} KB`
+  return `${(value / MB).toFixed(2)} MB`
+}
+
+export function extractJsonObject(text) {
+  const raw = String(text || '')
+  const start = raw.indexOf('{')
+  const end = raw.lastIndexOf('}')
+  if (start < 0 || end <= start) return null
+  return raw.slice(start, end + 1)
+}
+
+export function parseProjectSizeOutput(stdout, stderr = '') {
+  const combined = `${stdout || ''}\n${stderr || ''}`
+  if (/Bad Project Type/i.test(combined)) {
+    throw new CliError(
+      'tma project-size reported Bad Project Type: run it on tt build artifacts (dist-tt or opencard/dist), not source',
+    )
+  }
+  const jsonText = extractJsonObject(stdout) || extractJsonObject(stderr)
+  if (!jsonText) {
+    const preview = combined.replace(/\s+/g, ' ').trim().slice(0, 240)
+    throw new CliError(`Unable to parse tma project-size --json output${preview ? `: ${preview}` : ''}`)
+  }
+  let report
+  try {
+    report = JSON.parse(jsonText)
+  } catch {
+    throw new CliError(`Invalid tma project-size JSON: ${jsonText.slice(0, 240)}`)
+  }
+  if (!report || typeof report !== 'object' || typeof report.total !== 'number') {
+    throw new CliError(`tma project-size JSON is missing total: ${jsonText.slice(0, 240)}`)
+  }
+  return report
+}
+
+export function evaluateSizeReport(report, limits = PACKAGE_SIZE_LIMITS) {
+  const total = Number(report?.total) || 0
+  const failures = []
+  if (total > limits.totalMax) {
+    failures.push(`total package ${formatPackageBytes(total)} exceeds ${formatPackageBytes(limits.totalMax)}`)
+  }
+  return { ok: failures.length === 0, failures, total }
+}
+
+export function collectPackageSizeTargets(context) {
+  if (context.target === 'opencard') {
+    return [{
+      id: 'opencard',
+      label: 'OpenCard',
+      artifactRel: 'dist',
+      artifactDir: path.join(context.root, 'dist'),
+    }]
+  }
+  const targets = [{
+    id: 'landing-page',
+    label: 'landing page',
+    artifactRel: 'dist-tt',
+    artifactDir: path.join(context.root, 'dist-tt'),
+  }]
+  if (context.hasOpenCard && context.opencardRoot) {
+    targets.push({
+      id: 'interest-card',
+      label: 'interest card',
+      artifactRel: 'opencard/dist',
+      artifactDir: path.join(context.opencardRoot, 'dist'),
+    })
+  }
+  return targets
+}
+
+function findOnPath(name, env = process.env) {
+  const executableName = process.platform === 'win32' ? `${name}.cmd` : name
+  for (const directory of (env.PATH || '').split(path.delimiter)) {
+    const executable = path.resolve(directory || '.', executableName)
+    try {
+      accessSync(executable, constants.X_OK)
+      if (statSync(executable).isFile()) return executable
+    } catch {}
+  }
+  return ''
+}
+
+export function resolveCacheRoot(env = process.env) {
+  if (existsSync('/workspace')) {
+    const workspaceTmp = '/workspace/tmp'
+    mkdirSync(workspaceTmp, { recursive: true })
+    return workspaceTmp
+  }
+  return env.TMPDIR || os.tmpdir()
+}
+
+function resolveNpmBin() {
+  const sibling = path.join(path.dirname(process.execPath), process.platform === 'win32' ? 'npm.cmd' : 'npm')
+  if (existsSync(sibling)) return sibling
+  return findOnPath('npm') || 'npm'
+}
+
+export function resolveTmaBin(options = {}) {
+  if (options.tmaBin) {
+    if (!existsSync(options.tmaBin)) {
+      throw new CliError(`--tma path does not exist: ${options.tmaBin}`)
+    }
+    return options.tmaBin
+  }
+  const fromPath = findOnPath('tma', options.env)
+  if (fromPath) return fromPath
+
+  const cacheRoot = options.cacheRoot ?? resolveCacheRoot(options.env)
+  const prefix = path.join(cacheRoot, 'tt-ide-cli')
+  const bin = path.join(prefix, 'node_modules', '.bin', process.platform === 'win32' ? 'tma.cmd' : 'tma')
+  if (existsSync(bin)) return bin
+
+  mkdirSync(prefix, { recursive: true })
+  const npmCache = path.join(cacheRoot, 'npm-cache')
+  mkdirSync(npmCache, { recursive: true })
+  const env = {
+    ...process.env,
+    ...options.env,
+    npm_config_cache: npmCache,
+    npm_config_fund: 'false',
+    npm_config_audit: 'false',
+    npm_config_update_notifier: 'false',
+  }
+  const registries = [
+    env.NPM_CONFIG_REGISTRY,
+    env.npm_config_registry,
+    'https://bnpm.byted.org',
+    'https://registry.npmmirror.com/',
+  ].filter((value, index, list) => value && list.indexOf(value) === index)
+  const npmBin = resolveNpmBin()
+  const errors = []
+  const runCommand = options.runCommand ?? ((command, args, spawnOptions) => spawnSync(command, args, spawnOptions))
+  for (const registry of registries) {
+    const result = runCommand(npmBin, ['install', TT_IDE_CLI_SPEC, '--prefix', prefix, '--registry', registry], {
+      env,
+      encoding: 'utf8',
+      timeout: INSTALL_TIMEOUT_MS,
+    })
+    if ((result.status === 0) && existsSync(bin)) return bin
+    const detail = String(result.stderr || result.stdout || `exit ${result.status}`).trim().slice(0, 400)
+    errors.push(`${registry}: ${detail}`)
+  }
+  throw new CliError(
+    `Unable to install ${TT_IDE_CLI_SPEC} for tma project-size. Confirm npm registry access, or put tma on PATH / pass --tma.\n${errors.join('\n')}`,
+  )
+}
+
+function artifactReady(artifactDir) {
+  return existsSync(path.join(artifactDir, 'app.json')) && (
+    existsSync(path.join(artifactDir, 'app.js')) || existsSync(path.join(artifactDir, 'app.ts'))
+  )
+}
+
+async function defaultRunTma(tmaBin, artifactDir) {
+  return runCaptured(tmaBin, ['project-size', '--json', artifactDir], {
+    allowFailure: true,
+    timeoutMs: TMA_TIMEOUT_MS,
+    label: 'tma project-size',
+  })
+}
+
+/**
+ * @desc 校验 tt 构建产物包体积，必须对 dist-tt / opencard/dist 执行，不能对源码目录执行。
+ * @params {object} context CLI 工程上下文。
+ * @params {object} [options] 可选 tma 路径、JSON 输出和测试注入。
+ * @return {Promise<object>} 各产物的体积判定；超限或缺产物时抛出 CliError。
+ * @example await validatePackageSize(context)
+ */
+export async function validatePackageSize(context, options = {}) {
+  const targets = collectPackageSizeTargets(context)
+  const tmaBin = options.resolveTma
+    ? await options.resolveTma()
+    : resolveTmaBin({ tmaBin: options.tmaBin, env: options.env, runCommand: options.runCommand })
+  const runTma = options.runTma ?? defaultRunTma
+  const results = []
+
+  for (const target of targets) {
+    const entry = { id: target.id, label: target.label, artifact: target.artifactRel, ok: false }
+    try {
+      if (!existsSync(target.artifactDir)) {
+        throw new CliError(
+          `Missing tt artifact directory ${target.artifactRel}. Run pnpm build:tt (or pnpm verify) first.`,
+        )
+      }
+      if (!artifactReady(target.artifactDir)) {
+        throw new CliError(
+          `${target.artifactRel} is not a complete tt artifact (missing app.json / app.js). Do not run tma project-size on source or H5 dist.`,
+        )
+      }
+      const output = await runTma(tmaBin, target.artifactDir)
+      const report = parseProjectSizeOutput(output?.stdout, output?.stderr)
+      const evaluated = evaluateSizeReport(report)
+      entry.total = evaluated.total
+      entry.ok = evaluated.ok
+      if (!evaluated.ok) {
+        entry.failures = evaluated.failures
+        throw new CliError(evaluated.failures.join('; '))
+      }
+      console.log(
+        `[vibecoding:package-size] OK ${target.label}: ${formatPackageBytes(evaluated.total)} / ${formatPackageBytes(PACKAGE_SIZE_LIMITS.totalMax)}`,
+      )
+    } catch (error) {
+      entry.ok = false
+      entry.message = error instanceof Error ? error.message : String(error)
+      console.error(`[vibecoding:package-size] FAIL ${target.label}: ${entry.message}`)
+    }
+    results.push(entry)
+  }
+
+  const ok = results.length > 0 && results.every((item) => item.ok)
+  const payload = { ok, limits: PACKAGE_SIZE_LIMITS, tma: tmaBin, targets: results }
+  if (options.json) {
+    console.log(JSON.stringify({
+      ok: payload.ok,
+      limits: payload.limits,
+      targets: payload.targets,
+    }, null, 2))
+  }
+  if (!ok) {
+    const details = results
+      .filter((item) => !item.ok)
+      .map((item) => `${item.label} (${item.artifact}): ${item.message}`)
+      .join('\n')
+    throw new CliError(
+      `Package size check failed.\n${details}\nMove large images/audio/static assets to CDN, rebuild tt artifacts, then re-run.`,
+    )
+  }
+  return payload
+}

package/src/validators/routes.cjs

@@ -3,7 +3,6 @@ const path = require('path');
 
 function validateRoutes(context, options = {}) {
 if (context.target !== 'taro') return;
-const quiet = Boolean(options.quiet);
 const ROOT = context.root;
 const routesDir = options.routesDir || '/tmp/routes';
 const CLIENT_FILE = path.join(routesDir, 'client-routes.json');
@@ -403,7 +402,7 @@ function main() {
   const closedDomainServerRoutes = loadClosedDomainServerRoutes();
   const cardRoutingConfig = loadCardRoutingConfig();
 
-  if (!quiet) console.log('=== 前后端路由一致性检测报告 ===\n');
+  console.log('=== 前后端路由一致性检测报告 ===\n');
 
   assertOpenDomainServerDoesNotCallClosedDomainOpenAPI();
 
@@ -452,7 +451,7 @@ function main() {
     }
   }
 
-  if (!quiet) console.log('--- 检测结果 ---\n');
+  console.log('--- 检测结果 ---\n');
 
   if (mismatched.length > 0) {
     console.error(`未匹配（${mismatched.length} 条）：以下前端请求路径未匹配到所选服务域的服务端路由，请检查前端请求路径、服务域配置，或确认服务端已注册对应路由`);
@@ -461,7 +460,7 @@ function main() {
     }
     throw new Error('前后端路由一致性检测失败');
   } else {
-    if (!quiet) console.log('所有前端静态请求路径均已在服务端注册对应路由，检测通过。');
+    console.log('所有前端静态请求路径均已在服务端注册对应路由，检测通过。');
   }
 }
 

package/src/validators/server-artifact.mjs

@@ -63,7 +63,7 @@ function countFiles(target, policy) {
     (policy.excludes && isServerPackExcluded(name, policy) ? 0 : countFiles(path.join(target, name), policy)), 0)
 }
 
-export function validateServerArtifactFileCount(serverRoot, { packScriptPath, quiet = false } = {}) {
+export function validateServerArtifactFileCount(serverRoot, { packScriptPath } = {}) {
   if (!existsSync(serverRoot)) throw new CliError(`Server directory is missing: ${serverRoot}`)
   let policy = DEFAULT_POLICY
   if (packScriptPath) {
@@ -84,8 +84,6 @@ export function validateServerArtifactFileCount(serverRoot, { packScriptPath, qu
   if (count > MAX_FILE_COUNT) {
     throw new CliError(`Packed server artifact ${serverRoot} would contain ${count} files, exceeding the limit ${MAX_FILE_COUNT}. This count follows the server pack policy. Reduce files included by pack before submission.`)
   }
-  if (!quiet) {
-    console.log(`[verify] static:server-artifact-file-count → OK (${count}/${MAX_FILE_COUNT}, ${serverRoot}).`)
-  }
+  console.log(`[verify] static:server-artifact-file-count → OK (${count}/${MAX_FILE_COUNT}, ${serverRoot}).`)
   return { skipped: false, count, missing: [] }
 }