@fugood/bricks-project 2.24.0-beta.9 → 2.24.1-beta.0

package/tools/_shell.ts

@@ -0,0 +1,173 @@
+import { spawn, type StdioOptions } from 'node:child_process'
+
+// Template-literal shell helper replacing `$` from 'bun'. Only covers the
+// ergonomics actually used in this package (see call sites in tools/*.ts).
+//
+// Usage:
+//   await sh`git status`                        // inherit stdio, throw on nonzero
+//   await sh`cd ${cwd} && git status`.quiet().nothrow()
+//   const out = await sh`git rev-parse HEAD`.text()
+//   await sh`bunx bricks ${args}`.cwd(dir).text()
+//
+// Notes:
+// - Interpolated values are treated as single argv tokens (arrays expand to
+//   multiple tokens). Whitespace inside interpolated strings is preserved.
+// - A leading `cd <path> && <cmd...>` in the literal is lifted into the
+//   subprocess cwd — no shell is spawned, so no quoting concerns.
+// - Commands that chain with `&&` beyond the `cd` prefix aren't supported;
+//   split them into multiple `sh` awaits at the call site.
+
+export interface ShResult {
+  exitCode: number
+  stdout: Buffer
+  stderr: Buffer
+}
+
+type Mode = 'default' | 'text' | 'quiet'
+
+class Sh implements PromiseLike<ShResult> {
+  private _cwd: string | undefined
+  private _mode: Mode = 'default'
+  private _throw = true
+  private _promise: Promise<ShResult> | null = null
+
+  constructor(private readonly args: string[]) {}
+
+  cwd(dir: string): this {
+    this._cwd = dir
+    return this
+  }
+
+  quiet(): this {
+    this._mode = 'quiet'
+    return this
+  }
+
+  nothrow(): this {
+    this._throw = false
+    return this
+  }
+
+  async text(): Promise<string> {
+    // If no explicit quiet was requested, capture stdout/stderr without
+    // forwarding them to the parent's streams (matches Bun's `.text()`).
+    if (this._mode === 'default') this._mode = 'text'
+    const r = await this.run()
+    return r.stdout.toString('utf8')
+  }
+
+  then<TResult1 = ShResult, TResult2 = never>(
+    onfulfilled?: ((value: ShResult) => TResult1 | PromiseLike<TResult1>) | null,
+    onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null,
+  ): Promise<TResult1 | TResult2> {
+    return this.run().then(onfulfilled, onrejected)
+  }
+
+  private run(): Promise<ShResult> {
+    if (!this._promise) this._promise = this.exec()
+    return this._promise
+  }
+
+  private async exec(): Promise<ShResult> {
+    const [cmd, ...rest] = this.args
+    if (!cmd) throw new Error('sh: empty command')
+
+    const stdio: StdioOptions =
+      this._mode === 'default'
+        ? ['inherit', 'pipe', 'pipe']
+        : this._mode === 'quiet'
+          ? ['ignore', 'pipe', 'pipe']
+          : ['inherit', 'pipe', 'pipe']
+
+    const proc = spawn(cmd, rest, { cwd: this._cwd, stdio })
+
+    const outChunks: Buffer[] = []
+    const errChunks: Buffer[] = []
+    proc.stdout?.on('data', (c: Buffer) => {
+      outChunks.push(c)
+      if (this._mode === 'default') process.stdout.write(c)
+    })
+    proc.stderr?.on('data', (c: Buffer) => {
+      errChunks.push(c)
+      if (this._mode === 'default') process.stderr.write(c)
+    })
+
+    const exitCode: number = await new Promise((resolve, reject) => {
+      proc.on('error', reject)
+      proc.on('close', (code) => resolve(code ?? 0))
+    })
+
+    const stdout = Buffer.concat(outChunks)
+    const stderr = Buffer.concat(errChunks)
+    const result: ShResult = { exitCode, stdout, stderr }
+
+    if (exitCode !== 0 && this._throw) {
+      const err: any = new Error(`sh: command failed with exit ${exitCode}: ${this.args.join(' ')}`)
+      err.exitCode = exitCode
+      err.stdout = stdout
+      err.stderr = stderr
+      throw err
+    }
+
+    return result
+  }
+}
+
+const WHITESPACE = /\s/
+
+function tokenize(
+  strings: TemplateStringsArray,
+  values: unknown[],
+): { tokens: string[]; initialCwd?: string } {
+  const tokens: string[] = []
+  let current = ''
+  let inToken = false
+
+  const commit = () => {
+    if (inToken) {
+      tokens.push(current)
+      current = ''
+      inToken = false
+    }
+  }
+
+  const append = (s: string) => {
+    current += s
+    inToken = true
+  }
+
+  const appendValue = (val: unknown) => {
+    if (val == null) return
+    if (Array.isArray(val)) {
+      val.forEach((item, i) => {
+        if (i > 0) commit()
+        append(String(item))
+      })
+      return
+    }
+    append(String(val))
+  }
+
+  strings.forEach((literal, i) => {
+    for (let c = 0; c < literal.length; c++) {
+      const ch = literal[c]
+      if (WHITESPACE.test(ch)) commit()
+      else append(ch)
+    }
+    if (i < values.length) appendValue(values[i])
+  })
+  commit()
+
+  // Lift `cd <path> && <cmd...>` prefix into subprocess cwd
+  if (tokens.length >= 3 && tokens[0] === 'cd' && tokens[2] === '&&') {
+    return { tokens: tokens.slice(3), initialCwd: tokens[1] }
+  }
+  return { tokens }
+}
+
+export function sh(strings: TemplateStringsArray, ...values: unknown[]): Sh {
+  const { tokens, initialCwd } = tokenize(strings, values)
+  const s = new Sh(tokens)
+  if (initialCwd) s.cwd(initialCwd)
+  return s
+}

package/tools/deploy.ts

@@ -1,58 +1,126 @@
-import { $ } from 'bun'
+import { access, readFile, writeFile } from 'node:fs/promises'
 import { parseArgs } from 'util'
+import { sh } from './_shell'
+import { buildCommitArgs } from './_git-author'
 
 const cwd = process.cwd()
 
+const exists = async (p: string) => {
+  try {
+    await access(p)
+    return true
+  } catch {
+    return false
+  }
+}
+
+const readJson = async (p: string) => JSON.parse(await readFile(p, 'utf8'))
+
 const {
-  values: { changelogs: changelogsArg, 'changelogs-file': changelogsFile, yes },
+  values: {
+    changelogs: changelogsArg,
+    'changelogs-file': changelogsFile,
+    'auto-commit': autoCommit,
+    'auto-version': autoVersion,
+    version: versionArg,
+    yes,
+    help,
+  },
 } = parseArgs({
-  args: Bun.argv.slice(2),
+  args: process.argv.slice(2),
   options: {
     changelogs: { type: 'string' },
     'changelogs-file': { type: 'string' },
+    'auto-commit': { type: 'boolean' },
+    'auto-version': { type: 'boolean' },
+    version: { type: 'string' },
     yes: { type: 'boolean', short: 'y' },
+    help: { type: 'boolean', short: 'h' },
   },
   allowPositionals: true,
 })
 
+if (help) {
+  console.log(`Options:
+  --changelogs <text>        Changelogs text for the release
+  --changelogs-file <path>   Read changelogs from a file
+  --auto-commit              Auto-commit unstaged changes before deploying
+  --auto-version             Auto-bump patch version before deploying
+  --version <version>        Set explicit version for the release
+  -y, --yes                  Skip all prompts
+  -h, --help                 Show this help message`)
+  process.exit(0)
+}
+
 // Check git status
-const { exitCode } = await $`cd ${cwd} && git status`.nothrow()
+const { exitCode } = await sh`cd ${cwd} && git status`.quiet().nothrow()
 const isGitRepo = exitCode === 0
 
-let commitId = ''
-if (isGitRepo) {
-  const unstagedChanges = await $`cd ${cwd} && git diff --name-only --diff-filter=ACMR`.text()
-  if (unstagedChanges)
-    throw new Error('Unstaged changes found, please commit or stash your changes before deploying')
-
-  commitId = (await $`cd ${cwd} && git rev-parse HEAD`.text()).trim()
-} else if (!yes) {
+if (!isGitRepo && !yes) {
   const confirmContinue = prompt('No git repository found, continue? (y/n)')
   if (confirmContinue !== 'y') throw new Error('Deployment cancelled')
 }
 
 // Read application.json
-const app = await Bun.file(`${cwd}/application.json`).json()
-const config = await Bun.file(`${cwd}/.bricks/build/application-config.json`).json()
-
-// Get version from project's package.json
-const pkgFile = Bun.file(`${cwd}/package.json`)
-const version = (await pkgFile.exists()) ? (await pkgFile.json()).version : undefined
+const app = await readJson(`${cwd}/application.json`)
+const config = await readJson(`${cwd}/.bricks/build/application-config.json`)
+
+// Resolve version: explicit flag > auto-bump > package.json
+const pkgPath = `${cwd}/package.json`
+const pkgExists = await exists(pkgPath)
+let version: string | undefined
+
+if (versionArg) {
+  version = versionArg
+  if (pkgExists) {
+    const pkg = await readJson(pkgPath)
+    pkg.version = version
+    await writeFile(pkgPath, JSON.stringify(pkg, null, 2) + '\n')
+  }
+} else if (autoVersion && pkgExists) {
+  const pkg = await readJson(pkgPath)
+  const parts = (pkg.version || '0.0.0').split('.')
+  parts[2] = String(Number(parts[2] || 0) + 1)
+  version = parts.join('.')
+  pkg.version = version
+  await writeFile(pkgPath, JSON.stringify(pkg, null, 2) + '\n')
+} else {
+  version = pkgExists ? (await readJson(pkgPath)).version : undefined
+}
 
 // Get changelog from flag or file
 let changelogs = ''
 if (changelogsArg) {
   changelogs = changelogsArg
 } else if (changelogsFile) {
-  const file = Bun.file(changelogsFile)
-  if (!(await file.exists())) {
+  if (!(await exists(changelogsFile))) {
     throw new Error(`Changelogs file not found: ${changelogsFile}`)
   }
-  changelogs = await file.text()
+  changelogs = await readFile(changelogsFile, 'utf8')
 } else if (!yes) {
   changelogs = prompt('Enter changelogs (optional, press Enter to skip):') || ''
 }
 
+// Handle unstaged changes
+let commitId = ''
+if (isGitRepo) {
+  const unstagedChanges = await sh`cd ${cwd} && git diff --name-only --diff-filter=ACMR`.text()
+  if (unstagedChanges) {
+    if (autoCommit) {
+      const commitMsg = `chore: release ${version || 'new version'}`
+      const commitBody = changelogs || '[no changelogs]'
+      await sh`cd ${cwd} && git add -A`
+      const commitArgs = await buildCommitArgs(cwd, [commitMsg, commitBody])
+      await sh`cd ${cwd} && git ${commitArgs}`
+    } else {
+      throw new Error(
+        'Unstaged changes found, please commit or stash your changes before deploying',
+      )
+    }
+  }
+  commitId = (await sh`cd ${cwd} && git rev-parse HEAD`.text()).trim()
+}
+
 // Ask for confirmation
 if (!yes) {
   const confirm = prompt('Are you sure you want to deploy? (y/n)')
@@ -69,7 +137,7 @@ const releaseConfig = {
   bricks_project_last_commit_id: commitId || undefined,
 }
 const configPath = `${cwd}/.bricks/build/release-config.json`
-await Bun.write(configPath, JSON.stringify(releaseConfig))
+await writeFile(configPath, JSON.stringify(releaseConfig))
 
 const args = ['bricks', command, 'release', app.id, '-c', configPath, '--json']
 
@@ -81,7 +149,7 @@ if (changelogs) {
   args.push('--changelogs', changelogs)
 }
 
-const result = await $`${args}`.quiet().nothrow()
+const result = await sh`${args}`.quiet().nothrow()
 
 if (result.exitCode !== 0) {
   const output = result.stderr.toString() || result.stdout.toString()