@open-dy/vibecoding-cli 0.0.1-beta.1

package/src/preview/watch-card-routing.mjs

@@ -0,0 +1,89 @@
+import { watchFile, unwatchFile, readFileSync } from 'node:fs'
+import { resolveCardRoutingPath, openCardBuildEnvironment } from '../build/opencard-environment.mjs'
+
+// Polling follows atomic file replacements and also works when config/ is absent
+// at startup. Debouncing avoids restarting while an editor is still saving.
+export async function startRoutingPreview({ root, start, onError = console.error, signal, pollMs = 250, debounceMs = 150 }) {
+  const context = { root }
+  const file = resolveCardRoutingPath(context)
+  let mode = openCardBuildEnvironment(context).IS_CARD_CLOSED_DOMAIN
+  const controller = new AbortController()
+  const cancelStart = () => controller.abort()
+  signal?.addEventListener('abort', cancelStart, { once: true })
+  if (signal?.aborted) controller.abort()
+  async function launch(value) {
+    const runtime = await start({ IS_CARD_CLOSED_DOMAIN: value }, controller.signal)
+    let closing
+    return { ...runtime, close: () => (closing ??= Promise.resolve().then(() => runtime.close())) }
+  }
+  let current
+  try {
+    current = await launch(mode)
+  } catch (error) {
+    signal?.removeEventListener('abort', cancelStart)
+    throw error
+  }
+  let stopped = false
+  let timer
+  let queue = Promise.resolve()
+  let lastError
+
+  function readMode() {
+    // During watching, deletion/incomplete saves must not become an open default.
+    const routing = JSON.parse(readFileSync(file, 'utf8'))
+    const domain = routing?.cardData?.serviceDomain
+    if (!['closed', 'open', 'none'].includes(domain)) throw new Error(`${file}: cardData.serviceDomain must be closed, open, or none`)
+    return String(domain === 'closed')
+  }
+  async function refresh() {
+    if (stopped) return
+    let next
+    try {
+      next = readMode()
+      lastError = undefined
+    } catch (error) {
+      if (lastError !== error.message) console.error(`[opencard] Routing unchanged: ${error.message}`)
+      lastError = error.message
+      return
+    }
+    if (mode === next) return
+    console.log(`[opencard] Domain changed; restarting preview (closed=${next})`)
+    await current.close()
+    if (stopped) return
+    current = await launch(next)
+    mode = next
+    if (stopped) await current.close()
+  }
+  function changed() {
+    clearTimeout(timer)
+    timer = setTimeout(() => {
+      queue = queue.then(refresh).catch(error => {
+        if (!stopped) { onError(error); void close().catch(onError) }
+      })
+    }, debounceMs)
+  }
+  watchFile(file, { interval: pollMs }, changed)
+  // Catch a save that happened while the first compiler was starting.
+  changed()
+  let closing
+  function close() {
+    if (closing) return closing
+    stopped = true
+    controller.abort()
+    clearTimeout(timer)
+    unwatchFile(file, changed)
+    signal?.removeEventListener('abort', abort)
+    signal?.removeEventListener('abort', cancelStart)
+    closing = (async () => { await current.close(); await queue })()
+    return closing
+  }
+  function abort() { void close().catch(onError) }
+  signal?.addEventListener('abort', abort, { once: true })
+  if (signal?.aborted) await close()
+  return {
+    get child() { return current.child },
+    get runtime() { return current.runtime },
+    get port() { return current.port },
+    close,
+  }
+}

package/src/scripts/pack.mjs

@@ -0,0 +1,15 @@
+#!/usr/bin/env node
+import { runPack } from '../commands/pack.mjs'
+
+// Compatibility entry for scripts/pack.sh: do not source .env.dev or .bashrc,
+// let runPack resolve ARTIFACTS_DIR with the standard default fallback.
+const root = process.argv[2]
+if (!root) {
+  console.error('Missing project root')
+  process.exitCode = 2
+} else {
+  runPack({ root, target: 'taro' }).catch(error => {
+    console.error(error.message)
+    process.exitCode = error.exitCode ?? 1
+  })
+}

package/src/validators/dependencies.mjs

@@ -0,0 +1,34 @@
+import { existsSync, readFileSync } from 'node:fs'
+import path from 'node:path'
+import { CliError } from '../core/errors.mjs'
+
+const FIELDS = ['dependencies', 'devDependencies', 'optionalDependencies', 'peerDependencies']
+const FORBIDDEN = ['three', '@types/three']
+
+export function packageUses(root, name) {
+  try {
+    const manifest = JSON.parse(readFileSync(path.join(root, 'package.json'), 'utf8'))
+    return FIELDS.some((field) => Boolean(manifest[field]?.[name]))
+  } catch { return false }
+}
+
+export function validateDependencies(context) {
+  const roots = context.target === 'opencard'
+    ? [context.root]
+    : [context.root, ...(context.hasOpenCard ? [context.opencardRoot] : [])]
+  const issues = []
+  for (const root of roots) {
+    if (!existsSync(path.join(root, 'package.json'))) continue
+    const manifest = JSON.parse(readFileSync(path.join(root, 'package.json'), 'utf8'))
+    for (const field of FIELDS) {
+      for (const name of FORBIDDEN) {
+        if (manifest[field]?.[name]) issues.push(`${path.join(root, 'package.json')}: ${field}.${name}`)
+      }
+    }
+  }
+  if (issues.length > 0) {
+    throw new CliError(
+      `Unsupported web Three.js dependencies found:\n${issues.map((item) => `- ${item}`).join('\n')}\nUse @open-dy/threejs instead.`,
+    )
+  }
+}

package/src/validators/empty-project.mjs

@@ -0,0 +1,29 @@
+import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs'
+import path from 'node:path'
+import { CliError } from '../core/errors.mjs'
+
+// Keep the generated-project guard aligned with both source templates.  The
+// interest-card template used a different empty-page copy before this check
+// moved into the shared CLI, so one generic signature pair is not enough.
+const EMPTY_TEMPLATE_SIGNATURE_SETS = [
+  ['这是一个空白的小程序示意', '你可以继续描述对小程序的需求～'],
+  ['这是一个空白的兴趣卡落地页示意', '你可以继续描述对兴趣卡落地页的需求～'],
+]
+
+export function validateNonEmptyTaro(context) {
+  if (context.target !== 'taro') return
+  const pages = path.join(context.root, 'src/pages')
+  const index = path.join(pages, 'index/index.tsx')
+  if (!existsSync(index)) return
+  if (existsSync(pages)) {
+    const hasOtherPage = readdirSync(pages).some((name) =>
+      name !== 'index' && statSync(path.join(pages, name)).isDirectory(),
+    )
+    if (hasOtherPage) return
+  }
+  const content = readFileSync(index, 'utf8')
+  if (EMPTY_TEMPLATE_SIGNATURE_SETS.some((signatures) =>
+    signatures.every((signature) => content.includes(signature)))) {
+    throw new CliError('The Taro project still contains the empty template page')
+  }
+}

package/src/validators/feed-card.cjs

@@ -0,0 +1,156 @@
+const fs = require("node:fs");
+const path = require("node:path");
+const Ajv = require("ajv");
+
+function failFast(message) {
+  throw new Error(`\n[Validation Failed] ${message}`);
+}
+
+function reportAndExit(errors) {
+  failFast(
+    `Found ${errors.length} issue(s). Please fix ALL of them in a single revision before re-running validation.\n\n` +
+      errors.map((error, index) => `(${index + 1}) ${error}\n`).join("\n"),
+  );
+}
+
+function readCardDataServiceDomain(projectRoot) {
+  const routingPath = path.join(projectRoot, "config", "card-routing.json");
+  if (!fs.existsSync(routingPath)) {
+    failFast(
+      `Missing ${routingPath}. Cannot choose a Feed card Schema until cardData.serviceDomain declares open or closed.`,
+    );
+  }
+
+  let routing;
+  try {
+    routing = JSON.parse(fs.readFileSync(routingPath, "utf8"));
+  } catch (error) {
+    failFast(`Invalid JSON in ${routingPath}: ${error.message}`);
+  }
+
+  const serviceDomain = routing?.cardData?.serviceDomain;
+  if (serviceDomain !== "open" && serviceDomain !== "closed") {
+    failFast(
+      `${routingPath} must declare cardData.serviceDomain as "open" or "closed" before validating feed-card.json; got ${JSON.stringify(serviceDomain)}.`,
+    );
+  }
+  return serviceDomain;
+}
+
+function resolveFeedCardSchema(projectRoot) {
+  // card-routing.json is the sole source of truth for the selected service
+  // domain. Both domains share the custom Feed card data contract; keep
+  // project-local constraints when present; newly generated projects can rely
+  // on the schema shipped with the CLI.
+  readCardDataServiceDomain(projectRoot);
+  const schemaName = "custom-card-schema.json";
+  const schemaPath = [
+    path.join(projectRoot, "scripts", "schemas", schemaName),
+    path.join(projectRoot, "feed", schemaName),
+  ].find((candidate) => fs.existsSync(candidate)) ??
+    path.resolve(__dirname, "../../assets/schemas", schemaName);
+  if (!fs.existsSync(schemaPath)) {
+    failFast(`Schema file missing on disk: ${schemaPath}`);
+  }
+  return schemaPath;
+}
+
+function validateFeedCard(context, options = {}) {
+  if (context.target !== "taro") {
+    throw new Error("Feed card validation requires --target taro");
+  }
+  const projectRoot = context.root;
+  const appId = process.env.APP_ID || "";
+  const cardAppId = process.env.OPEN_CARD_ID || "";
+
+  const jsonPath = path.join(projectRoot, "feed/feed-card.json");
+  const opencardDir = path.join(projectRoot, "opencard");
+  const hasOpencard = fs.existsSync(opencardDir);
+  const hasFeedCard = fs.existsSync(jsonPath);
+
+  if (hasOpencard && !hasFeedCard) {
+    failFast(
+      `Missing ${jsonPath} while opencard/ exists.\n  Fix: Read config/card-routing.json first, then generate feed/feed-card.json with the matching Feed card Schema.`,
+    );
+  }
+
+  if (!hasFeedCard) {
+    return { skipped: true };
+  }
+
+  let data;
+  try {
+    const fileContent = fs.readFileSync(jsonPath, "utf8");
+    data = JSON.parse(fileContent);
+  } catch (e) {
+    failFast(
+      `Invalid JSON syntax in ${jsonPath}: ${e.message}\n  Fix: Check trailing commas, unmatched brackets, unescaped quotes, and re-emit syntactically valid JSON.`,
+    );
+  }
+
+  const templateType = data?.TemplateType;
+  const templateStyleType = data?.TemplateStyleType;
+
+  if (templateType !== 5 || templateStyleType !== 6) {
+    failFast(
+      `Only custom feed card is supported: expected TemplateType=5 and TemplateStyleType=6, got TemplateType=${JSON.stringify(templateType)}, TemplateStyleType=${JSON.stringify(templateStyleType)}.\n  Fix: Regenerate feed-card.json using the Schema selected from the project's real service-domain configuration.`,
+    );
+  }
+
+  if (!hasOpencard) {
+    failFast(
+      `feed-card.json declares a custom Feed card (TemplateStyleType=6) but opencard/ is missing.\n  Fix: Install the opencard sub-app (see install-opencard.sh) before shipping the custom card.`,
+    );
+  }
+
+  const schemaPath = resolveFeedCardSchema(projectRoot);
+
+  const errors = [];
+
+  if (appId && data.AppID !== appId) {
+    errors.push(
+      `AppID mismatch: expected "${appId}", got "${data.AppID}".\n  Fix: Update AppID to "${appId}" and regenerate PageURL so its query parameters reflect the new AppID.`,
+    );
+  }
+
+  if (cardAppId && data.CardAppID !== cardAppId) {
+    errors.push(
+      `CardAppID mismatch: expected "${cardAppId}", got "${data.CardAppID}".\n  Fix: Update CardAppID to "${cardAppId}" (custom feed card requires this exact value).`,
+    );
+  }
+
+  try {
+    const schema = JSON.parse(fs.readFileSync(schemaPath, "utf8"));
+    const ajv = new Ajv({ allErrors: true, unicodeRegExp: true });
+    const validate = ajv.compile(schema);
+    if (!validate(data)) {
+      errors.push(
+        `JSON Schema validation failed (schema: ${path.basename(schemaPath)}). Raw ajv errors:\n` +
+          JSON.stringify(validate.errors, null, 2) +
+          "\n  Fix: For each error above, locate the offending field via the instancePath, and adjust value/type/length/enum to satisfy the rule. All listed errors must be fixed together.",
+      );
+    }
+  } catch (error) {
+    errors.push(
+      `JSON Schema validation failed (schema: ${path.basename(schemaPath)}). ${error.message}`,
+    );
+  }
+
+  if (errors.length > 0) {
+    reportAndExit(errors);
+  }
+
+  if (options.touchTimestamp !== false) {
+    data.__timestamp = Date.now();
+    try {
+      fs.writeFileSync(jsonPath, JSON.stringify(data, null, 2), "utf8");
+    } catch {
+      // Match the template validator: timestamp updates are best-effort.
+    }
+  }
+
+  console.log("All validations passed!");
+  return { skipped: false };
+}
+
+module.exports = { resolveFeedCardSchema, validateFeedCard };

package/src/validators/feed-card.mjs

@@ -0,0 +1,32 @@
+// Share one implementation with the synchronous legacy template entry point.
+import validator from './feed-card.cjs'
+import { CliError } from '../core/errors.mjs'
+
+function runValidation(callback) {
+  try {
+    return callback()
+  } catch (error) {
+    throw new CliError(error.message)
+  }
+}
+
+/**
+ * @desc 定位工程实际使用的 Feed 卡片 schema 文件。
+ * @params {string} projectRoot 工程根目录。
+ * @return {string} schema 文件的绝对路径。
+ * @example resolveFeedCardSchema(process.cwd())
+ */
+export function resolveFeedCardSchema(projectRoot) {
+  return runValidation(() => validator.resolveFeedCardSchema(projectRoot))
+}
+
+/**
+ * @desc 校验 Feed 卡片结构、字段和可发布性约束。
+ * @params {object} context CLI 工程上下文。
+ * @params {object} [options] 校验选项。
+ * @return {unknown} 校验器返回的结果；发现错误时抛出 CliError。
+ * @example validateFeedCard(context, { full: true })
+ */
+export function validateFeedCard(context, options = {}) {
+  return runValidation(() => validator.validateFeedCard(context, options))
+}

package/src/validators/opencard-structure.mjs

@@ -0,0 +1,58 @@
+import { existsSync, readFileSync, readdirSync } from 'node:fs'
+import path from 'node:path'
+import { CliError } from '../core/errors.mjs'
+
+const FORBIDDEN = ['app.ts', 'app.tsx', 'app.js', 'app.jsx']
+const TIMING = /__lynx_timing_flag\s*=\s*(["'])__lynx_timing_actual_fmp\1/g
+
+function walk(directory, files = []) {
+  if (!existsSync(directory)) return files
+  for (const entry of readdirSync(directory, { withFileTypes: true })) {
+    const target = path.join(directory, entry.name)
+    if (entry.isDirectory()) walk(target, files)
+    else if (/\.[jt]sx?$/.test(entry.name)) files.push(target)
+  }
+  return files
+}
+
+export function validateOpenCardStructure(context) {
+  const root = context.target === 'opencard' ? context.root : context.opencardRoot
+  if (!root) return { skipped: true }
+  const src = path.join(root, 'src')
+  const forbidden = FORBIDDEN.filter((name) => existsSync(path.join(src, name)))
+  if (forbidden.length > 0) {
+    throw new CliError(`OpenCard does not support App entry files: ${forbidden.join(', ')}`)
+  }
+
+  let timingCount = 0
+  for (const file of walk(src)) {
+    const content = readFileSync(file, 'utf8')
+    if (/\.[jt]sx$/.test(file)) timingCount += content.match(TIMING)?.length ?? 0
+  }
+  if (timingCount !== 1) {
+    throw new CliError(
+      `OpenCard src must contain exactly one Actual FMP timing flag; found ${timingCount}`,
+    )
+  }
+
+  let pageSource = ''
+  for (const file of walk(path.join(src, 'pages'))) {
+    pageSource += `\n${readFileSync(file, 'utf8')}`
+  }
+  const navigationCount = pageSource.match(/\bnavigateToMiniProgram\s*\(/g)?.length ?? 0
+  if (navigationCount > 0) {
+    const preloadCount = pageSource.match(/\.preloadMiniApp\s*\(\s*\{\s*appList\b/g)?.length ?? 0
+    if (
+      preloadCount !== 1 ||
+      !/\buseDidShow\s*\(/.test(pageSource) ||
+      !/\buseReady\s*\(/.test(pageSource)
+    ) {
+      throw new CliError(
+        `OpenCard found ${navigationCount} navigateToMiniProgram call(s); ` +
+        'requires exactly one preloadMiniApp guarded by useReady and first useDidShow; ' +
+        `found ${preloadCount} preload call(s)`,
+      )
+    }
+  }
+  return { skipped: false }
+}