bod-cli 0.10.10 → 0.10.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bod-cli",
-  "version": "0.10.10",
+  "version": "0.10.11",
   "type": "module",
   "bin": {
     "bod": "./src/cli.ts"

package/src/commands/deploy.ts

@@ -6,11 +6,37 @@ import { formatSize } from '../utils/output'
 import { resolveExcludes, tarballOffenders } from '../utils/excludes'
 import { resolveAppId, resolveAppName, readInstanceFromYaml, readDeployModeFromYaml, readExcludesFromYaml, detectSiblingDeps, readYamlConfig, resolveRepoFromYaml } from '../utils/resolve'
 
-async function detectBranch(explicit?: string): Promise<string> {
+/**
+ * The branch to deploy — never the literal string `HEAD`.
+ *
+ * `git rev-parse --abbrev-ref HEAD` prints `HEAD` in a DETACHED checkout, which is what
+ * every GitHub Actions run and every detached worktree is. That string was then deployed
+ * as an ordinary branch name: a real deployment, a live `head--<app>` preview host, DNS
+ * and a Caddy route, for a branch that does not exist. Three of them existed on the blank
+ * app on 2026-09-05, and the server now refuses one outright (400), so resolving it here
+ * is what keeps CI deploying instead of failing.
+ *
+ * CI knows the answer even when git does not: Actions sets GITHUB_HEAD_REF on a
+ * pull_request run and GITHUB_REF_NAME on a push. Those are consulted before giving up.
+ * If nothing can name the branch we REFUSE rather than guessing `main` — silently
+ * promoting an arbitrary detached commit to production is far worse than stopping.
+ */
+export async function detectBranch(explicit?: string): Promise<string> {
   if (explicit) return explicit
   const proc = Bun.spawnSync(['git', 'rev-parse', '--abbrev-ref', 'HEAD'])
   const branch = proc.exitCode === 0 ? proc.stdout.toString().trim() : ''
-  return branch || 'main'
+  if (branch && branch.toUpperCase() !== 'HEAD') return branch
+
+  const fromCi = (process.env.GITHUB_HEAD_REF || process.env.GITHUB_REF_NAME || '').trim()
+  if (fromCi && fromCi.toUpperCase() !== 'HEAD') return fromCi
+
+  if (branch.toUpperCase() === 'HEAD') {
+    throw new Error(
+      'Detached HEAD: git reports no branch, and no CI branch variable is set. ' +
+      'Pass --branch explicitly (in GitHub Actions: --branch "${{ github.head_ref || github.ref_name }}").'
+    )
+  }
+  return 'main' // not a git repo at all — the historical default
 }
 
 export async function uploadDeploy(client: BodClient, appId: string, branch: string) {

package/test/detect-branch.test.ts

@@ -0,0 +1,76 @@
+import { describe, test, expect, beforeAll, afterAll } from 'bun:test'
+import { mkdtempSync, rmSync } from 'fs'
+import { tmpdir } from 'os'
+import { join } from 'path'
+import { detectBranch } from '../src/commands/deploy'
+
+/**
+ * A DETACHED HEAD IS NOT A BRANCH CALLED "HEAD".
+ *
+ * `git rev-parse --abbrev-ref HEAD` prints the literal string `HEAD` in a detached
+ * checkout — every GitHub Actions run, and any detached worktree. `bod deploy` used to
+ * send that as the branch, and the platform obligingly created a real deployment, a live
+ * `head--<app>` host, DNS and a Caddy route for it. Three existed on the blank app on
+ * 2026-09-05.
+ *
+ * This uses a REAL git repo in a real detached state, not a stubbed `git` — the whole bug
+ * lives in what git actually prints.
+ */
+
+let dir: string
+let origCwd: string
+const git = (...args: string[]) => Bun.spawnSync(['git', ...args], { cwd: dir })
+
+beforeAll(() => {
+  origCwd = process.cwd()
+  dir = mkdtempSync(join(tmpdir(), 'bod-detect-branch-'))
+  git('init', '-q', '-b', 'feature-x')
+  git('config', 'user.email', 't@t.t'); git('config', 'user.name', 't')
+  Bun.spawnSync(['touch', join(dir, 'f')])
+  git('add', '.'); git('commit', '-qm', 'c1')
+})
+
+afterAll(() => { process.chdir(origCwd); rmSync(dir, { recursive: true, force: true }) })
+
+const withEnv = async (env: Record<string, string | undefined>, fn: () => Promise<unknown>) => {
+  const saved: Record<string, string | undefined> = {}
+  for (const k of Object.keys(env)) { saved[k] = process.env[k]; if (env[k] === undefined) delete process.env[k]; else process.env[k] = env[k]! }
+  try { return await fn() } finally {
+    for (const k of Object.keys(saved)) { if (saved[k] === undefined) delete process.env[k]; else process.env[k] = saved[k]! }
+  }
+}
+const noCi = { GITHUB_HEAD_REF: undefined, GITHUB_REF_NAME: undefined }
+
+describe('detectBranch', () => {
+  test('an attached checkout reports its real branch', async () => {
+    process.chdir(dir)
+    expect(await withEnv(noCi, () => detectBranch())).toBe('feature-x')
+  })
+
+  test('an explicit branch always wins', async () => {
+    process.chdir(dir)
+    expect(await withEnv(noCi, () => detectBranch('release'))).toBe('release')
+  })
+
+  test('a DETACHED checkout refuses instead of deploying a branch named HEAD', async () => {
+    process.chdir(dir)
+    const sha = Bun.spawnSync(['git', 'rev-parse', 'HEAD'], { cwd: dir }).stdout.toString().trim()
+    git('checkout', '-q', sha)
+    // Prove the rig: git really does print the literal string here.
+    expect(Bun.spawnSync(['git', 'rev-parse', '--abbrev-ref', 'HEAD'], { cwd: dir }).stdout.toString().trim()).toBe('HEAD')
+
+    await expect(withEnv(noCi, () => detectBranch())).rejects.toThrow(/Detached HEAD/)
+  })
+
+  test('...but a GitHub Actions run resolves from its own env instead of failing', async () => {
+    process.chdir(dir) // still detached from the previous test
+    expect(await withEnv({ ...noCi, GITHUB_REF_NAME: 'main' }, () => detectBranch())).toBe('main')
+    // A pull_request run: head_ref is the source branch and wins over the merge ref.
+    expect(await withEnv({ GITHUB_HEAD_REF: 'feat/pr', GITHUB_REF_NAME: '123/merge' }, () => detectBranch())).toBe('feat/pr')
+  })
+
+  test('a CI variable that is itself HEAD is not accepted either', async () => {
+    process.chdir(dir)
+    await expect(withEnv({ ...noCi, GITHUB_REF_NAME: 'HEAD' }, () => detectBranch())).rejects.toThrow(/Detached HEAD/)
+  })
+})