bod-cli 0.7.4 → 0.8.4

package/.github/workflows/publish.yml

@@ -27,9 +27,6 @@ jobs:
       - name: Install dependencies
         run: bun install --frozen-lockfile
 
-      - name: Build
-        run: bun run build
-
       - name: Configure Git
         run: |
           git config user.name "GitHub Actions Bot"

package/package.json

@@ -1,12 +1,9 @@
 {
   "name": "bod-cli",
-  "version": "0.7.4",
+  "version": "0.8.4",
   "type": "module",
   "bin": {
-    "bod": "./dist/cli.js"
-  },
-  "scripts": {
-    "build": "bun build src/cli.ts --outdir dist --target node --format esm"
+    "bod": "./src/cli.ts"
   },
   "dependencies": {
     "@inquirer/prompts": "^7.0.0",

package/src/cli.ts

@@ -16,6 +16,7 @@ import serveCmd from './commands/serve'
 import sshCmd from './commands/ssh'
 import publishCmd from './commands/publish'
 import dbCmd from './commands/db'
+import pkg from '../package.json' with { type: 'json' }
 
 // Parse --instance / --local / -l early so it's set before citty dispatches subcommands.
 // Supports both `--instance=NAME` and `--instance NAME` forms.
@@ -53,7 +54,7 @@ const subCommands = {
 const main = defineCommand({
   meta: {
     name: 'bod',
-    version: '0.1.0',
+    version: pkg.version,
     description: 'Unified CLI for the Bod product family',
   },
   args: {

package/src/commands/db.ts

@@ -79,42 +79,76 @@ function directTarget(port: number, token: string, label: string): DbTarget {
   }
 }
 
+/** True if cwd has a `bodify.yaml` (i.e. we're inside a Bodify app project). */
+function isInAppFolder(): boolean {
+  return existsSync(join(process.cwd(), 'bodify.yaml'))
+}
+
 /**
  * Resolve a target for DB commands.
  *
- * Precedence:
- *   1. Explicit `--instance <name>` / `BOD_INSTANCE` → always the Bodify agent
- *      proxy for that instance. Local shortcuts are skipped so the flag isn't
- *      silently ignored while `bod serve` runs in the same dir.
- *   2. Otherwise, prefer direct-to-BodDB if we can discover the port + admin
- *      password locally (`.bodify/serve.info.json` from `bod serve`, or
- *      `.env BODDB_ADMIN_PASSWORD` + `bodify.yaml database.port`).
- *   3. Fall back to the Bodify agent proxy for the default instance.
+ * Explicit, predictable rules — no silent auto-detection:
+ *   • `-l` / `--local`: REQUIRE a running `bod serve` in cwd. Connects
+ *     directly to its BodDB (port from `.bodify/serve.info.json`, or
+ *     `.env BODDB_ADMIN_PASSWORD` + `bodify.yaml database.port`). Fails
+ *     loudly if no local serve is discoverable — we never silently fall
+ *     through to prod when `-l` was requested.
+ *   • No `-l` (default): route through the Bodify agent proxy (remote prod
+ *     by default, or the instance named by `--instance` / `BOD_INSTANCE`).
+ *     Even when `bod serve` is running in the same directory, we stay on
+ *     prod unless `-l` was passed — this is the opposite of the old
+ *     behavior and prevents "which DB did I just write to?" confusion.
+ *
+ * Every resolved target carries a human label that the command layer prints
+ * as a banner before running, so the user can always see where writes land.
  */
-async function resolveDbTarget(appArg: string | undefined): Promise<DbTarget> {
-  const explicitInstance = !!(process.env._BOD_INSTANCE_OVERRIDE || process.env.BOD_INSTANCE)
+async function resolveDbTarget(appArg: string | undefined, wantLocal: boolean): Promise<DbTarget> {
+  const inApp = isInAppFolder()
+  const scopeLabel = inApp ? 'APP' : 'BODIFY-PLATFORM'
 
-  if (!explicitInstance) {
-    // 1. Live `bod serve` info file — authoritative (correct port even if scanned).
+  if (wantLocal) {
+    // `-l` only makes sense inside an app folder — the Bodify platform DB
+    // isn't something you run locally via `bod serve`.
+    if (!inApp) {
+      console.error(chalk.red('--local (-l) only works inside a Bodify app folder (needs bodify.yaml).'))
+      process.exit(1)
+    }
     const info = readServeInfo()
-    if (info) return directTarget(info.dbPort, info.dbAdminPassword, 'local serve')
-    // 2. .env BODDB_ADMIN_PASSWORD + bodify.yaml database.port — works without restarting serve.
+    if (info) return directTarget(info.dbPort, info.dbAdminPassword, `LOCAL ${scopeLabel} bod serve`)
     const envPw = readDotEnv('BODDB_ADMIN_PASSWORD')
-    if (envPw) return directTarget(readDbPortFromYaml(), envPw, 'direct via .env')
+    if (envPw) return directTarget(readDbPortFromYaml(), envPw, `LOCAL ${scopeLabel} via .env`)
+    console.error(chalk.red('--local (-l) requires a running `bod serve` in this directory.'))
+    console.error(chalk.dim('  Expected `.bodify/serve.info.json` or BODDB_ADMIN_PASSWORD in .env — neither found.'))
+    process.exit(1)
   }
 
-  // 3. Bodify agent proxy (deployed apps — or explicitly-requested instance).
+  // Remote: Bodify agent proxy. Inside an app folder → that app's DB;
+  // outside → the Bodify platform app's own DB.
   const { url, apiKey } = getResolvedInstance(loadConfig())
   const client = new BodClient(url, apiKey)
-  const appId = await resolveAppId(client, resolveAppName(appArg))
+  const effectiveAppArg = inApp ? appArg : (appArg ?? 'bodify')
+  const appId = await resolveAppId(client, resolveAppName(effectiveAppArg))
+  const instanceLabel = process.env._BOD_INSTANCE_OVERRIDE || process.env.BOD_INSTANCE || 'default'
   return {
-    label: `agent ${url} → app ${appId}`,
+    label: `REMOTE ${scopeLabel} ${instanceLabel} (${url}) → app ${appId}`,
     request<T>(method: string, sub: string, body?: unknown): Promise<T> {
       return client.request<T>(method, `/apps/${appId}${sub}`, body)
     },
   }
 }
 
+/** Print a clear banner showing the resolved DB target. Always on stderr. */
+function printTargetBanner(target: DbTarget): void {
+  const isLocal = target.label.startsWith('LOCAL')
+  const color = isLocal ? chalk.cyan : chalk.yellow
+  console.error(color(`→ DB target: ${target.label}${isInAppFolder() ? '' : '  [no bodify.yaml in cwd]'}`))
+}
+
+/** Read --local / -l from argv before citty parses, so all subcommands see it. */
+function readLocalFlag(): boolean {
+  return process.argv.slice(2).some(a => a === '--local' || a === '-l')
+}
+
 /** Read body from positional arg, --file, or stdin (in that order). */
 async function readBody(positional: string | undefined, file: string | undefined): Promise<unknown> {
   let raw: string | undefined
@@ -201,7 +235,8 @@ const getCmd = defineCommand({
   },
   async run({ args }) {
     strictArgs(['path', 'app', 'a', 'deep', 'd', 'limit', 'n', 'offset', 'output', 'o'])
-    const target = await resolveDbTarget(args.app)
+    const target = await resolveDbTarget(args.app, readLocalFlag())
+    printTargetBanner(target)
     const path = normalizePath(args.path)
     const qs: string[] = []
     if (!args.deep) {
@@ -229,7 +264,8 @@ const setCmd = defineCommand({
   async run({ args }) {
     strictArgs(['path', 'value', 'app', 'a', 'file', 'f'])
     const body = await readBody(args.value, args.file)
-    const target = await resolveDbTarget(args.app)
+    const target = await resolveDbTarget(args.app, readLocalFlag())
+    printTargetBanner(target)
     await target.request('PUT', `/db/${normalizePath(args.path)}`, body)
     console.log(chalk.green(`✓ Set ${args.path}`))
   },
@@ -246,7 +282,8 @@ const updateCmd = defineCommand({
   async run({ args }) {
     strictArgs(['path', 'value', 'app', 'a', 'file', 'f'])
     const body = await readBody(args.value, args.file)
-    const target = await resolveDbTarget(args.app)
+    const target = await resolveDbTarget(args.app, readLocalFlag())
+    printTargetBanner(target)
     await target.request('PATCH', `/db/${normalizePath(args.path)}`, body)
     console.log(chalk.green(`✓ Updated ${args.path}`))
   },
@@ -263,7 +300,8 @@ const pushCmd = defineCommand({
   async run({ args }) {
     strictArgs(['path', 'value', 'app', 'a', 'file', 'f'])
     const body = await readBody(args.value, args.file)
-    const target = await resolveDbTarget(args.app)
+    const target = await resolveDbTarget(args.app, readLocalFlag())
+    printTargetBanner(target)
     const res = await target.request<DbResponse>('POST', `/db/${normalizePath(args.path)}`, body)
     console.log(chalk.green(`✓ Pushed → ${args.path}/${res.key}`))
   },
@@ -282,7 +320,8 @@ const deleteCmd = defineCommand({
       console.error(chalk.yellow(`Refusing to delete "${args.path}" without --confirm (-y).`))
       process.exit(1)
     }
-    const target = await resolveDbTarget(args.app)
+    const target = await resolveDbTarget(args.app, readLocalFlag())
+    printTargetBanner(target)
     await target.request('DELETE', `/db/${normalizePath(args.path)}`)
     console.log(chalk.green(`✓ Deleted ${args.path}`))
   },
@@ -350,7 +389,8 @@ const queryCmd = defineCommand({
       limit: args.limit ? Number(args.limit) : undefined,
       offset: args.offset ? Number(args.offset) : undefined,
     }
-    const target = await resolveDbTarget(args.app)
+    const target = await resolveDbTarget(args.app, readLocalFlag())
+    printTargetBanner(target)
     const res = await target.request<DbResponse>('POST', `/query/${normalizePath(args.path)}`, body)
     let rows = res.data as Array<Record<string, unknown>> | null
     if (!args.deep && Array.isArray(rows)) {