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

package/src/core/args.mjs

@@ -0,0 +1,101 @@
+import { UsageError } from './errors.mjs'
+
+const BOOLEAN_FLAGS = new Set([
+  'auto-start',
+  'full',
+  'runtime-only',
+  'static-only',
+  'ports-only',
+  'skip-install',
+  'skip-root-install',
+  'incremental',
+  'help',
+])
+
+const VALUE_FLAGS = new Set(['target', 'cwd', 'timeout', 'frontend-url', 'scope'])
+
+export function parseArgs(argv) {
+  const positionals = []
+  const flags = {}
+  const passthrough = []
+  let isPassthrough = false
+
+  for (let index = 0; index < argv.length; index += 1) {
+    const token = argv[index]
+    if (isPassthrough) {
+      passthrough.push(token)
+      continue
+    }
+    if (token === '--') {
+      if (argv[0] !== 'turbo') {
+        throw new UsageError('The -- separator is only supported by vibecoding turbo')
+      }
+      isPassthrough = true
+      continue
+    }
+    if (token === '-h') {
+      flags.help = true
+      continue
+    }
+    if (!token.startsWith('--')) {
+      positionals.push(token)
+      continue
+    }
+
+    const raw = token.slice(2)
+    const separator = raw.indexOf('=')
+    const name = separator === -1 ? raw : raw.slice(0, separator)
+    const inlineValue = separator === -1 ? undefined : raw.slice(separator + 1)
+
+    if (BOOLEAN_FLAGS.has(name)) {
+      if (inlineValue !== undefined) {
+        throw new UsageError(`--${name} does not accept a value`)
+      }
+      flags[name] = true
+      continue
+    }
+
+    if (!VALUE_FLAGS.has(name)) {
+      throw new UsageError(`Unknown option: --${name}`)
+    }
+
+    const value = inlineValue ?? argv[index + 1]
+    if (!value || (inlineValue === undefined && value.startsWith('--'))) {
+      throw new UsageError(`Missing value for --${name}`)
+    }
+    flags[name] = value
+    if (inlineValue === undefined) index += 1
+  }
+
+  return { positionals, flags, passthrough }
+}
+
+export function requireTarget(flags) {
+  const target = flags.target
+  if (!target) {
+    throw new UsageError(
+      'Missing required option: --target\nAvailable targets: taro, opencard',
+    )
+  }
+  if (target !== 'taro' && target !== 'opencard') {
+    throw new UsageError(
+      `Invalid target: ${target}\nAvailable targets: taro, opencard`,
+    )
+  }
+  return target
+}
+
+export function resolveBuildScope(command, target, flags) {
+  const scope = flags.scope
+  if (!scope) return undefined
+  if (command !== 'build') {
+    throw new UsageError('--scope is only supported by the build command')
+  }
+  if (target !== 'taro') {
+    throw new UsageError('--scope is only supported with --target taro')
+  }
+  if (scope !== 'tt') {
+    throw new UsageError(`Invalid build scope: ${scope}\nAvailable build scopes: tt`)
+  }
+  return scope
+}

package/src/core/context.mjs

@@ -0,0 +1,101 @@
+import { existsSync, readFileSync } from 'node:fs'
+import path from 'node:path'
+import { CliError } from './errors.mjs'
+
+function hasAll(root, entries) {
+  return entries.every((entry) => existsSync(path.join(root, entry)))
+}
+
+function isTaroRoot(root) {
+  return hasAll(root, ['package.json', 'src', 'config', 'server/package.json'])
+}
+
+function isOpenCardRoot(root) {
+  return hasAll(root, ['package.json', 'src', 'config', 'project.card.json'])
+}
+
+function isPackageRoot(root) {
+  return hasAll(root, ['package.json'])
+}
+
+/**
+ * Infer the target for commands that do not need the target-specific options
+ * used by dev/build/lint. The nearest project marker wins, so an OpenCard
+ * directory nested inside a Taro project is still treated as OpenCard.
+ */
+export function inferProjectTarget({ cwd = process.cwd() } = {}) {
+  let current = path.resolve(cwd)
+  while (true) {
+    if (isOpenCardRoot(current)) return 'opencard'
+    if (isTaroRoot(current)) return 'taro'
+    const parent = path.dirname(current)
+    if (parent === current) return 'taro'
+    current = parent
+  }
+}
+
+function findUp(start, predicate) {
+  let current = path.resolve(start)
+  while (true) {
+    if (predicate(current)) return current
+    const parent = path.dirname(current)
+    if (parent === current) return null
+    current = parent
+  }
+}
+
+function readPackage(root) {
+  try {
+    return JSON.parse(readFileSync(path.join(root, 'package.json'), 'utf8'))
+  } catch (error) {
+    throw new CliError(`Cannot read ${path.join(root, 'package.json')}: ${error.message}`)
+  }
+}
+
+export function resolveProjectContext({ cwd = process.cwd(), target }) {
+  const requested = path.resolve(cwd)
+  let root
+
+  if (target === 'taro') {
+    root = findUp(requested, isTaroRoot)
+  } else {
+    root = findUp(requested, isOpenCardRoot)
+    if (!root) {
+      const taroRoot = findUp(requested, isTaroRoot)
+      const nested = taroRoot ? path.join(taroRoot, 'opencard') : null
+      if (nested && isOpenCardRoot(nested)) root = nested
+    }
+  }
+
+  if (!root) {
+    const expected = target === 'taro'
+      ? 'package.json, src/, config/ and server/package.json'
+      : 'package.json, src/, config/ and project.card.json'
+    throw new CliError(
+      `Cannot locate a ${target} project from ${requested}. Expected ${expected}.`,
+    )
+  }
+
+  const packageJson = readPackage(root)
+  const taroRoot = target === 'taro' ? root : path.dirname(root)
+  const opencardRoot = target === 'taro'
+    ? (isOpenCardRoot(path.join(root, 'opencard')) ? path.join(root, 'opencard') : null)
+    : root
+  const closedDomainServerRoot = target === 'taro'
+    ? (isPackageRoot(path.join(root, 'closed-domain-server'))
+        ? path.join(root, 'closed-domain-server')
+        : null)
+    : null
+
+  return {
+    target,
+    root,
+    taroRoot,
+    opencardRoot,
+    closedDomainServerRoot,
+    serverRoot: target === 'taro' ? path.join(root, 'server') : null,
+    packageJson,
+    hasOpenCard: Boolean(opencardRoot && isOpenCardRoot(opencardRoot)),
+    hasClosedDomainServer: Boolean(closedDomainServerRoot),
+  }
+}

package/src/core/environment.mjs

@@ -0,0 +1,55 @@
+import { existsSync, readFileSync } from 'node:fs'
+import path from 'node:path'
+import { runCaptured } from './runner.mjs'
+
+export function readEnvFile(root, name = '.env.dev') {
+  const file = path.join(root, name)
+  if (!existsSync(file)) return {}
+  const values = {}
+  for (const rawLine of readFileSync(file, 'utf8').split(/\r?\n/)) {
+    const line = rawLine.trim()
+    if (!line || line.startsWith('#')) continue
+    const match = line.match(/^(?:export\s+)?([A-Za-z_][A-Za-z0-9_]*)=(.*)$/)
+    if (!match) continue
+    let value = match[2].trim()
+    if ((value.startsWith('"') && value.endsWith('"')) ||
+        (value.startsWith("'") && value.endsWith("'"))) {
+      value = value.slice(1, -1)
+    }
+    values[match[1]] = value
+  }
+  return values
+}
+
+function parseNullSeparatedEnvironment(output) {
+  const values = {}
+  for (const entry of output.split('\0')) {
+    const separator = entry.indexOf('=')
+    if (separator <= 0) continue
+    values[entry.slice(0, separator)] = entry.slice(separator + 1)
+  }
+  return values
+}
+
+export async function readRuntimeEnvironment(root, options = {}) {
+  const baseEnv = options.baseEnv ?? process.env
+  const runCapturedFn = options.runCapturedFn ?? runCaptured
+  const result = await runCapturedFn('bash', [
+    '-c',
+    'set +u; if [ -f "$HOME/.bashrc" ]; then source "$HOME/.bashrc" >/dev/null 2>&1 || true; fi; env -0',
+  ], {
+    allowFailure: true,
+    env: baseEnv,
+  })
+  const shellEnv = result.code === 0
+    ? parseNullSeparatedEnvironment(result.stdout)
+    : {}
+  return {
+    ...baseEnv,
+    ...shellEnv,
+    // The dev command runs outside the cloud runtime. Do not inherit the
+    // sandbox image's production mode; explicit project configuration wins.
+    ...(options.development ? { APP_ENV: 'DEV' } : {}),
+    ...readEnvFile(root),
+  }
+}

package/src/core/errors.mjs

@@ -0,0 +1,14 @@
+export class CliError extends Error {
+  constructor(message, exitCode = 1) {
+    super(message)
+    this.name = 'CliError'
+    this.exitCode = exitCode
+  }
+}
+
+export class UsageError extends CliError {
+  constructor(message) {
+    super(message, 2)
+    this.name = 'UsageError'
+  }
+}

package/src/core/ports.mjs

@@ -0,0 +1,76 @@
+import { runCaptured } from './runner.mjs'
+
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms))
+const DEFAULT_TERMINATION_GRACE_MS = 3_000
+
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0)
+    return true
+  } catch {
+    return false
+  }
+}
+
+export async function terminateProcesses(pids, options = {}) {
+  const graceMs = options.graceMs ?? DEFAULT_TERMINATION_GRACE_MS
+  const targets = [...new Set(pids.map(Number).filter(Number.isInteger))]
+    .filter((pid) => pid > 0 && isProcessAlive(pid))
+
+  for (const pid of targets) {
+    try { process.kill(pid, 'SIGTERM') } catch {}
+  }
+
+  const deadline = Date.now() + graceMs
+  let survivors = targets.filter(isProcessAlive)
+  while (survivors.length > 0 && Date.now() < deadline) {
+    await sleep(Math.min(50, Math.max(1, deadline - Date.now())))
+    survivors = survivors.filter(isProcessAlive)
+  }
+
+  for (const pid of survivors) {
+    try { process.kill(pid, 'SIGKILL') } catch {}
+  }
+  return { terminated: targets.filter((pid) => !survivors.includes(pid)), forced: survivors }
+}
+
+export async function isPortListening(port) {
+  const result = await runCaptured('lsof', [`-tiTCP:${port}`, '-sTCP:LISTEN'], {
+    allowFailure: true,
+  })
+  return result.code === 0 && result.stdout.trim().length > 0
+}
+
+export async function clearPort(port) {
+  const result = await runCaptured('lsof', [`-tiTCP:${port}`, '-sTCP:LISTEN'], {
+    allowFailure: true,
+  })
+  const pids = [...new Set(result.stdout.trim().split(/\s+/).filter(Boolean))]
+  if (pids.length === 0) {
+    console.log(`[vibecoding:dev] port ${port} is free`)
+    return
+  }
+  console.log(`[vibecoding:dev] clearing port ${port} (PIDs: ${pids.join(', ')})`)
+  const { forced } = await terminateProcesses(pids)
+  if (forced.length > 0) {
+    console.warn(
+      `[vibecoding:dev] force-killed port ${port} processes after timeout (PIDs: ${forced.join(', ')})`,
+    )
+  }
+}
+
+export async function waitForPorts(ports, timeoutSeconds) {
+  const deadline = Date.now() + timeoutSeconds * 1000
+  while (Date.now() < deadline) {
+    const status = await Promise.all(ports.map(async (entry) => ({
+      ...entry,
+      listening: await isPortListening(entry.port),
+    })))
+    if (status.every((entry) => entry.listening)) return status
+    await new Promise((resolve) => setTimeout(resolve, 1000))
+  }
+  return Promise.all(ports.map(async (entry) => ({
+    ...entry,
+    listening: await isPortListening(entry.port),
+  })))
+}

package/src/core/process-output.mjs

@@ -0,0 +1,25 @@
+import { createInterface } from 'node:readline'
+
+export function forwardLabeledStream(source, destination, label) {
+  const reader = createInterface({ input: source, crlfDelay: Infinity, terminal: false })
+
+  reader.on('line', (line) => {
+    if (!destination.write(`[${label}] ${line}\n`)) {
+      reader.pause()
+      destination.once('drain', () => reader.resume())
+    }
+  })
+
+  return reader
+}
+
+export function attachLabeledOutput(child, label, options = {}) {
+  const readers = []
+  const stdout = options.stdout ?? process.stdout
+  const stderr = options.stderr ?? process.stderr
+
+  if (child.stdout) readers.push(forwardLabeledStream(child.stdout, stdout, label))
+  if (child.stderr) readers.push(forwardLabeledStream(child.stderr, stderr, label))
+
+  return readers
+}

package/src/core/runner.mjs

@@ -0,0 +1,90 @@
+import { spawn } from 'node:child_process'
+import path from 'node:path'
+import { createRequire } from 'node:module'
+import { CliError } from './errors.mjs'
+
+export function resolveProjectBinary(root, name) {
+  const executable = process.platform === 'win32' ? `${name}.cmd` : name
+  return path.join(root, 'node_modules', '.bin', executable)
+}
+
+export function resolveSdkTaroEntry(root) {
+  return createRequire(path.join(root, 'package.json')).resolve('@open-dy/vibecoding-sdk-opencard/build/taro-toolchain')
+}
+
+export function runProcess(command, args = [], options = {}) {
+  const label = options.label ?? path.basename(command)
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, args, {
+      cwd: options.cwd,
+      env: { ...process.env, ...options.env },
+      stdio: options.stdio ?? 'inherit',
+      detached: options.detached ?? false,
+      shell: options.shell ?? false,
+    })
+
+    child.on('error', (error) => {
+      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(
+        `${label} failed${signal ? ` with signal ${signal}` : ` with exit code ${code}`}`,
+      ))
+    })
+  })
+}
+
+export function runCaptured(command, args = [], options = {}) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, args, {
+      cwd: options.cwd,
+      env: { ...process.env, ...options.env },
+      stdio: ['ignore', 'pipe', 'pipe'],
+      shell: false,
+    })
+    let stdout = ''
+    let stderr = ''
+    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(error.message)))
+    child.on('exit', (code) => {
+      if (code === 0 || options.allowFailure) {
+        resolve({ code: code ?? 1, stdout, stderr })
+      } else {
+        reject(new CliError(
+          `${options.label ?? path.basename(command)} failed with exit code ${code}\n${stderr || stdout}`,
+        ))
+      }
+    })
+  })
+}
+
+export async function runTasks(tasks, options = {}) {
+  const results = await Promise.allSettled(
+    tasks.map(async ({ name, run }) => {
+      console.log(`[vibecoding] starting ${name}`)
+      await run()
+      console.log(`[vibecoding] completed ${name}`)
+      return name
+    }),
+  )
+
+  const failures = results
+    .map((result, index) => ({ result, task: tasks[index] }))
+    .filter(({ result }) => result.status === 'rejected')
+
+  if (failures.length > 0) {
+    const details = failures.map(({ result, task }) =>
+      `- ${task.name}: ${result.reason instanceof Error ? result.reason.message : String(result.reason)}`,
+    )
+    throw new CliError(
+      `${options.label ?? 'tasks'} failed (${failures.length}):\n${details.join('\n')}`,
+    )
+  }
+}

package/src/core/service-log-context.mjs

@@ -0,0 +1,27 @@
+import { AsyncLocalStorage } from 'node:async_hooks'
+
+const serviceLogContext = new AsyncLocalStorage()
+const consoleMethods = ['debug', 'error', 'info', 'log', 'warn']
+let consoleInstalled = false
+
+function installContextualConsole() {
+  if (consoleInstalled) return
+  consoleInstalled = true
+
+  for (const method of consoleMethods) {
+    const original = console[method].bind(console)
+    console[method] = (...args) => {
+      const label = serviceLogContext.getStore()
+      if (!label || (typeof args[0] === 'string' && args[0].startsWith(`[${label}]`))) {
+        original(...args)
+        return
+      }
+      original(`[${label}]`, ...args)
+    }
+  }
+}
+
+export function withServiceLogLabel(label, run) {
+  installContextualConsole()
+  return serviceLogContext.run(label, run)
+}

package/src/core/web-config.mjs

@@ -0,0 +1,13 @@
+import { writeFileSync } from 'node:fs'
+import path from 'node:path'
+
+const WEB_CONFIG = {
+  hasAuditDouyinCloud: true,
+}
+
+export function writeWebConfig(outputRoot) {
+  if (!outputRoot) throw new Error('writeWebConfig requires an output root')
+  const output = path.resolve(outputRoot, 'web.config.json')
+  writeFileSync(output, `${JSON.stringify(WEB_CONFIG, null, 2)}\n`, 'utf8')
+  return output
+}