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

package/src/commands/dev.mjs

@@ -0,0 +1,319 @@
+import { spawn } from 'node:child_process'
+import { mkdirSync, readFileSync } from 'node:fs'
+import path from 'node:path'
+import { readRuntimeEnvironment } from '../core/environment.mjs'
+import { CliError } from '../core/errors.mjs'
+import { clearPort } from '../core/ports.mjs'
+import { attachLabeledOutput } from '../core/process-output.mjs'
+import { runProcess } from '../core/runner.mjs'
+import { resolvePreviewPort, startPreview } from '../preview/start-preview.mjs'
+import { runDatabaseInit } from './db.mjs'
+
+export function assertDevSupervised(env = process.env) {
+  if (env.VIBECODING_DEV_SUPERVISED !== '1') {
+    throw new CliError(
+      'dev must be started through the vibecoding launcher so its process tree can be supervised',
+    )
+  }
+}
+
+function spawnManaged(command, args, { cwd, env, name, label = name }, children, fail) {
+  const child = spawn(command, args, {
+    cwd,
+    env: { ...process.env, ...env },
+    stdio: ['ignore', 'pipe', 'pipe'],
+    detached: true,
+  })
+  attachLabeledOutput(child, label)
+  const managed = { child, name, expectedExit: false }
+  children.push(managed)
+  child.on('error', (error) => fail(new CliError(`${name} failed to start: ${error.message}`)))
+  child.on('exit', (code, signal) => {
+    if (managed.expectedExit) return
+    if (code !== 0) fail(new CliError(`${name} exited (${signal ?? code})`))
+  })
+  return managed
+}
+
+function readProjectRegistry(directory) {
+  let config
+  try {
+    config = readFileSync(path.join(directory, '.npmrc'), 'utf8')
+  } catch (error) {
+    if (error?.code === 'ENOENT') return null
+    throw error
+  }
+
+  for (const line of config.split(/\r?\n/)) {
+    const match = line.match(/^\s*registry\s*=\s*(\S+)/)
+    if (!match) continue
+    const registry = match[1]
+    if (/^https?:\/\/[^\s]+$/i.test(registry)) return registry
+  }
+  return null
+}
+
+function withProjectRegistry(args, directory) {
+  // Only PPE packaging injects this offline runner and explicitly pins the
+  // project registry. Other installs use pnpm's project/user configuration.
+  let manifest
+  try {
+    manifest = JSON.parse(readFileSync(path.join(directory, 'package.json'), 'utf8'))
+  } catch (error) {
+    if (error?.code === 'ENOENT') return args
+    throw error
+  }
+  const runner = manifest.devDependencies?.['@byted/microapp-preview-runner']
+  if (typeof runner !== 'string' || !runner.startsWith('file:patches/')) return args
+  const registry = readProjectRegistry(directory)
+  return registry ? [...args, `--registry=${registry}`] : args
+}
+
+export function getInstallSteps(context, options = {}) {
+  const steps = []
+  if (!options.skipRootInstall) {
+    steps.push({
+      args: withProjectRegistry(
+        ['install', '--config.confirm-modules-purge=false'],
+        context.root,
+      ),
+      cwd: context.root,
+      label: 'pnpm install',
+    })
+  }
+  if (context.target === 'taro' && context.hasOpenCard) {
+    steps.push({
+      args: withProjectRegistry([
+        '--dir', context.opencardRoot, 'install', '--ignore-workspace',
+        '--config.confirm-modules-purge=false',
+      ], context.opencardRoot),
+      cwd: context.root,
+      label: 'opencard pnpm install',
+    })
+  }
+  return steps
+}
+
+async function install(context, options = {}) {
+  for (const step of getInstallSteps(context, options)) {
+    await runProcess('pnpm', step.args, {
+      cwd: step.cwd,
+      label: step.label,
+      // Match the template's registry handling for both the workspace and the
+      // independent OpenCard project. Undefined removes inherited spawn env keys.
+      env: {
+        npm_config_registry: undefined,
+        NPM_CONFIG_REGISTRY: undefined,
+        yarn_registry: undefined,
+        YARN_REGISTRY: undefined,
+      },
+    })
+  }
+  console.log('[vibecoding:dev] Dependencies installed successfully')
+}
+
+export function isTruthyFlag(value) {
+  const normalized = String(value ?? '').trim().toLowerCase()
+  return normalized === '1' || normalized === 'true' || normalized === 'yes'
+}
+
+export function getTaroDevConfiguration(context, env = process.env) {
+  const frontendPort = resolvePreviewPort(env.DEPLOY_RUN_PORT, 10086)
+  const serverPort = resolvePreviewPort(env.SERVER_PORT, 3000)
+  const openCardPort = resolvePreviewPort(env.OPENCARD_PORT, 10087)
+  const closedDomainServerPort = resolvePreviewPort(env.CLOSED_DOMAIN_SERVER_PORT, 3001)
+  const ports = [frontendPort, serverPort]
+  if (context.hasOpenCard) ports.push(openCardPort)
+  if (context.hasClosedDomainServer) ports.push(closedDomainServerPort)
+  return {
+    ports,
+    serverPort,
+    closedDomainServerPort,
+  }
+}
+
+export function createDatabaseGateWatcher(options) {
+  let previous = options.baseline
+  let running = false
+  let stopped = false
+  const tick = async () => {
+    if (stopped || running) return
+    running = true
+    try {
+      const env = await options.readEnvironment()
+      const current = env.HAS_CALLED_DATABASE_INIT_TOOL
+      if (isTruthyFlag(current) && !isTruthyFlag(previous)) {
+        previous = current
+        await options.onEnabled(env)
+      }
+    } catch (error) {
+      options.onError?.(error)
+    } finally {
+      running = false
+    }
+  }
+  const timer = (options.setIntervalFn ?? setInterval)(
+    () => { void tick() },
+    options.intervalMs ?? 5_000,
+  )
+  timer.unref?.()
+  return {
+    tick,
+    stop() {
+      stopped = true
+      ;(options.clearIntervalFn ?? clearInterval)(timer)
+    },
+  }
+}
+
+export async function initializeDatabaseThenRestart(options) {
+  try {
+    await (options.runDatabaseInitFn ?? runDatabaseInit)(
+      options.context,
+      { env: options.env },
+    )
+  } catch (error) {
+    options.onError?.(error)
+    return false
+  }
+  await options.restartBackend(options.env)
+  return true
+}
+
+export async function runDev(context, options = {}) {
+  assertDevSupervised()
+  if (!options.skipInstall) await install(context, options)
+  let env = await readRuntimeEnvironment(context.root, { development: true })
+  const children = []
+  const runtimes = []
+  let databaseWatcher = null
+  let serverManaged = null
+  let settled = false
+  let resolveLifetime
+  let rejectLifetime
+  const lifetime = new Promise((resolve, reject) => {
+    resolveLifetime = resolve
+    rejectLifetime = reject
+  })
+  const fail = (error) => { if (!settled) rejectLifetime(error) }
+  const finish = () => { if (!settled) resolveLifetime() }
+  const handlePreviewExit = (error) => error ? fail(error) : finish()
+
+  const taroDev = context.target === 'taro'
+    ? getTaroDevConfiguration(context, env)
+    : null
+  const openCardPort = resolvePreviewPort(env.OPENCARD_PORT, 10087)
+  const ports = context.target === 'opencard'
+    ? [openCardPort]
+    : taroDev.ports
+  for (const port of ports) await clearPort(port)
+
+  const cleanup = async () => {
+    if (settled) return
+    settled = true
+    databaseWatcher?.stop()
+    for (const managed of children) {
+      const { child } = managed
+      managed.expectedExit = true
+      if (!child.pid || child.exitCode !== null) continue
+      try { process.kill(-child.pid, 'SIGKILL') } catch {}
+    }
+    await Promise.allSettled(runtimes.map((runtime) => runtime.close()))
+  }
+  const signalHandler = () => { void cleanup().then(() => process.exit(0)) }
+  for (const signal of ['SIGINT', 'SIGTERM', 'SIGHUP']) process.once(signal, signalHandler)
+
+  try {
+    mkdirSync(path.join(context.root, '.home'), { recursive: true })
+    if (context.target === 'opencard') {
+      const preview = await startPreview({
+        root: context.root,
+        cardMode: true,
+        env,
+        onExit: handlePreviewExit,
+      })
+      children.push({ child: preview.child, name: 'opencard watch' })
+      runtimes.push(preview.runtime)
+    } else {
+      const baseline = env.HAS_CALLED_DATABASE_INIT_TOOL
+      await runDatabaseInit(context, { env })
+      env = await readRuntimeEnvironment(context.root, { development: true })
+
+      const startBackend = (runtimeEnv) => spawnManaged(
+        'pnpm',
+        ['--filter', 'server', 'run', 'start:dev'],
+        {
+          cwd: context.root,
+          env: { ...runtimeEnv, NJS_SERVER_PORT: String(taroDev.serverPort) },
+          name: 'server dev',
+          label: 'server',
+        },
+        children,
+        fail,
+      )
+      const startClosedDomainServer = (runtimeEnv) => spawnManaged(
+        'pnpm',
+        ['--filter', 'closed-domain-server', 'run', 'start:dev'],
+        {
+          cwd: context.root,
+          env: {
+            ...runtimeEnv,
+            NJS_SERVER_PORT: String(taroDev.closedDomainServerPort),
+          },
+          name: 'closed-domain-server dev',
+          label: 'closed-domain-server',
+        },
+        children,
+        fail,
+      )
+      const startManagedPreview = async (previewOptions) => {
+        const preview = await startPreview(previewOptions)
+        children.push({ child: preview.child, name: previewOptions.cardMode ? 'opencard watch' : 'taro watch' })
+        runtimes.push(preview.runtime)
+      }
+      const previewTasks = [
+        startManagedPreview({ root: context.root, env, onExit: handlePreviewExit }),
+      ]
+      if (context.hasOpenCard) {
+        previewTasks.push(startManagedPreview({
+          root: context.opencardRoot,
+          cardMode: true,
+          env,
+          onExit: handlePreviewExit,
+        }))
+      }
+      serverManaged = startBackend(env)
+      if (context.hasClosedDomainServer) startClosedDomainServer(env)
+
+      const restartBackend = async () => {
+        if (settled) return
+        if (serverManaged?.child?.pid && serverManaged.child.exitCode === null) {
+          serverManaged.expectedExit = true
+          try { process.kill(-serverManaged.child.pid, 'SIGKILL') } catch {}
+        }
+        await clearPort(taroDev.serverPort)
+        env = await readRuntimeEnvironment(context.root, { development: true })
+        serverManaged = startBackend(env)
+      }
+      databaseWatcher = createDatabaseGateWatcher({
+        baseline,
+        readEnvironment: () => readRuntimeEnvironment(context.root, { development: true }),
+        onEnabled: (runtimeEnv) => initializeDatabaseThenRestart({
+          context,
+          env: runtimeEnv,
+          restartBackend,
+          onError: (error) => console.warn(
+            `[mysql-gate] init-mysql-db failed; keeping current backend: ${error.message}`,
+          ),
+        }),
+        onError: (error) => console.warn(`[mysql-gate] watcher failed: ${error.message}`),
+      })
+      await Promise.all(previewTasks)
+    }
+    console.log(`[vibecoding:dev] services started (${ports.join(', ')})`)
+    await lifetime
+  } finally {
+    await cleanup()
+    for (const signal of ['SIGINT', 'SIGTERM', 'SIGHUP']) process.removeListener(signal, signalHandler)
+  }
+}

package/src/commands/lint.mjs

@@ -0,0 +1,176 @@
+import { existsSync, mkdirSync } from 'node:fs'
+import path from 'node:path'
+import { CliError } from '../core/errors.mjs'
+import { resolveProjectBinary, runCaptured, runProcess, runTasks } from '../core/runner.mjs'
+import { lintOpenCardProject } from '../lint/lint-lynx-css.mjs'
+import { validateNonEmptyTaro } from '../validators/empty-project.mjs'
+import { validateOpenCardStructure } from '../validators/opencard-structure.mjs'
+import { validateSqlQueries } from '../validators/sql.mjs'
+import { validateWidgetShell } from '../validators/widget-shell.mjs'
+
+const globalConfigs = [
+  'eslint.config.mjs', 'tsconfig.json', 'package.json', 'pnpm-lock.yaml',
+  'opencard/eslint.config.mjs', 'opencard/tsconfig.json', 'opencard/package.json',
+]
+
+export async function changedFiles(root, patterns, capture = runCaptured) {
+  try {
+    const baseCandidates = ['origin/main', 'origin/master']
+    let base = null
+    for (const candidate of baseCandidates) {
+      const check = await capture('git', ['rev-parse', '--verify', candidate], {
+        cwd: root,
+        allowFailure: true,
+      })
+      if (check.code === 0) {
+        base = candidate
+        break
+      }
+    }
+    if (!base) {
+      const roots = await capture('git', ['rev-list', '--max-parents=0', 'HEAD'], {
+        cwd: root,
+        allowFailure: true,
+      })
+      base = roots.stdout.split('\n').map((item) => item.trim()).filter(Boolean).at(-1) ?? null
+    }
+    if (!base) return []
+    let result = await capture(
+      'git',
+      ['diff', '--name-only', `${base}...HEAD`, '--', ...patterns],
+      { cwd: root, allowFailure: true },
+    )
+    if (result.code !== 0 || !result.stdout.trim()) {
+      result = await capture('git', ['diff', '--name-only', 'HEAD', '--', ...patterns], {
+        cwd: root,
+        allowFailure: true,
+      })
+    }
+    if (result.code !== 0) return []
+    return result.stdout.split('\n').map((item) => item.trim()).filter(Boolean)
+  } catch {
+    // Match the template's full-check fallback when Git cannot run.
+    return []
+  }
+}
+
+export async function incrementalLintFiles(root, capture = runCaptured) {
+  const files = await changedFiles(root, [
+    'src/**', 'server/**', 'closed-domain-server/**', 'feed/**', 'opencard/src/**', ...globalConfigs,
+  ], capture)
+  return files.some((file) => globalConfigs.includes(file)) ? [] : files
+}
+
+export function selectOpenCardEslintFiles(changed) {
+  if (changed.length === 0) {
+    return { runEslint: true, files: ['src/**/*.{js,jsx,ts,tsx}'] }
+  }
+  const files = changed
+    .filter((file) => /\.(?:js|jsx|ts|tsx)$/.test(file))
+    .map((file) => file.replace(/^opencard\//, ''))
+  return { runEslint: files.length > 0, files }
+}
+
+export function runLynxCss(root, lintProject = lintOpenCardProject) {
+  const findings = lintProject(root)
+  if (findings.length === 0) return
+  const details = findings.map((finding) =>
+    `${finding.file}:${finding.line}:${finding.column} ${finding.message}`,
+  )
+  throw new CliError(
+    `OpenCard Lynx CSS check failed (${findings.length}):\n${details.join('\n')}`,
+  )
+}
+
+export async function lintOpenCard(context, options = {}) {
+  const root = context.target === 'opencard' ? context.root : context.opencardRoot
+  if (!root) return
+  const projectRoot = context.taroRoot && existsSync(path.join(context.taroRoot, 'node_modules/.bin/tsc'))
+    ? context.taroRoot
+    : root
+  const tsc = resolveProjectBinary(projectRoot, 'tsc')
+  const eslint = resolveProjectBinary(projectRoot, 'eslint')
+  mkdirSync(path.join(root, 'node_modules/.cache/eslint'), { recursive: true })
+  const eslintArgs = ['--cache', '--cache-location', 'node_modules/.cache/eslint/opencard-src']
+  let changed = []
+  if (options.incremental) {
+    changed = await changedFiles(context.taroRoot ?? root, ['opencard/src/**'])
+    if (changed.length > 0) {
+      console.log(`[opencard lint] incremental mode (${changed.length} files)`)
+    }
+  }
+  const eslintSelection = selectOpenCardEslintFiles(changed)
+  eslintArgs.push(...eslintSelection.files)
+  const validationContext = { ...context, root, target: 'opencard' }
+  const tasks = [
+    { 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 }) },
+  ]
+  if (eslintSelection.runEslint) {
+    tasks.push({
+      name: 'opencard-eslint',
+      run: () => runProcess(eslint, eslintArgs, { cwd: root }),
+    })
+  }
+  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 })
+    return
+  }
+
+  validateNonEmptyTaro(context)
+  const tsc = resolveProjectBinary(context.root, 'tsc')
+  const eslint = resolveProjectBinary(context.root, 'eslint')
+  const eslintArgs = ['--cache', '--cache-location', 'node_modules/.cache/eslint/root-src']
+  const changed = incremental ? await incrementalLintFiles(context.root) : []
+  if (incremental) {
+    const files = changed.filter((file) => file.startsWith('src/'))
+    eslintArgs.push(...(files.length > 0 ? files : ['src/**/*.{js,jsx,ts,tsx,css,scss}']))
+  } else {
+    eslintArgs.push('src/**/*.{js,jsx,ts,tsx,css,scss}')
+  }
+
+  const full = !incremental || changed.length === 0
+  const serverChanged = changed.some((file) => file.startsWith('server/'))
+  const closedDomainChanged = changed.some((file) => file.startsWith('closed-domain-server/'))
+  const tasks = []
+  if (full || changed.some((file) => file.startsWith('src/'))) {
+    tasks.push(
+      { name: 'taro-tsc', run: () => runProcess(tsc, ['--noEmit'], { cwd: context.root }) },
+      { name: 'taro-eslint', run: () => runProcess(eslint, eslintArgs, { cwd: context.root }) },
+    )
+  }
+  if (full || serverChanged || closedDomainChanged) {
+    tasks.push({
+      name: 'server-sql',
+      run: () => validateSqlQueries([context.serverRoot, context.closedDomainServerRoot]),
+    })
+  }
+  if (full || serverChanged) {
+    tasks.push({
+      name: 'server-lint',
+      run: () => runTasks([
+        { name: 'server-tsc', run: () => runProcess(tsc, ['--noEmit'], { cwd: context.serverRoot }) },
+        {
+          name: 'server-eslint',
+          run: () => runProcess(eslint, [
+            '--cache',
+            '--cache-location',
+            'node_modules/.cache/eslint/server-src',
+            'src/**/*.{js,jsx,ts,tsx}',
+          ], { cwd: context.serverRoot }),
+        },
+      ], { label: 'server lint' }),
+    })
+  }
+  if (context.hasOpenCard && (full || changed.some((file) => file.startsWith('opencard/')))) {
+    tasks.push({ name: 'opencard-lint', run: () => lintOpenCard(context, { incremental: !full }) })
+  }
+  await runTasks(tasks, { label: 'lint' })
+}

package/src/commands/pack.mjs

@@ -0,0 +1,169 @@
+import {
+  cpSync,
+  existsSync,
+  lstatSync,
+  mkdtempSync,
+  mkdirSync,
+  readFileSync,
+  realpathSync,
+  rmSync,
+  statSync,
+  writeFileSync,
+} from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import { spawn } from 'node:child_process'
+import { CliError } from '../core/errors.mjs'
+import { resolveProjectContext } from '../core/context.mjs'
+import { buildOpenCard, buildPackInputs } from './build.mjs'
+
+const DEFAULT_ARTIFACTS = '/tmp/microapp_artifacts'
+
+// Keep build/zip exit codes from the original shell entry without changing the
+// error handling of unrelated CLI commands.
+function runPackProcess(command, args, options) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, args, {
+      cwd: options.cwd,
+      env: { ...process.env, ...options.env },
+      stdio: 'inherit',
+    })
+    child.once('error', error => reject(new CliError(`${command}: ${error.message}`, error.code === 'ENOENT' ? 127 : 1)))
+    child.once('exit', (code, signal) => {
+      if (code === 0) return resolve()
+      reject(new CliError(`${command} failed${signal ? ` with signal ${signal}` : ` with exit code ${code}`}`,
+        code ?? (128 + (os.constants.signals[signal] ?? 0))))
+    })
+  })
+}
+
+function isDirectory(directory) {
+  return existsSync(directory) && statSync(directory).isDirectory()
+}
+
+function resolveExistingPath(directory) {
+  if (existsSync(directory)) return realpathSync(directory)
+  const parent = path.dirname(directory)
+  return parent === directory ? directory : path.join(resolveExistingPath(parent), path.basename(directory))
+}
+
+function resolveArtifactsDirectory(root, requested) {
+  if (typeof requested !== 'string' || !requested.trim()) throw new CliError('Artifact directory must not be empty')
+  const absolute = path.resolve(root, requested)
+  // Never recursively clean a project/home/temp root or an ancestor, including
+  // aliases through symlinks. Dedicated subdirectories remain supported.
+  const resolved = resolveExistingPath(absolute)
+  const protectedPaths = [root, os.homedir(), os.tmpdir(), '/tmp'].map(value => resolveExistingPath(path.resolve(value)))
+  if (protectedPaths.some(value => value === resolved || value.startsWith(`${resolved}${path.sep}`)) || resolved === path.parse(resolved).root) {
+    throw new CliError(`Unsafe artifact directory: ${absolute}`)
+  }
+  if (existsSync(absolute) && lstatSync(absolute).isSymbolicLink()) {
+    throw new CliError(`Artifact directory must not be a symlink: ${absolute}`)
+  }
+  return absolute
+}
+
+async function zipDirectory(directory, output, { removeExisting = true } = {}) {
+  if (!isDirectory(directory)) throw new CliError(`Pack input is missing: ${directory}`)
+  if (removeExisting) rmSync(output, { force: true })
+  await runPackProcess('zip', ['-rq', output, '.'], { cwd: directory })
+}
+
+function createServerStage(server, stage) {
+  if (!isDirectory(server)) throw new CliError(`Server pack input is missing: ${server}`)
+  const required = ['dist', 'Dockerfile', 'package.json', 'run.sh']
+  for (const name of required) {
+    if (!existsSync(path.join(server, name))) {
+      throw new CliError(`Server pack input is missing: ${path.join(server, name)}`)
+    }
+  }
+  for (const name of ['dist', 'package.json', 'run.sh', 'sql', 'scripts']) {
+    const source = path.join(server, name)
+    if (existsSync(source)) cpSync(source, path.join(stage, name), { recursive: true })
+  }
+  let dockerfile = readFileSync(path.join(server, 'Dockerfile'), 'utf8')
+  const additions = []
+  if (isDirectory(path.join(server, 'scripts'))) additions.push('COPY ./scripts ./scripts')
+  if (isDirectory(path.join(server, 'sql'))) additions.push('COPY ./sql ./sql')
+  // Match awk's per-line insertion, including multiple COPY instructions and
+  // its final newline. Files named sql/scripts are copied but are not folders.
+  dockerfile = dockerfile.split('\n').filter((_, index, lines) => index < lines.length - 1 || lines[index] !== '')
+    .flatMap(line => /^COPY package\.json/.test(line) ? [line, ...additions] : [line])
+    .map(line => `${line}\n`).join('')
+  writeFileSync(path.join(stage, 'Dockerfile'), dockerfile)
+  return stage
+}
+
+export async function packOpenCardArtifact(context, artifacts) {
+  mkdirSync(artifacts, { recursive: true })
+  await zipDirectory(path.join(context.root, 'dist'), path.join(artifacts, 'opencard.zip'))
+}
+
+async function packServer(server, artifacts, closed = false) {
+  const stage = mkdtempSync(path.join(os.tmpdir(), 'vibecoding-server-pack-'))
+  try {
+    createServerStage(server, stage)
+    await zipDirectory(stage, path.join(artifacts, closed ? 'closed-domain-server.zip' : 'server.zip'), { removeExisting: false })
+    cpSync(path.join(stage, 'Dockerfile'), path.join(artifacts, closed ? 'closed-domain-Dockerfile' : 'Dockerfile'))
+    cpSync(path.join(server, 'run.sh'), path.join(artifacts, closed ? 'closed-domain-run.sh' : 'run.sh'))
+  } finally {
+    rmSync(stage, { recursive: true, force: true })
+  }
+}
+
+export async function packTaroArtifacts(context, artifacts) {
+  artifacts = resolveArtifactsDirectory(context.root, artifacts)
+  mkdirSync(artifacts, { recursive: true })
+  const dist = path.join(context.root, 'dist-tt')
+  console.log(`Packing ${dist} into ${artifacts}/microapp.zip`)
+  await zipDirectory(dist, path.join(artifacts, 'microapp.zip'))
+  await packServer(context.serverRoot ?? path.join(context.root, 'server'), artifacts)
+  const closedServer = path.join(context.root, 'closed-domain-server')
+  if (existsSync(path.join(closedServer, 'package.json')) && statSync(path.join(closedServer, 'package.json')).isFile()) {
+    await packServer(closedServer, artifacts, true)
+  } else {
+    console.log('No closed-domain-server/package.json; skipping closed-domain-server artifacts')
+  }
+  const routing = path.join(context.root, 'config/card-routing.json')
+  if (existsSync(routing) && statSync(routing).isFile()) {
+    cpSync(routing, path.join(artifacts, 'card-routing.json'))
+  } else {
+    console.log(`No ${routing}; skipping card-routing.json artifact`)
+  }
+  // A legacy project build hook can write an OpenCard archive into ARTIFACTS_DIR.
+  // Do not replace that archive or require opencard/dist after it succeeds.
+}
+
+export async function runPack(context, options = {}) {
+  const artifacts = resolveArtifactsDirectory(context.root,
+    options.artifactsDir ?? process.env.ARTIFACTS_DIR ?? DEFAULT_ARTIFACTS)
+  if (context.target === 'opencard') {
+    await buildOpenCard(context)
+    await packOpenCardArtifact(context, artifacts)
+    return
+  }
+
+  console.log(`Cleaning ${artifacts}`)
+  rmSync(artifacts, { recursive: true, force: true })
+  mkdirSync(artifacts, { recursive: true })
+  const packageJson = context.packageJson ?? JSON.parse(readFileSync(path.join(context.root, 'package.json'), 'utf8'))
+  const projectBuild = packageJson.scripts?.['build:pack']
+  if (projectBuild) {
+    // Preserve compatibility for projects that own their OpenCard archive.
+    console.log('Running build:pack')
+    await runPackProcess('pnpm', ['build:pack'], {
+      cwd: context.root,
+      env: { ...options.env, ARTIFACTS_DIR: artifacts },
+    })
+  } else {
+    // Current templates use the shared CLI build orchestration.
+    context = resolveProjectContext({ cwd: context.root, target: 'taro' })
+    await buildPackInputs(context, options)
+  }
+
+  await packTaroArtifacts(context, artifacts)
+  if (!projectBuild && context.hasOpenCard) {
+    await packOpenCardArtifact({ root: context.opencardRoot }, artifacts)
+  }
+  console.log(`Pack completed. Artifacts located in ${artifacts}`)
+}