bod-cli 0.3.2 → 0.5.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bod-cli",
-  "version": "0.3.2",
+  "version": "0.5.2",
   "type": "module",
   "bin": {
     "bod": "./dist/cli.js"
@@ -13,6 +13,7 @@
     "chalk": "^5.3.0",
     "citty": "^0.1.6",
     "cli-table3": "^0.6.5",
+    "yaml": "^2.8.3",
     "zod": "^3.23.0"
   },
   "devDependencies": {

package/src/cli.ts

@@ -14,10 +14,13 @@ import removeCmd from './commands/remove'
 import openCmd from './commands/open'
 import serveCmd from './commands/serve'
 import sshCmd from './commands/ssh'
+import publishCmd from './commands/publish'
 
-// Parse --instance early so it's set before citty dispatches subcommands
+// Parse --instance / --local / -l early so it's set before citty dispatches subcommands
 const instanceFlag = process.argv.find(a => a.startsWith('--instance='))?.split('=').slice(1).join('=')
+const isLocal = process.argv.includes('--local') || process.argv.includes('-l')
 if (instanceFlag) setInstanceOverride(instanceFlag)
+else if (isLocal) setInstanceOverride('local')
 
 const subCommands = {
   login: loginCmd,
@@ -32,6 +35,7 @@ const subCommands = {
   open: openCmd,
   serve: serveCmd,
   ssh: sshCmd,
+  publish: publishCmd,
 }
 
 const main = defineCommand({
@@ -72,6 +76,7 @@ const main = defineCommand({
       { value: 'init',     name: 'init      — Initialize a project' },
       { value: 'add',      name: 'add       — Add a package' },
       { value: 'remove',   name: 'remove    — Remove a package' },
+      { value: 'publish',  name: 'publish   — Publish package to registry' },
       { value: 'login',    name: 'login     — Add/switch instance' },
       { value: 'exit',     name: 'exit      — Exit' },
     ]
@@ -79,7 +84,7 @@ const main = defineCommand({
     while (true) {
       let command: string
       try {
-        command = await select({ message: 'What would you like to do?', choices })
+        command = await select({ message: 'What would you like to do?', choices, theme: { prefix: { idle: '>', done: '>' }, icon: { cursor: '>' }, style: { help: () => '', keysHelpTip: () => '' } } })
       } catch (e) {
         if ((e as Error).name === 'ExitPromptError') return
         throw e
@@ -135,6 +140,7 @@ async function getInteractiveArgs(command: string): Promise<string[] | null> {
         if (!pkg) return null
         return [pkg]
       }
+      case 'publish': return []
       default: return []
     }
   } catch (e) {

package/src/commands/deploy.ts

@@ -2,7 +2,7 @@ import { defineCommand } from 'citty'
 import chalk from 'chalk'
 import { loadConfig, getResolvedInstance } from '../config'
 import { BodClient } from '../client'
-import { resolveAppId, resolveAppName, readInstanceFromYaml, readDeployModeFromYaml } from '../utils/resolve'
+import { resolveAppId, resolveAppName, readInstanceFromYaml, readDeployModeFromYaml, readExcludesFromYaml, detectSiblingDeps } from '../utils/resolve'
 
 async function detectBranch(explicit?: string): Promise<string> {
   if (explicit) return explicit
@@ -11,36 +11,65 @@ 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) {
-  console.log(chalk.dim('Packing source...'))
-  const tar = Bun.spawn(
-    ['tar', 'cz', '--exclude=node_modules', '--exclude=.git', '--exclude=dist', '.'],
-    { stdout: 'pipe', stderr: 'pipe' },
-  )
+  const defaultExcludes = ['node_modules', '.git', 'dist']
+  const userExcludes = readExcludesFromYaml()
+  const allExcludes = [...new Set([...defaultExcludes, ...userExcludes])]
+  const excludeFlags = allExcludes.map(e => `--exclude=${e}`)
+
+  // Auto-detect file:.. dependencies and include them in the tarball
+  const siblingPaths = detectSiblingDeps()
+  if (siblingPaths.length) console.log(chalk.dim(`Including siblings: ${siblingPaths.join(', ')}`))
+
+  console.log(chalk.dim(`Packing source (excluding: ${allExcludes.join(', ')})...`))
+  const tmpFile = `${Bun.env.TMPDIR || '/tmp'}/bod-deploy-${Date.now()}.tar.gz`
+  const tar = Bun.spawnSync(['tar', 'cz', ...excludeFlags, '-f', tmpFile, '.', ...siblingPaths], { stderr: 'pipe' })
+  if (tar.exitCode !== 0) {
+    const errText = tar.stderr.toString()
+    throw new Error(`tar failed: ${errText}`)
+  }
+
+  const file = Bun.file(tmpFile)
+  const size = file.size
+  console.log(chalk.dim(`Uploading ${formatSize(size)}...`))
+
+  const start = Date.now()
   await client.upload<any>(
     `/apps/${appId}/deploy/upload`,
-    tar.stdout as ReadableStream,
+    file.stream(),
     { 'x-branch': branch },
   )
-  const exitCode = await tar.exited
-  if (exitCode !== 0) {
-    const errText = await new Response(tar.stderr).text().catch(() => '')
-    throw new Error(`tar failed: ${errText}`)
-  }
+  const elapsed = ((Date.now() - start) / 1000).toFixed(1)
+  console.log(chalk.dim(`Uploaded ${formatSize(size)} in ${elapsed}s`))
+
+  // Cleanup temp file
+  try { (await import('fs')).unlinkSync(tmpFile) } catch {}
 }
 
 async function gitDeploy(client: BodClient, appId: string, branch: string) {
   await client.post<any>(`/apps/${appId}/deploy`, { branch })
 }
 
-async function pollDeploy(client: BodClient, appId: string, since: number) {
+function branchToSubdomain(branch: string, domain: string, productionBranch: string): string {
+  if (branch === productionBranch) return domain
+  const sanitized = branch.toLowerCase().replace(/[^a-z0-9-]/g, '-').replace(/-+/g, '-').replace(/^-|-$/g, '')
+  return `${sanitized}--${domain}`
+}
+
+async function pollDeploy(client: BodClient, appId: string, since: number, instanceCaps?: { baseDomain?: string | null }, localConfig?: { localDomain?: string; caddyPort?: number } | null) {
   console.log(chalk.dim('Waiting for deployment...'))
   let lastStatus = ''
+  let lastLogTs = since
   for (let i = 0; i < 120; i++) {
     await Bun.sleep(2000)
     const detail = await client.get<any>(`/apps/${appId}`)
     const deps = detail.deployments ?? []
-    // Find the deployment created after we triggered (don't fall back to older ones)
     const latest = deps.find((d: any) => (d.createdAt ?? 0) >= since)
     if (!latest) continue
     const status = latest.status
@@ -48,13 +77,49 @@ async function pollDeploy(client: BodClient, appId: string, since: number) {
       console.log(chalk.dim(`  Status: ${status}`))
       lastStatus = status
     }
+
+    // Tail logs during build/deploy
+    try {
+      const signals = await client.get<any[]>(`/apps/${appId}/signals?limit=50&from=${lastLogTs + 1}`)
+      if (Array.isArray(signals) && signals.length) {
+        // Signals come desc — reverse for chronological display
+        for (const s of [...signals].reverse()) {
+          const time = new Date(s.ts).toISOString().slice(11, 23)
+          const msg = s.message ?? ''
+          if (s.level === 'error' || s.source === 'stderr') {
+            console.log(chalk.dim(time) + ' ' + chalk.red(msg))
+          } else {
+            console.log(chalk.dim(time) + ' ' + chalk.dim(msg))
+          }
+        }
+        lastLogTs = Math.max(...signals.map((s: any) => s.ts))
+      }
+    } catch { /* signal fetch is best-effort */ }
+
     if (status === 'live') {
       console.log(chalk.green(`✓ Deployment live!`))
-      if (detail.domain) console.log(chalk.dim(`  → https://${detail.domain}`))
+      if (detail.domain && latest.branch) {
+        const host = branchToSubdomain(latest.branch, detail.domain, detail.productionBranch ?? 'main')
+        const isPreview = host !== detail.domain
+        // For local instances, rewrite domain to localDomain variant
+        const baseDomain = instanceCaps?.baseDomain
+        const ld = localConfig?.localDomain
+        const port = localConfig?.caddyPort
+        let displayUrl: string
+        if (ld && baseDomain && host.endsWith(`.${baseDomain}`)) {
+          const localHost = host.slice(0, -(baseDomain.length + 1)) + `.${ld}`
+          displayUrl = `http://${localHost}${port ? `:${port}` : ''}`
+        } else {
+          displayUrl = `https://${host}`
+        }
+        console.log(`  → ${displayUrl}`)
+        if (isPreview) console.log(chalk.yellow(`  ⚠ Preview deployment (branch: ${latest.branch})`))
+      }
       return
     }
     if (status === 'failed') {
       console.error(chalk.red(`✗ Deployment failed`))
+      if (latest.error) console.error(chalk.red(`  ${latest.error}`))
       process.exit(1)
     }
   }
@@ -69,9 +134,15 @@ export default defineCommand({
     upload: { type: 'boolean', description: 'Upload local source instead of git clone', default: false },
   },
   async run({ args }) {
-    const { url, apiKey, name: instanceName } = getResolvedInstance(loadConfig(), readInstanceFromYaml())
-    if (readInstanceFromYaml()) console.log(chalk.dim(`Using instance "${instanceName}" from bodify.yaml`))
+    const { url, apiKey, name: instanceName, instance } = getResolvedInstance(loadConfig(), readInstanceFromYaml())
+    console.log(chalk.dim(`Using instance "${instanceName}"`))
     const client = new BodClient(url, apiKey)
+    // Fetch local config for URL generation
+    const isLocal = url.startsWith('http://localhost')
+    let localConfig: { localDomain?: string; caddyPort?: number } | null = null
+    if (isLocal) {
+      try { localConfig = await client.get<any>('/config/public') } catch {}
+    }
 
     const appName = resolveAppName(args.app)
 
@@ -95,7 +166,7 @@ export default defineCommand({
     const useUpload = forceUpload || !hasRepo
     console.log(chalk.dim(`Deploying ${appName} (branch: ${branch})${useUpload ? ' via upload' : ''}...`))
 
-    const since = Date.now()
+    const since = Date.now() - 5000 // buffer for clock skew
     if (useUpload) {
       await uploadDeploy(client, appId, branch)
     } else {
@@ -103,6 +174,6 @@ export default defineCommand({
     }
 
     console.log(chalk.green(`✓ Deployment queued`))
-    await pollDeploy(client, appId, since)
+    await pollDeploy(client, appId, since, instance.capabilities, localConfig)
   },
 })

package/src/commands/env.ts

@@ -32,8 +32,13 @@ function parseDotEnv(content: string): Record<string, string> {
     if (eqIdx === -1) continue
     const key = trimmed.slice(0, eqIdx).trim()
     let value = trimmed.slice(eqIdx + 1).trim()
-    if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith("'") && value.endsWith("'")))
+    if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith("'") && value.endsWith("'"))) {
       value = value.slice(1, -1)
+    } else {
+      // Strip inline comments (unquoted values only)
+      const commentIdx = value.indexOf(' #')
+      if (commentIdx !== -1) value = value.slice(0, commentIdx).trimEnd()
+    }
     env[key] = value
   }
   return env

package/src/commands/init/init.ts

@@ -1,11 +1,12 @@
 import { defineCommand } from 'citty'
 import { select, input, confirm } from '@inquirer/prompts'
 import chalk from 'chalk'
-import { existsSync, mkdirSync, writeFileSync, readdirSync } from 'fs'
+import { existsSync, mkdirSync, writeFileSync, readdirSync, readFileSync } from 'fs'
 import { basename, join } from 'path'
 import { loadConfig, getResolvedInstance, configExists } from '../../config'
 import { BodClient } from '../../client'
 import { TEMPLATES, type TemplateId } from './templates'
+import { parse as parseYaml, stringify as stringifyYaml } from 'yaml'
 
 type AppType = 'caab' | 'static' | 'server' | 'mixed' | 'unknown'
 
@@ -232,13 +233,27 @@ export default defineCommand({
         repo = proc.stdout.toString().trim()
       } catch { /* no git remote */ }
 
-      // bodify.yaml
-      if (existsSync(join(cwd, 'bodify.yaml'))) {
-        console.log(chalk.dim('bodify.yaml already exists, skipping'))
-      } else {
+      // bodify.yaml — create or merge missing fields
+      const yamlPath = join(cwd, 'bodify.yaml')
+      let yamlData: Record<string, any> = {}
+      let yamlExisted = false
+      if (existsSync(yamlPath)) {
+        yamlExisted = true
+        yamlData = parseYaml(readFileSync(yamlPath, 'utf8')) ?? {}
+      }
+      let yamlDirty = false
+      if (!yamlData.name) { yamlData.name = appName; yamlDirty = true }
+      if (!yamlExisted) {
         const useDb = detected === 'caab' && await confirm({ message: 'Enable database?', default: false })
-        writeFileSync(join(cwd, 'bodify.yaml'), generateBodifyYaml(appName, { database: useDb, repo }))
-        console.log(chalk.green('✓ Created bodify.yaml'))
+        if (useDb) { yamlData.database = true; yamlDirty = true }
+        if (repo) { yamlData.repo = repo; yamlDirty = true }
+        yamlDirty = true
+      }
+      if (yamlDirty) {
+        writeFileSync(yamlPath, stringifyYaml(yamlData))
+        console.log(chalk.green(yamlExisted ? '✓ Updated bodify.yaml' : '✓ Created bodify.yaml'))
+      } else {
+        console.log(chalk.dim('bodify.yaml already up to date'))
       }
 
       // Register
@@ -251,6 +266,11 @@ export default defineCommand({
         })
         console.log(chalk.green(`✓ App registered (id: ${app.id})`))
         if (app.domain) console.log(chalk.dim(`  Domain: ${app.domain}`))
+        // Persist appId + domain into bodify.yaml
+        let changed = false
+        if (app.id && !yamlData.appId) { yamlData.appId = app.id; changed = true }
+        if (app.domain && !yamlData.domain) { yamlData.domain = app.domain; changed = true }
+        if (changed) writeFileSync(yamlPath, stringifyYaml(yamlData))
       } catch (e) {
         console.warn(chalk.yellow(`Warning: Could not register: ${(e as Error).message}`))
       }

package/src/commands/publish.ts

@@ -0,0 +1,87 @@
+import { defineCommand } from 'citty'
+import chalk from 'chalk'
+import { readFileSync } from 'fs'
+import { loadConfig, getResolvedInstance } from '../config'
+import { BodClient } from '../client'
+
+export default defineCommand({
+  meta: { name: 'publish', description: 'Publish a package to Bodify registry' },
+  args: {
+    tag: { type: 'string', description: 'Dist-tag (default: latest)', default: 'latest' },
+  },
+  async run({ args }) {
+    // Read package.json
+    let pkg: { name: string; version: string; description?: string }
+    try {
+      pkg = JSON.parse(readFileSync('package.json', 'utf-8'))
+    } catch {
+      console.error(chalk.red('No package.json found in current directory'))
+      process.exit(1)
+    }
+    if (!pkg.name || !pkg.version) {
+      console.error(chalk.red('package.json must have name and version'))
+      process.exit(1)
+    }
+
+    const { url, apiKey, name: instanceName, instance } = getResolvedInstance(loadConfig())
+    if (!instance.capabilities.registryEnabled) {
+      console.error(chalk.red(`Registry not enabled on instance "${instanceName}"`))
+      process.exit(1)
+    }
+
+    console.log(chalk.dim(`Publishing ${pkg.name}@${pkg.version} to ${instanceName}...`))
+
+    // Pack tarball (npm pack works with any package manager)
+    const pack = Bun.spawnSync(['npm', 'pack', '--pack-destination', '.'], { stderr: 'pipe', stdout: 'pipe' })
+    if (pack.exitCode !== 0) {
+      console.error(chalk.red(`npm pack failed: ${pack.stderr.toString()}`))
+      process.exit(1)
+    }
+    const tarballPath = pack.stdout.toString().trim().split('\n').pop()!
+    const tarballData = readFileSync(tarballPath)
+    const tarballBase64 = tarballData.toString('base64')
+
+    // Build npm-compatible publish body
+    const distTag = args.tag || 'latest'
+    const safeName = pkg.name.replace('/', '%2f')
+    const tarballFilename = `${pkg.name.replace('@', '').replace('/', '-')}-${pkg.version}.tgz`
+
+    const body = {
+      name: pkg.name,
+      'dist-tags': { [distTag]: pkg.version },
+      versions: {
+        [pkg.version]: {
+          name: pkg.name,
+          version: pkg.version,
+          description: pkg.description,
+          dist: {
+            tarball: `${url}/api/registry/${safeName}/-/${tarballFilename}`,
+          },
+        },
+      },
+      _attachments: {
+        [tarballFilename]: {
+          content_type: 'application/octet-stream',
+          data: tarballBase64,
+          length: tarballData.length,
+        },
+      },
+    }
+
+    const client = new BodClient(url, apiKey)
+    try {
+      await client.put(`/registry/${encodeURIComponent(pkg.name)}`, body)
+      console.log(chalk.green(`✓ Published ${pkg.name}@${pkg.version}`))
+    } catch (e: any) {
+      if (e.message?.includes('409')) {
+        console.error(chalk.red(`${pkg.name}@${pkg.version} already exists`))
+      } else {
+        console.error(chalk.red(`Publish failed: ${e.message}`))
+      }
+      process.exit(1)
+    }
+
+    // Cleanup tarball
+    try { (await import('fs')).unlinkSync(tarballPath) } catch {}
+  },
+})

package/src/commands/serve.ts

@@ -4,7 +4,12 @@ import { existsSync } from 'fs'
 
 function resolveBodifyServe(): string {
   // Sibling directory convention: bod-cli and bodify live side by side
-  const sibling = join(import.meta.dir, '../../../bodify/src/serve.ts')
+  // Try both source (src/commands/) and dist (dist/) layouts
+  const candidates = [
+    join(import.meta.dir, '../../../bodify/src/serve.ts'),  // from src/commands/
+    join(import.meta.dir, '../../bodify/src/serve.ts'),     // from dist/
+  ]
+  const sibling = candidates.find(existsSync) ?? candidates[0]
   if (existsSync(sibling)) return sibling
   // Fallback: try global BODIFY_DIR env
   const envDir = process.env.BODIFY_DIR

package/src/config.ts

@@ -63,15 +63,14 @@ export function getDefaultInstance(config: Config): { name: string; instance: In
   return { name, instance: config.instances[name] }
 }
 
-/** Override instance from --instance flag or BOD_INSTANCE env var */
-let instanceOverride: string | undefined
-
+/** Override instance from --instance flag or BOD_INSTANCE env var.
+ *  Uses process.env to avoid bundler module-duplication issues. */
 export function setInstanceOverride(name: string | undefined) {
-  instanceOverride = name
+  if (name) process.env._BOD_INSTANCE_OVERRIDE = name
 }
 
-export function getResolvedInstance(config: Config, yamlInstance?: string): { name: string; url: string; apiKey: string; instance: Instance } {
-  const override = instanceOverride ?? process.env.BOD_INSTANCE ?? yamlInstance
+export function getResolvedInstance(config: Config, _yamlInstance?: string): { name: string; url: string; apiKey: string; instance: Instance } {
+  const override = process.env._BOD_INSTANCE_OVERRIDE ?? process.env.BOD_INSTANCE
   if (override) {
     const inst = config.instances[override]
     if (!inst) throw new Error(`Instance "${override}" not found in config. Available: ${Object.keys(config.instances).join(', ')}`)

package/src/utils/output.ts

@@ -7,6 +7,7 @@ export function printTable(rows: Record<string, unknown>[], columns?: string[])
   const table = new Table({
     head: keys.map(k => chalk.bold(k)),
     style: { head: [], border: [] },
+    chars: { top: '-', 'top-mid': '+', 'top-left': '+', 'top-right': '+', bottom: '-', 'bottom-mid': '+', 'bottom-left': '+', 'bottom-right': '+', left: '|', 'left-mid': '+', mid: '-', 'mid-mid': '+', right: '|', 'right-mid': '+', middle: '|' },
   })
   for (const row of rows) {
     table.push(keys.map(k => String(row[k] ?? '')))

package/src/utils/resolve.ts

@@ -1,7 +1,28 @@
 import chalk from 'chalk'
 import { readFileSync } from 'fs'
+import { parse } from 'yaml'
 import { BodClient } from '../client'
 
+interface BodifyYaml {
+  name?: string
+  instance?: string
+  deploy?: 'upload' | 'git'
+  exclude?: string[]
+  [key: string]: unknown
+}
+
+let _parsedYaml: BodifyYaml | null | undefined
+
+function readYaml(): BodifyYaml | null {
+  if (_parsedYaml !== undefined) return _parsedYaml
+  try {
+    _parsedYaml = parse(readFileSync('bodify.yaml', 'utf-8')) as BodifyYaml
+  } catch {
+    _parsedYaml = null
+  }
+  return _parsedYaml
+}
+
 export async function resolveAppId(client: BodClient, nameOrId: string): Promise<string> {
   const apps = await client.get<any[]>('/apps')
   const match = apps.find(a => a.name === nameOrId || a.id === nameOrId)
@@ -13,25 +34,66 @@ export async function resolveAppId(client: BodClient, nameOrId: string): Promise
 }
 
 export function readAppNameFromYaml(): string | undefined {
-  try {
-    const yaml = readFileSync('bodify.yaml', 'utf-8')
-    return yaml.match(/name:\s*(.+)/)?.[1]?.trim()
-  } catch { return undefined }
+  return readYaml()?.name
 }
 
 export function readInstanceFromYaml(): string | undefined {
-  try {
-    const yaml = readFileSync('bodify.yaml', 'utf-8')
-    return yaml.match(/instance:\s*(.+)/)?.[1]?.trim()
-  } catch { return undefined }
+  return readYaml()?.instance
 }
 
 export function readDeployModeFromYaml(): 'upload' | 'git' | undefined {
+  const mode = readYaml()?.deploy
+  return mode === 'upload' ? 'upload' : mode === 'git' ? 'git' : undefined
+}
+
+export function readExcludesFromYaml(): string[] {
+  return readYaml()?.exclude ?? []
+}
+
+/** Scan all package.json files for file:.. dependencies and return unique relative paths */
+export function detectSiblingDeps(): string[] {
+  const { existsSync, readFileSync, readdirSync } = require('fs')
+  const paths = new Set<string>()
+
+  const scan = (pkgPath: string) => {
+    if (!existsSync(pkgPath)) return
+    try {
+      const pkg = JSON.parse(readFileSync(pkgPath, 'utf8'))
+      for (const field of ['dependencies', 'devDependencies']) {
+        if (!pkg[field]) continue
+        for (const ver of Object.values(pkg[field]) as string[]) {
+          if (ver.startsWith('file:') && ver.includes('..')) {
+            // Normalize: resolve relative to project root
+            const rel = ver.slice(5) // strip 'file:'
+            // From package.json dir, resolve the relative path, then make it relative to cwd
+            const { resolve, relative } = require('path')
+            const { dirname } = require('path')
+            const abs = resolve(dirname(pkgPath), rel)
+            const fromCwd = relative(process.cwd(), abs)
+            if (fromCwd.startsWith('..') && existsSync(abs)) paths.add(fromCwd)
+          }
+        }
+      }
+    } catch {}
+  }
+
+  // Root package.json
+  scan('package.json')
+
+  // Workspace packages
   try {
-    const yaml = readFileSync('bodify.yaml', 'utf-8')
-    const mode = yaml.match(/deploy:\s*(.+)/)?.[1]?.trim()
-    return mode === 'upload' ? 'upload' : mode === 'git' ? 'git' : undefined
-  } catch { return undefined }
+    const root = JSON.parse(readFileSync('package.json', 'utf8'))
+    for (const pattern of root.workspaces ?? []) {
+      const base = pattern.replace(/\/?\*$/, '')
+      if (existsSync(base)) {
+        for (const dir of readdirSync(base)) {
+          scan(`${base}/${dir}/package.json`)
+        }
+      }
+    }
+  } catch {}
+
+  return [...paths]
 }
 
 /** Resolve app name from explicit arg or bodify.yaml fallback. Logs clearly when falling back. */