basic/scripts/cli.ts

#!/usr/bin/env node

import { spawn } from 'node:child_process'
import fs from 'node:fs'
import path from 'node:path'
import process from 'node:process'
import { fileURLToPath } from 'node:url'
import * as p from '@clack/prompts'

interface PackageJson {
  name: string
  description?: string
  scripts?: Record<string, string>
}

interface WorkspaceEntry {
  name: string
  packageJsonPath: string
}

interface AppInfo {
  name: string
  packageName: string
  description: string
  scripts: string[]
}

interface RunMessageContext {
  app: AppInfo
  script: string
}

interface ModeConfig {
  action: Mode
  intro: string
  noAppsMessage: string
  appSelectMessage: string
  scriptMatcher: (scriptName: string) => boolean
  selectionMode: 'single' | 'multiple'
  completionMessage?: string
  getRunMessage?: (context: RunMessageContext) => string
  showRunMessageWhenSingleApp?: boolean
}

type Mode = 'build' | 'dev' | 'serve'

const currentDir = path.dirname(fileURLToPath(import.meta.url))
const rootDir = path.resolve(currentDir, '..')
const isWindows = process.platform === 'win32'
const validModes: Mode[] = ['build', 'dev', 'serve']
const modeConfigs: Record<Mode, ModeConfig> = {
  build: {
    action: 'build',
    intro: 'Select apps to build',
    noAppsMessage: 'No apps found with build script',
    appSelectMessage: 'Which apps do you want to build?',
    scriptMatcher: isBuildScript,
    selectionMode: 'multiple',
    completionMessage: 'Build complete!',
    getRunMessage: ({ app, script }) => `Building "${app.name}" with script "${script}"...`,
  },
  dev: {
    action: 'dev',
    intro: 'Select an app to run',
    noAppsMessage: 'No apps found with dev script',
    appSelectMessage: 'Which app do you want to run?',
    scriptMatcher: isDevScript,
    selectionMode: 'single',
    getRunMessage: ({ app }) => `Starting ${app.packageName}...`,
  },
  serve: {
    action: 'serve',
    intro: 'Select an app to serve',
    noAppsMessage: 'No apps found with serve script',
    appSelectMessage: 'Which app do you want to serve?',
    scriptMatcher: isServeScript,
    selectionMode: 'single',
    getRunMessage: ({ app, script }) => `Serving "${app.name}" with script "${script}"...`,
  },
}

let childProcess: ReturnType<typeof spawn> | null = null

process.on('SIGINT', () => {
  childProcess?.kill('SIGINT')
})

function isBuildScript(scriptName: string): boolean {
  return scriptName === 'build' || scriptName.startsWith('build:')
}

function isDevScript(scriptName: string): boolean {
  return scriptName === 'dev' || scriptName.startsWith('dev:')
}

function isServeScript(scriptName: string): boolean {
  return scriptName === 'serve' || scriptName.startsWith('serve:')
}

function getWorkspaceEntries(): WorkspaceEntry[] {
  const entries: WorkspaceEntry[] = []
  const appsDir = path.resolve(rootDir, 'apps')

  if (fs.existsSync(appsDir)) {
    const apps = fs.readdirSync(appsDir, { withFileTypes: true })

    for (const app of apps) {
      if (!app.isDirectory()) {
        continue
      }

      const packageJsonPath = path.join(appsDir, app.name, 'package.json')
      if (!fs.existsSync(packageJsonPath)) {
        continue
      }

      entries.push({
        name: app.name,
        packageJsonPath,
      })
    }
  }

  const docsPackageJsonPath = path.resolve(rootDir, 'docs', 'package.json')
  if (fs.existsSync(docsPackageJsonPath)) {
    entries.push({
      name: 'docs',
      packageJsonPath: docsPackageJsonPath,
    })
  }

  return entries
}

function readPackageJson(packageJsonPath: string): PackageJson {
  return JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8')) as PackageJson
}

function getApps(scriptMatcher: (scriptName: string) => boolean): AppInfo[] {
  const apps: AppInfo[] = []

  for (const entry of getWorkspaceEntries()) {
    const packageJson = readPackageJson(entry.packageJsonPath)
    const scripts = Object.keys(packageJson.scripts ?? {}).filter(scriptMatcher)

    if (scripts.length === 0) {
      continue
    }

    apps.push({
      name: entry.name,
      packageName: packageJson.name,
      description: packageJson.description || '',
      scripts,
    })
  }

  return apps
}

function getAppChoices(apps: AppInfo[]): Array<{ value: string, label: string, hint: string }> {
  return apps.map(app => ({
    value: app.packageName,
    label: app.name,
    hint: app.description,
  }))
}

function getAppByPackageName(apps: AppInfo[], packageName: string): AppInfo {
  const app = apps.find(item => item.packageName === packageName)

  if (!app) {
    throw new Error(`App not found: ${packageName}`)
  }

  return app
}

function resolvePromptValue<T>(value: T | symbol): T {
  if (p.isCancel(value)) {
    p.cancel('Operation cancelled')
    process.exit(0)
  }

  return value
}

async function selectScript(app: AppInfo, action: Mode): Promise<string> {
  if (app.scripts.length === 1) {
    return app.scripts[0]
  }

  const script = await p.select({
    message: `Select ${action} script for "${app.name}":`,
    options: app.scripts.map(name => ({
      value: name,
      label: name,
    })),
  })

  return resolvePromptValue(script)
}

async function runPackageScript(packageName: string, script: string): Promise<void> {
  return new Promise((resolve, reject) => {
    childProcess = spawn('pnpm', ['--filter', packageName, 'run', script], {
      stdio: 'inherit',
      cwd: rootDir,
      shell: isWindows,
    })

    childProcess.on('close', (code) => {
      childProcess = null

      if (code === 0 || code === null) {
        resolve()
        return
      }

      reject(new Error(`Process exited with code ${code}`))
    })

    childProcess.on('error', (error) => {
      childProcess = null
      reject(error)
    })
  })
}

async function selectApps(apps: AppInfo[], message: string, selectionMode: ModeConfig['selectionMode']): Promise<AppInfo[]> {
  if (selectionMode === 'multiple') {
    const selectedPackageNames = resolvePromptValue(await p.multiselect({
      message,
      options: getAppChoices(apps),
      required: true,
    }))

    return selectedPackageNames.map(packageName => getAppByPackageName(apps, packageName))
  }

  const selectedPackageName = resolvePromptValue(await p.select({
    message,
    options: getAppChoices(apps),
  }))

  return [getAppByPackageName(apps, selectedPackageName)]
}

async function runSelectedApps(apps: AppInfo[], config: ModeConfig, showRunMessage: boolean): Promise<void> {
  for (const app of apps) {
    const script = await selectScript(app, config.action)

    if (showRunMessage) {
      const runMessage = config.getRunMessage?.({
        app,
        script,
      })

      if (runMessage) {
        p.log.info(runMessage)
      }
    }

    await runPackageScript(app.packageName, script)
  }
}

async function runMode(config: ModeConfig): Promise<void> {
  p.intro(config.intro)

  const apps = getApps(config.scriptMatcher)

  if (apps.length === 0) {
    p.log.error(config.noAppsMessage)
    process.exit(1)
  }

  if (apps.length === 1) {
    p.log.info(`Only one app found: ${apps[0].name}`)
    await runSelectedApps([apps[0]], config, config.showRunMessageWhenSingleApp ?? false)

    if (config.completionMessage) {
      p.outro(config.completionMessage)
    }

    return
  }

  const selectedApps = await selectApps(apps, config.appSelectMessage, config.selectionMode)
  await runSelectedApps(selectedApps, config, true)

  if (config.completionMessage) {
    p.outro(config.completionMessage)
  }
}

function parseModeArg(argv: string[]): string | undefined {
  for (let index = 0; index < argv.length; index += 1) {
    const arg = argv[index]

    if (arg === '--mode' || arg === '-m') {
      return argv[index + 1]
    }

    if (arg.startsWith('--mode=')) {
      return arg.slice('--mode='.length)
    }

    if (arg.startsWith('-m=')) {
      return arg.slice('-m='.length)
    }
  }

  return undefined
}

function hasHelpArg(argv: string[]): boolean {
  return argv.includes('--help') || argv.includes('-h')
}

function isMode(value: string | undefined): value is Mode {
  return value !== undefined && validModes.includes(value as Mode)
}

function printHelp(): void {
  console.log(`Usage: tsx scripts/cli.ts --mode=<${validModes.join('|')}>`)
  console.log('Examples:')
  console.log('  pnpm dev')
  console.log('  pnpm build')
  console.log('  pnpm serve')
  console.log('  pnpm cli -- --mode=dev')
}

async function main(): Promise<void> {
  const argv = process.argv.slice(2)
  const modeArg = parseModeArg(argv)

  if (hasHelpArg(argv)) {
    printHelp()
    return
  }

  if (!isMode(modeArg)) {
    p.log.error(`Invalid or missing mode. Expected one of: ${validModes.join(', ')}`)
    printHelp()
    process.exit(1)
  }

  await runMode(modeConfigs[modeArg])
}

main().catch((error: Error) => {
  p.log.error(error.message)
  process.exit(1)
})