bod-cli 0.10.3 → 0.10.5

package/package.json

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

package/src/cli.ts

@@ -5,6 +5,7 @@ import { configExists, setInstanceOverride } from './config'
 import loginCmd from './commands/login'
 import appsCmd from './commands/apps'
 import deployCmd from './commands/deploy'
+import packCmd from './commands/pack'
 import rollbackCmd from './commands/rollback'
 import logsCmd from './commands/logs'
 import envCmd from './commands/env'
@@ -39,6 +40,7 @@ const subCommands = {
   login: loginCmd,
   init: initCmd,
   deploy: deployCmd,
+  pack: packCmd,
   rollback: rollbackCmd,
   apps: appsCmd,
   logs: logsCmd,

package/src/commands/deploy.ts

@@ -2,6 +2,8 @@ import { defineCommand } from 'citty'
 import chalk from 'chalk'
 import { loadConfig, getResolvedInstance } from '../config'
 import { BodClient } from '../client'
+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> {
@@ -11,16 +13,8 @@ async function detectBranch(explicit?: string): Promise<string> {
   return branch || 'main'
 }
 
-function formatSize(bytes: number): string {
-  if (bytes < 1024) return `${bytes} B`
-  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`
-  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`
-}
-
 async function uploadDeploy(client: BodClient, appId: string, branch: string) {
-  const defaultExcludes = ['node_modules', '.git', 'dist', '.env.local', '.env.*.local']
-  const userExcludes = readExcludesFromYaml()
-  const allExcludes = [...new Set([...defaultExcludes, ...userExcludes])]
+  const allExcludes = resolveExcludes(readExcludesFromYaml())
   const excludeFlags = allExcludes.map(e => `--exclude=${e}`)
 
   // Auto-detect file:.. dependencies and include them in the tarball
@@ -113,6 +107,13 @@ async function uploadDeploy(client: BodClient, appId: string, branch: string) {
 
   const file = Bun.file(tmpFile)
   const size = file.size
+  // A source upload is normally ~1MB. Past this, name the culprit instead of leaving
+  // the operator to go hunting with `du` (that hunt is why `bod pack` exists).
+  if (size > 50 * 1e6) {
+    console.log(chalk.yellow(`Warning: upload tarball is ${formatSize(size)}. Largest entries:`))
+    for (const o of tarballOffenders(tmpFile)) console.log(chalk.yellow(`  ${formatSize(o.bytes).padStart(10)}  ${o.path}`))
+    console.log(chalk.yellow('Add the offender to `exclude:` in bodify.yaml, or run `bod pack --max-mb 50` in a predeploy guard.'))
+  }
   console.log(chalk.dim(`Uploading ${formatSize(size)}...`))
 
   const start = Date.now()

package/src/commands/pack.ts

@@ -0,0 +1,59 @@
+import { defineCommand } from 'citty'
+import chalk from 'chalk'
+import { formatSize } from '../utils/output'
+import { DEFAULT_EXCLUDES, resolveExcludes, tarballOffenders } from '../utils/excludes'
+import { readExcludesFromYaml } from '../utils/resolve'
+
+/**
+ * `bod pack` — pack the exact `bod deploy --upload` tarball WITHOUT uploading, report
+ * its size, and (with --max-mb) fail naming the top offenders by size.
+ *
+ * This is the shared home for the bloat guard apps used to hand-roll (blank's
+ * scripts/guard-deploy.ts duplicated bod-cli's default exclude list, so it drifted).
+ * An app picks it up by replacing its own tar-and-measure step with:
+ *     bod pack --max-mb 50     # nonzero exit ⇒ predeploy blocks
+ */
+export default defineCommand({
+  meta: { name: 'pack', description: 'Pack the upload tarball locally and report its size / top offenders' },
+  args: {
+    'max-mb': { type: 'string', description: 'Fail (exit 1) if the tarball exceeds this many MB' },
+    top: { type: 'string', description: 'How many offenders to list (default 8)' },
+    'list-excludes': { type: 'boolean', description: 'Print the effective exclude set and exit' },
+  },
+  async run({ args }) {
+    const excludes = resolveExcludes(readExcludesFromYaml())
+    if (args['list-excludes']) {
+      for (const p of excludes) {
+        const why = DEFAULT_EXCLUDES.find(d => d.pattern === p)?.why
+        console.log(`${p}${why ? chalk.dim(`  — ${why}`) : chalk.dim('  — from bodify.yaml')}`)
+      }
+      return
+    }
+
+    const tmpFile = `${Bun.env.TMPDIR || '/tmp'}/bod-pack-${Date.now()}.tar.gz`
+    const tar = Bun.spawnSync(['tar', 'czh', ...excludes.map(e => `--exclude=${e}`), '-f', tmpFile, '.'], {
+      stderr: 'pipe',
+      env: { ...process.env, COPYFILE_DISABLE: '1' },
+    })
+    if (tar.exitCode !== 0) {
+      console.error(chalk.red(`tar failed: ${tar.stderr.toString().slice(0, 300)}`))
+      process.exit(1)
+    }
+    const bytes = Bun.file(tmpFile).size
+    const limit = args['max-mb'] ? Number(args['max-mb']) : undefined
+    const over = limit !== undefined && bytes / 1e6 > limit
+
+    if (over || Bun.env.BOD_PACK_VERBOSE) {
+      const top = tarballOffenders(tmpFile, args.top ? Number(args.top) : 8)
+      console.error(chalk.bold('\nTop entries in the tarball (uncompressed):'))
+      for (const o of top) console.error(`  ${formatSize(o.bytes).padStart(10)}  ${o.path}`)
+    }
+    try { (await import('fs')).unlinkSync(tmpFile) } catch {}
+
+    if (over) {
+      console.error(chalk.red(`\nupload tarball ${(bytes / 1e6).toFixed(1)}MB exceeds ${limit}MB ceiling — exclude the offender above in bodify.yaml.`))
+      process.exit(1)
+    }
+    console.log(chalk.green(`upload tarball ${formatSize(bytes)}${limit ? ` (ceiling ${limit}MB)` : ''} OK`))
+  },
+})

package/src/utils/excludes.ts

@@ -0,0 +1,98 @@
+/**
+ * Upload-deploy exclude resolution.
+ *
+ * `bod deploy --upload` tars the WORKING TREE (deliberately NOT .gitignore-driven —
+ * untracked-but-needed files like generated config and built assets must still ship).
+ * That left every app hand-maintaining its own `exclude:` list, which drifts from
+ * reality until a large local-only dir silently rides the upload and breaks a deploy
+ * (2026-08-19: `.agent/checkpoints.git` ~56MB blew the 50MB ceiling on Blank).
+ *
+ * ── BSD-tar pattern gotcha (hard-won, do not "tidy" these into globs) ─────────────
+ * `tar --exclude=NAME` matches NAME as any path COMPONENT at any depth — so a bare
+ * `.agent` kills `./.agent` and `./packages/x/.agent` alike. the glob form
+ * `star-slash-native` does NOT match the top-level `./native` on BSD tar (macOS):
+ * that form once shipped
+ * native/ (~1.7GB NativeScript build) to prod. KEEP DEFAULTS BARE. The scaffold
+ * template still emits that same glob form for tests/, which is the same latent bug.
+ * Covered by test/excludes.test.ts ("bare pattern matches top level").
+ *
+ * ── Composition ──────────────────────────────────────────────────────────────────
+ * Effective set = DEFAULT_EXCLUDES ∪ bodify.yaml `exclude:` (union, never replace).
+ * Escape hatch: an entry prefixed with `!` opts a default back IN, for the rare app
+ * that genuinely serves one of these paths:
+ *
+ *     exclude:
+ *       - "native"    # app-specific addition
+ *       - "!dist"     # this app ships a prebuilt dist/ — undo the default
+ *
+ * `!` only cancels defaults; it is not a general negation (tar has no such concept).
+ */
+
+/** Applied to every `--upload` deploy. Bare names on purpose (see gotcha above).
+ *  Bar for entry: unambiguously LOCAL state that no app can serve at runtime.
+ *  Deliberately NOT here: `tests`/`test`, `native`, `store`, `evals` — all plausible
+ *  real source-directory names; a bare pattern would match them at any depth, and
+ *  dropping something an app serves is far worse than a few MB of tarball. */
+export const DEFAULT_EXCLUDES: { pattern: string; why: string }[] = [
+  { pattern: 'node_modules', why: 'prod re-installs from the lockfile' },
+  { pattern: '.git', why: 'repo history; the upload is a source snapshot' },
+  { pattern: 'dist', why: 'build output — prod builds from source (pre-existing default)' },
+  { pattern: '.env.local', why: 'local-only secrets; prod env comes from the platform' },
+  { pattern: '.env.*.local', why: 'local-only per-env secrets' },
+  { pattern: '.agent', why: 'agentx runtime state; .agent/checkpoints.git alone hit ~56MB' },
+  { pattern: '.claude', why: 'Claude Code local session/settings state' },
+  { pattern: '.cursor', why: 'Cursor editor local state' },
+  { pattern: '.vscode', why: 'VS Code local workspace state' },
+  { pattern: '.idea', why: 'JetBrains local workspace state' },
+  { pattern: '.tmp', why: 'repo-wide scratch convention — never runtime input' },
+  { pattern: 'scratchpad', why: 'agent scratch dir, same class as .tmp' },
+  { pattern: '.bodify', why: 'local `bod serve` state / dev database' },
+  // Enumerating these by hand is what failed: `.mcp-android`/`.mcp-ios` were listed
+  // while `.mcp-playwright/profile` (41.8MB) and `.mcp-cursor/cache` (7.3MB) sailed
+  // through on para-li. The family is the unit, not each member. Still a BARE
+  // pattern (no leading `*/`), so it matches at top level too — pinned by test.
+  { pattern: '.mcp-*', why: 'local MCP tool state (android/ios/playwright/cursor/…)' },
+  { pattern: '.bodify-bak*', why: 'local `bod serve` db backups — same class as .bodify' },
+  { pattern: '.frame-dev', why: 'frame dev-server cache' },
+  { pattern: '.DS_Store', why: 'macOS Finder metadata' },
+]
+
+/** Union the built-in defaults with an app's `exclude:` list, honouring `!x` opt-ins. */
+export function resolveExcludes(userExcludes: string[] = []): string[] {
+  const optedIn = new Set(
+    userExcludes.filter(e => e.startsWith('!')).map(e => e.slice(1).trim()),
+  )
+  const additions = userExcludes.filter(e => !e.startsWith('!'))
+  const defaults = DEFAULT_EXCLUDES.map(d => d.pattern).filter(p => !optedIn.has(p))
+  // Late `!x` also cancels a same-named app entry, so `!dist` means what it reads.
+  return [...new Set([...defaults, ...additions])].filter(p => !optedIn.has(p))
+}
+
+export interface Offender { path: string; bytes: number }
+
+/**
+ * Top space consumers in an ALREADY-PACKED tarball, so a size failure names the
+ * culprit instead of guessing at it. Reads the archive index (uncompressed member
+ * sizes) and rolls entries up to their first two path components, which is what
+ * makes `.agent/checkpoints.git` legible rather than 4,000 loose object files.
+ */
+export function tarballOffenders(tarPath: string, limit = 8): Offender[] {
+  const proc = Bun.spawnSync(['tar', 'tvf', tarPath], { stdout: 'pipe', stderr: 'pipe' })
+  if (proc.exitCode !== 0) return []
+  const totals = new Map<string, number>()
+  for (const line of proc.stdout.toString().split('\n')) {
+    // The owner columns differ between bsdtar (`0 elya wheel`) and GNU tar (`elya/wheel`),
+    // so anchor on the stable part: <size> <mon> <day> <time-or-year> <path>.
+    const m = line.match(/\s(\d+)\s+\w{3}\s+\d+\s+[\d:]+\s+(.+)$/)
+    if (!m) continue
+    const bytes = Number(m[1])
+    const parts = m[2].replace(/^\.\//, '').split('/').filter(Boolean)
+    if (!parts.length) continue
+    const key = parts.slice(0, 2).join('/')
+    totals.set(key, (totals.get(key) ?? 0) + bytes)
+  }
+  return [...totals]
+    .map(([path, bytes]) => ({ path, bytes }))
+    .sort((a, b) => b.bytes - a.bytes)
+    .slice(0, limit)
+}

package/src/utils/output.ts

@@ -25,3 +25,10 @@ export function printKv(entries: Record<string, unknown>) {
     console.log(`${chalk.bold(k.padEnd(maxKey))}  ${v}`)
   }
 }
+
+/** Human-readable byte size. Shared by deploy + pack. */
+export function formatSize(bytes: number): string {
+  if (bytes < 1024) return `${bytes} B`
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`
+}

package/test/excludes.test.ts

@@ -0,0 +1,135 @@
+import { describe, expect, test, beforeAll, afterAll } from 'bun:test'
+import { mkdirSync, writeFileSync, rmSync } from 'fs'
+import { join } from 'path'
+import { tmpdir } from 'os'
+import { DEFAULT_EXCLUDES, resolveExcludes, tarballOffenders } from '../src/utils/excludes'
+
+const FIX = join(tmpdir(), `bod-excludes-fixture-${process.pid}`)
+const TAR = join(tmpdir(), `bod-excludes-fixture-${process.pid}.tar.gz`)
+
+/** Pack FIX with `excludes` exactly the way deploy.ts does, return the member list. */
+function pack(excludes: string[], out = TAR): string[] {
+  const r = Bun.spawnSync(['tar', 'czh', ...excludes.map(e => `--exclude=${e}`), '-f', out, '.'], {
+    cwd: FIX, stderr: 'pipe', env: { ...process.env, COPYFILE_DISABLE: '1' },
+  })
+  if (r.exitCode !== 0) throw new Error(r.stderr.toString())
+  const l = Bun.spawnSync(['tar', 'tzf', out], { stdout: 'pipe' })
+  return l.stdout.toString().split('\n').map(s => s.replace(/^\.\//, '').replace(/\/$/, '')).filter(Boolean)
+}
+
+beforeAll(() => {
+  const f = (p: string, body = 'x') => {
+    const abs = join(FIX, p)
+    mkdirSync(abs.slice(0, abs.lastIndexOf('/')), { recursive: true })
+    writeFileSync(abs, body)
+  }
+  // local state that must NEVER ship — at top level (the BSD-tar failure mode) AND nested
+  f('.agent/checkpoints.git/pack.bin', 'A'.repeat(3_000_000)) // the 2026-08-19 incident
+  f('packages/x/.agent/state.json')
+  f('.claude/settings.json'); f('.cursor/rules'); f('.tmp/junk'); f('scratchpad/note')
+  f('.bodify/dev.db'); f('.mcp-ios/x'); f('.mcp-android/x'); f('.vscode/settings.json')
+  // the family members hand-enumeration missed on para-li (41.8MB + 7.3MB)
+  f('.mcp-playwright/profile/p.bin'); f('.mcp-cursor/cache/c.bin')
+  f('packages/x/.mcp-ios/s.json'); f('.bodify-bak-1/data.db')
+  f('.frame-dev/cache'); f('.DS_Store'); f('.env.local', 'SECRET=1')
+  // per-app exclusion target
+  f('native/App.js')
+  // MUST SHIP
+  f('public/app.js', 'served')
+  f('config.generated.json', '{"generated":true}') // untracked-but-needed — why .gitignore is not used
+  f('dist/bundle.js', 'built')                     // re-included via the `!dist` escape hatch
+  f('src/store/index.ts')                          // a real source dir named like a hand-rolled exclude
+  f('src/test/unit.ts')
+  f('src/mcp-client/keep.ts')                      // a real source dir the `.mcp-*` family must NOT eat
+})
+afterAll(() => {
+  rmSync(FIX, { recursive: true, force: true })
+  rmSync(TAR, { force: true })
+})
+
+describe('resolveExcludes', () => {
+  test('.agent is a default (the incident that motivated this)', () => {
+    expect(DEFAULT_EXCLUDES.map(d => d.pattern)).toContain('.agent')
+  })
+
+  test('every default is a BARE name, never a glob path — `star/x` misses top-level ./x on BSD tar', () => {
+    for (const { pattern } of DEFAULT_EXCLUDES) expect(pattern).not.toContain('/')
+  })
+
+  test('per-app excludes COMPOSE with the defaults (union, not replace)', () => {
+    const r = resolveExcludes(['native'])
+    expect(r).toContain('native')
+    expect(r).toContain('.agent')
+    expect(r).toContain('node_modules')
+  })
+
+  test('`!x` opts a default back in', () => {
+    expect(resolveExcludes([])).toContain('dist')
+    expect(resolveExcludes(['!dist'])).not.toContain('dist')
+    expect(resolveExcludes(['!dist'])).toContain('.agent') // only the named one is cancelled
+  })
+
+  test('deliberately NOT defaults — plausible real source dir names', () => {
+    const p = DEFAULT_EXCLUDES.map(d => d.pattern)
+    for (const risky of ['test', 'tests', 'native', 'store', 'evals']) expect(p).not.toContain(risky)
+  })
+})
+
+describe('tar behaviour on this machine (BSD tar)', () => {
+  test('a BARE pattern excludes the dir at TOP LEVEL and at depth', () => {
+    const members = pack(['.agent'])
+    expect(members).not.toContain('.agent/checkpoints.git/pack.bin')
+    expect(members).not.toContain('packages/x/.agent/state.json')
+  })
+
+  // The regression guard: the glob form silently stops matching top-level dirs.
+  // This is the exact bug that shipped native/ (~1.7GB) to prod.
+  test('the `star/name` glob form does NOT match a top-level dir — so defaults must stay bare', () => {
+    const members = pack(['*/.agent'])
+    expect(members).toContain('.agent/checkpoints.git/pack.bin')   // top-level SURVIVED
+    expect(members).not.toContain('packages/x/.agent/state.json')  // nested was excluded
+  })
+})
+
+describe('the real upload tarball', () => {
+  let members: string[]
+  beforeAll(() => { members = pack(resolveExcludes(['native', '!dist'])) })
+
+  test('default-excluded local state is absent, including at top level', () => {
+    for (const gone of [
+      '.agent/checkpoints.git/pack.bin', 'packages/x/.agent/state.json',
+      '.claude/settings.json', '.cursor/rules', '.tmp/junk', 'scratchpad/note',
+      '.bodify/dev.db', '.mcp-ios/x', '.mcp-android/x', '.vscode/settings.json',
+      '.frame-dev/cache', '.DS_Store', '.env.local',
+      '.mcp-playwright/profile/p.bin', '.mcp-cursor/cache/c.bin',
+      'packages/x/.mcp-ios/s.json', '.bodify-bak-1/data.db',
+    ]) expect(members).not.toContain(gone)
+  })
+
+  test('a per-app exclude still applies', () => {
+    expect(members).not.toContain('native/App.js')
+  })
+
+  test('the `!dist` escape hatch really re-includes a default-excluded path', () => {
+    expect(members).toContain('dist/bundle.js')
+    expect(pack(resolveExcludes([]), TAR + '.2')).not.toContain('dist/bundle.js')
+    rmSync(TAR + '.2', { force: true })
+  })
+
+  test('paths that must ship are still present', () => {
+    expect(members).toContain('public/app.js')
+    expect(members).toContain('config.generated.json') // untracked-but-needed
+    expect(members).toContain('src/store/index.ts')
+    expect(members).toContain('src/test/unit.ts')
+    expect(members).toContain('src/mcp-client/keep.ts') // `.mcp-*` is dot-anchored, not a substring
+  })
+})
+
+describe('tarballOffenders', () => {
+  test('names the biggest entry rolled up to two path components', () => {
+    pack([]) // no excludes → the 3MB .agent blob is in the archive
+    const top = tarballOffenders(TAR)
+    expect(top[0].path).toBe('.agent/checkpoints.git')
+    expect(top[0].bytes).toBeGreaterThan(2_900_000)
+  })
+})