@dboio/cli 0.11.4 → 0.15.0

package/src/commands/add.js

@@ -1,20 +1,59 @@
 import { Command } from 'commander';
-import { readFile, readdir, stat, writeFile, mkdir, rename } from 'fs/promises';
+import { readFile, readdir, stat, writeFile, mkdir, unlink } from 'fs/promises';
 import { join, dirname, basename, extname, relative } from 'path';
 import { DboClient } from '../lib/client.js';
 import { buildInputBody, checkSubmitErrors } from '../lib/input-parser.js';
 import { formatResponse, formatError } from '../lib/formatter.js';
 import { log } from '../lib/logger.js';
 import { shouldSkipColumn } from '../lib/columns.js';
-import { loadAppConfig, loadAppJsonBaseline, loadExtensionDocumentationMDPlacement, loadDescriptorFilenamePreference, loadConfig } from '../lib/config.js';
+import { loadAppConfig, loadAppJsonBaseline, saveAppJsonBaseline, loadExtensionDocumentationMDPlacement, loadDescriptorFilenamePreference, loadConfig } from '../lib/config.js';
 import { resolveDirective, resolveTemplateCols, assembleMetadata, promptReferenceColumn, setTemplateCols, saveMetadataTemplates, loadMetadataTemplates } from '../lib/metadata-templates.js';
-import { buildUidFilename, hasUidInFilename } from '../lib/filenames.js';
+import { hasUidInFilename, buildMetaFilename, isMetadataFile } from '../lib/filenames.js';
 import { setFileTimestamps } from '../lib/timestamps.js';
 import { checkStoredTicket, clearGlobalTicket } from '../lib/ticketing.js';
 import { checkModifyKey, isModifyKeyError, handleModifyKeyError } from '../lib/modify-key.js';
 import { loadIgnore } from '../lib/ignore.js';
-import { loadStructureFile, findBinByPath } from '../lib/structure.js';
+import { loadStructureFile, findBinByPath, BINS_DIR } from '../lib/structure.js';
 import { runPendingMigrations } from '../lib/migrations.js';
+import { upsertDeployEntry } from '../lib/deploy-config.js';
+
+// ─── File type classification for auto-detection in bin directories ────────
+
+/** Extensions treated as content entities (text-based, stored in content.Content) */
+const CONTENT_EXTENSIONS = new Set([
+  'sh', 'js', 'json', 'html', 'txt', 'xml', 'css', 'md',
+  'htm', 'svg', 'sql', 'csv', 'yaml', 'yml', 'ts', 'jsx', 'tsx',
+]);
+
+/** Extensions treated as media entities (binary files: images, audio, video) */
+const MEDIA_EXTENSIONS = new Set([
+  // Images
+  'png', 'jpg', 'jpeg', 'gif', 'webp', 'ico', 'bmp', 'tiff', 'tif', 'avif',
+  // Audio
+  'mp3', 'wav', 'ogg', 'aac', 'flac', 'm4a', 'wma',
+  // Video
+  'mp4', 'webm', 'mov', 'avi', 'mkv', 'wmv', 'flv',
+  // Fonts
+  'woff', 'woff2', 'ttf', 'otf', 'eot',
+  // Documents / archives (binary)
+  'pdf', 'zip', 'gz', 'tar',
+]);
+
+/** Simple MIME type lookup for common media extensions */
+const MIME_TYPES = {
+  png: 'image/png', jpg: 'image/jpeg', jpeg: 'image/jpeg', gif: 'image/gif',
+  webp: 'image/webp', ico: 'image/x-icon', bmp: 'image/bmp', svg: 'image/svg+xml',
+  tiff: 'image/tiff', tif: 'image/tiff', avif: 'image/avif',
+  mp3: 'audio/mpeg', wav: 'audio/wav', ogg: 'audio/ogg', aac: 'audio/aac',
+  flac: 'audio/flac', m4a: 'audio/mp4', wma: 'audio/x-ms-wma',
+  mp4: 'video/mp4', webm: 'video/webm', mov: 'video/quicktime',
+  avi: 'video/x-msvideo', mkv: 'video/x-matroska', wmv: 'video/x-ms-wmv',
+  flv: 'video/x-flv',
+  woff: 'font/woff', woff2: 'font/woff2', ttf: 'font/ttf', otf: 'font/otf',
+  eot: 'application/vnd.ms-fontobject',
+  pdf: 'application/pdf', zip: 'application/zip', gz: 'application/gzip',
+  tar: 'application/x-tar',
+};
 
 export const addCommand = new Command('add')
   .description('Add a new file to DBO.io (creates record on server)')
@@ -118,6 +157,165 @@ async function detectManifestFile(filePath) {
   return { meta, metaPath };
 }
 
+/**
+ * Detect whether a file lives inside lib/bins/ and auto-classify as content or media.
+ *
+ * Content extensions: sh, js, json, html, txt, xml, css, md, etc.
+ * Media extensions: png, jpg, webp, mp4, woff2, pdf, etc.
+ *
+ * Returns { meta, metaPath } or null if not applicable.
+ */
+export async function detectBinFile(filePath) {
+  const rel = relative(process.cwd(), filePath).replace(/\\/g, '/');
+
+  // Must be inside lib/bins/ (or legacy Bins/)
+  if (!rel.startsWith(BINS_DIR + '/') && !rel.toLowerCase().startsWith('bins/')) return null;
+
+  const ext = extname(filePath).replace('.', '').toLowerCase();
+  if (!ext) return null;
+
+  const isContent = CONTENT_EXTENSIONS.has(ext);
+  const isMedia = MEDIA_EXTENSIONS.has(ext);
+  if (!isContent && !isMedia) return null;
+
+  const appConfig = await loadAppConfig();
+  const structure = await loadStructureFile();
+
+  // Resolve BinID from the file's parent directory
+  const fileDir = dirname(rel);
+  const bin = findBinByPath(fileDir, structure);
+
+  const fileName = basename(filePath);
+  const base = basename(filePath, extname(filePath));
+
+  // Build metadata path next to the file
+  const metaPath = join(dirname(filePath), `${base}.metadata.json`);
+
+  // Use the bin's server-side Path field (e.g. "assets/css", "assets/gfx")
+  const binPath = bin?.path || '';
+
+  if (isContent) {
+    // content.Name = filename without extension, content.Path = <binPath>/<Name>.<Extension>
+    const contentPath = binPath
+      ? `${binPath}/${base}.${ext.toLowerCase()}`
+      : `${base}.${ext.toLowerCase()}`;
+
+    const meta = {
+      _entity: 'content',
+      _contentColumns: ['Content'],
+      Name: base,
+      Content: `@${fileName}`,
+      Extension: ext.toUpperCase(),
+      Path: contentPath,
+      Active: 1,
+      Public: 0,
+    };
+    if (bin) meta.BinID = bin.binId;
+    if (appConfig.AppID) meta.AppID = appConfig.AppID;
+
+    await writeFile(metaPath, JSON.stringify(meta, null, 2) + '\n');
+    log.success(`Auto-created content metadata for "${fileName}"`);
+
+    // Seed metadata_templates.json with content fields if missing
+    await seedMetadataTemplate();
+
+    return { meta, metaPath };
+  }
+
+  // Media: media.Name = filename without extension, media.Filename = filename with extension
+  // media.Path = bin directory path, media.FullPath = /media/<AppShortName>/app/<binPath>/<Filename>
+  const meta = {
+    _entity: 'media',
+    _mediaFile: `@${fileName}`,
+    Name: base,
+    Filename: fileName,
+    Extension: ext,
+    Ownership: 'App',
+  };
+  if (bin) meta.BinID = bin.binId;
+  if (appConfig.AppID) meta.AppID = appConfig.AppID;
+  if (binPath) meta.Path = binPath;
+
+  const mimeType = MIME_TYPES[ext];
+  if (mimeType) meta.MimeType = mimeType;
+
+  // Build FullPath: /media/<AppShortName>/app/<binPath>/<Filename>
+  if (appConfig.AppShortName) {
+    const fullPathParts = ['', 'media', appConfig.AppShortName, 'app'];
+    if (binPath) fullPathParts.push(binPath);
+    fullPathParts.push(fileName);
+    meta.FullPath = fullPathParts.join('/');
+  }
+
+  await writeFile(metaPath, JSON.stringify(meta, null, 2) + '\n');
+  log.success(`Auto-created media metadata for "${fileName}"`);
+
+  // Seed metadata_templates.json with media fields if missing
+  await seedMetadataTemplate();
+
+  return { meta, metaPath };
+}
+
+/** Default template cols for core entity types */
+const TEMPLATE_DEFAULTS = {
+  content: [
+    'AppID', 'BinID', 'Name', 'Path', 'Content=@reference', 'Extension',
+    'Type', 'Title', 'Active', 'Public=0', 'SiteID', 'Description',
+    'Keywords', 'Parameters', 'CacheControl', 'RequireSSL', 'EntityID',
+  ],
+  media: [
+    'AppID', 'BinID', 'Name', 'Path', 'Filename', 'Extension',
+    'MimeType', 'FileSize', 'Ownership', 'Public', 'Description',
+    'Duration', 'ParentMediaID',
+  ],
+  output: [
+    'AppID', 'BinID', 'Name', 'Type', 'CustomSQL=@reference',
+    'Active', 'Public', 'Title', 'Description', 'Parameters',
+    'Cache', 'Limit', 'MaxRows', 'RowsPerPage', 'ApplyLocks',
+    'AdhocFilters', 'BaseEntityID', 'DataSourceID',
+    'DefaultMediaID', 'TemplateContentID', 'children',
+  ],
+  output_value: [
+    'OutputID', 'Title', 'ShortName', 'OutputType', 'OrderNumber',
+    'CustomSQL', 'Format', 'Aggregate', 'DatePart', 'Distinct',
+    'Hide', 'Shared', 'Summary', 'SortType', 'SortOrder',
+    'EnforceSecurity', 'ReferencedEntityColumnID',
+    'OutputValueEntityColumnRelID', 'children',
+  ],
+  output_value_filter: [
+    'OutputID', 'OutputValueID', 'ShortName', 'FilterType', 'Operator',
+    'OrderNumber', 'CustomSQL', 'Prompted', 'Required', 'Inclusive',
+    'PrimaryValue', 'SecondaryValue', 'FilterPreset',
+    'ApplyToAggregate', 'ValuesByOutputID', 'children',
+  ],
+  output_value_entity_column_rel: [
+    'OutputID', 'OutputValueID', 'JoinType', 'OrderNumber', 'CustomSQL',
+    'Alias', 'SourceJoinID', 'SourceEntityColumnID',
+    'ReferencedEntityColumnID', 'children',
+  ],
+};
+
+/**
+ * Seed .dbo/metadata_templates.json with default fields for the given entity
+ * (and any other missing core entities) if an entry doesn't already exist.
+ */
+async function seedMetadataTemplate() {
+  const templates = await loadMetadataTemplates() ?? {};
+
+  // Seed all missing core entities in one pass
+  const seeded = [];
+  for (const [name, cols] of Object.entries(TEMPLATE_DEFAULTS)) {
+    if (templates[name]) continue;
+    templates[name] = cols;
+    seeded.push(name);
+  }
+
+  if (seeded.length === 0) return;
+
+  await saveMetadataTemplates(templates);
+  log.dim(`  Seeded metadata_templates.json with ${seeded.join(', ')} fields`);
+}
+
 async function addSingleFile(filePath, client, options, batchDefaults) {
   // Check .dboignore before doing any processing
   const ig = await loadIgnore();
@@ -235,6 +433,12 @@ async function addSingleFile(filePath, client, options, batchDefaults) {
     return await submitAdd(manifestMeta.meta, manifestMeta.metaPath, filePath, client, options);
   }
 
+  // Step 3e: Auto-detect content/media files in bin directories (lib/bins/)
+  const binMeta = await detectBinFile(filePath);
+  if (binMeta) {
+    return await submitAdd(binMeta.meta, binMeta.metaPath, filePath, client, options);
+  }
+
   // Step 4: No usable metadata — interactive wizard
   const inquirer = (await import('inquirer')).default;
 
@@ -363,7 +567,7 @@ async function addSingleFile(filePath, client, options, batchDefaults) {
 /**
  * Submit an insert to the server from a metadata object.
  */
-async function submitAdd(meta, metaPath, filePath, client, options) {
+export async function submitAdd(meta, metaPath, filePath, client, options) {
   const entity = meta._entity;
   const contentCols = new Set(meta._contentColumns || []);
   const metaDir = dirname(metaPath);
@@ -442,11 +646,22 @@ async function submitAdd(meta, metaPath, filePath, client, options) {
     throw new Error('Add failed');
   }
 
-  // Extract UID from response and rename files to ~uid convention
+  // Extract UID and server-populated fields from response, merge into metadata
   const addResults = result.payload?.Results?.Add || result.data?.Payload?.Results?.Add || [];
   if (addResults.length > 0) {
-    const returnedUID = addResults[0].UID;
-    const returnedLastUpdated = addResults[0]._LastUpdated;
+    const serverRecord = addResults[0];
+    const returnedUID = serverRecord.UID;
+    const returnedLastUpdated = serverRecord._LastUpdated;
+
+    // Merge server-populated fields into meta (e.g. _id, ContentID, _LastUpdated, _CreatedOn)
+    for (const [key, value] of Object.entries(serverRecord)) {
+      // Skip internal/transient fields and arrays (Physical, Errors)
+      if (Array.isArray(value)) continue;
+      if (key === 'entity' || key === 'RowID') continue;
+      // Don't overwrite existing content/media references or private fields we manage
+      if (meta[key] !== undefined && !key.startsWith('_')) continue;
+      meta[key] = value;
+    }
 
     if (returnedUID) {
       // Check if UID is already embedded in the filename (idempotency guard)
@@ -456,54 +671,43 @@ async function submitAdd(meta, metaPath, filePath, client, options) {
         await writeFile(metaPath, JSON.stringify(meta, null, 2) + '\n');
         log.success(`UID already in filename: ${returnedUID}`);
       } else {
-        // Compute new names
+        // Companion file NOT renamed — only update UID in metadata and rename metadata file
         const metaDir = dirname(metaPath);
-        const currentExt = extname(filePath).substring(1);
-        const currentBase = basename(filePath, extname(filePath));
-        const newBase = buildUidFilename(currentBase, returnedUID);
-        const newFilename = currentExt ? `${newBase}.${currentExt}` : newBase;
-        const newFilePath = join(metaDir, newFilename);
-        const newMetaPath = join(metaDir, `${newBase}.metadata.json`);
-
-        // Rename content file
-        try {
-          await rename(filePath, newFilePath);
-          log.success(`Renamed: ${basename(filePath)} → ${newFilename}`);
-        } catch (err) {
-          log.warn(`  Could not rename content file: ${err.message}`);
-        }
+        const metaBase = basename(metaPath, '.metadata.json');
+        const newMetaPath = join(metaDir, buildMetaFilename(metaBase, returnedUID));
 
-        // Update @reference in metadata
         meta.UID = returnedUID;
-        for (const col of (meta._contentColumns || [])) {
-          const ref = meta[col];
-          if (ref && String(ref).startsWith('@')) {
-            const oldRefFile = String(ref).substring(1);
-            if (oldRefFile === basename(filePath)) {
-              meta[col] = `@${newFilename}`;
-            }
-          }
-        }
 
-        // Write and rename metadata file
         await writeFile(newMetaPath, JSON.stringify(meta, null, 2) + '\n');
         if (metaPath !== newMetaPath) {
-          try { await rename(metaPath, newMetaPath); } catch { /* already written */ }
+          try { await unlink(metaPath); } catch { /* old file already gone */ }
         }
         log.dim(`  Renamed metadata: ${basename(metaPath)} → ${basename(newMetaPath)}`);
+        log.success(`UID assigned: ${returnedUID}`);
 
-        // Restore timestamps from server _LastUpdated
+        // Restore timestamps for metadata and companion files
         const config = await loadConfig();
         const serverTz = config.ServerTimezone;
         if (serverTz && returnedLastUpdated) {
           try {
-            await setFileTimestamps(newFilePath, returnedLastUpdated, returnedLastUpdated, serverTz);
             await setFileTimestamps(newMetaPath, returnedLastUpdated, returnedLastUpdated, serverTz);
+            for (const col of (meta._contentColumns || [])) {
+              const ref = meta[col];
+              if (ref && String(ref).startsWith('@')) {
+                const fp = join(metaDir, String(ref).substring(1));
+                await upsertDeployEntry(fp, returnedUID, entity, col);
+                try { await setFileTimestamps(fp, returnedLastUpdated, returnedLastUpdated, serverTz); } catch {}
+              }
+            }
+            if (meta._mediaFile && String(meta._mediaFile).startsWith('@')) {
+              const mediaFp = join(metaDir, String(meta._mediaFile).substring(1));
+              await upsertDeployEntry(mediaFp, returnedUID, entity, 'File');
+            }
           } catch { /* non-critical */ }
         }
 
-        log.success(`UID assigned: ${returnedUID}`);
-        log.dim(`  Files renamed to ~${returnedUID} convention`);
+        // Update .app_baseline.json so subsequent pull/diff recognize this record
+        await updateBaselineWithNewRecord(meta, returnedUID, returnedLastUpdated);
       }
       log.dim(`  Run "dbo pull -e ${entity} ${returnedUID}" to populate all columns`);
     }
@@ -512,6 +716,30 @@ async function submitAdd(meta, metaPath, filePath, client, options) {
   return { entity: meta._entity };
 }
 
+async function updateBaselineWithNewRecord(meta, uid, lastUpdated) {
+  try {
+    const baseline = await loadAppJsonBaseline();
+    if (!baseline) return;
+    const entity = meta._entity;
+    if (!entity) return;
+    if (!baseline.children) baseline.children = {};
+    if (!baseline.children[entity]) baseline.children[entity] = [];
+
+    const arr = baseline.children[entity];
+    const existingIdx = arr.findIndex(r => r.UID === uid || (meta._id && r._id === meta._id));
+    const entry = { ...meta, UID: uid };
+    if (lastUpdated) entry._LastUpdated = lastUpdated;
+
+    if (existingIdx >= 0) {
+      arr[existingIdx] = { ...arr[existingIdx], ...entry };
+    } else {
+      arr.push(entry);
+    }
+
+    await saveAppJsonBaseline(baseline);
+  } catch { /* baseline update is non-critical */ }
+}
+
 /**
  * Scan a directory for un-added files and add them.
  */
@@ -579,54 +807,135 @@ async function addDirectory(dirPath, client, options) {
 
 /**
  * Recursively find files that are not yet added to the server.
- * A file is "un-added" if:
- *   - It has no companion .metadata.json, OR
- *   - Its .metadata.json exists but has no _CreatedOn (never been on server)
+ * A file is "un-added" if no *.metadata.json references it via @.
+ *
+ * Detection uses two layers:
+ *   1. Per-directory: scan sibling *.metadata.json files (handles ~UID naming)
+ *   2. Project-wide: buildReferencedFileSet catches cross-directory @/ references
  */
-async function findUnaddedFiles(dir, ig) {
+export async function findUnaddedFiles(dir, ig, referencedFiles) {
   if (!ig) ig = await loadIgnore();
 
+  // On first call, build the set of files referenced by existing metadata
+  if (!referencedFiles) {
+    referencedFiles = await buildReferencedFileSet();
+  }
+
   const results = [];
   const entries = await readdir(dir, { withFileTypes: true });
 
+  // Build a set of filenames referenced by sibling metadata in this directory.
+  // This handles the ~UID naming convention: colors.metadata~uid.json → @colors.css
+  const localRefs = new Set();
+  for (const entry of entries) {
+    if (!isMetadataFile(entry.name)) continue;
+    try {
+      const raw = await readFile(join(dir, entry.name), 'utf8');
+      if (!raw.trim()) continue;
+      const meta = JSON.parse(raw);
+      // Only count records that are on the server (have UID or _CreatedOn)
+      if (!meta.UID && !meta._CreatedOn) continue;
+      for (const col of (meta._contentColumns || [])) {
+        const val = meta[col];
+        if (typeof val === 'string' && val.startsWith('@') && !val.startsWith('@/')) {
+          localRefs.add(val.substring(1));
+        }
+      }
+      if (meta._mediaFile && typeof meta._mediaFile === 'string' && meta._mediaFile.startsWith('@')) {
+        localRefs.add(meta._mediaFile.substring(1));
+      }
+    } catch { /* skip unreadable */ }
+  }
+
   for (const entry of entries) {
     const fullPath = join(dir, entry.name);
     const relPath = relative(process.cwd(), fullPath).replace(/\\/g, '/');
 
     if (entry.isDirectory()) {
       if (ig.ignores(relPath + '/') || ig.ignores(relPath)) continue;
-      results.push(...await findUnaddedFiles(fullPath, ig));
+      results.push(...await findUnaddedFiles(fullPath, ig, referencedFiles));
       continue;
     }
 
-    // Skip metadata files themselves (structural, not user-configurable)
-    if (entry.name.endsWith('.metadata.json')) continue;
+    // Skip metadata files themselves
+    if (isMetadataFile(entry.name)) continue;
     // Skip ignored files
     if (ig.ignores(relPath)) continue;
 
-    // Check for companion metadata
-    const ext = extname(entry.name);
-    const base = basename(entry.name, ext);
-    const metaPath = join(dir, `${base}.metadata.json`);
+    // Check 1: sibling metadata references this file via @
+    if (localRefs.has(entry.name)) continue;
+
+    // Check 2: project-wide cross-directory @/ references
+    if (referencedFiles.has(relPath)) continue;
 
-    let hasMetadata = false;
-    let isOnServer = false;
+    results.push(fullPath);
+  }
+
+  return results;
+}
+
+/**
+ * Scan all metadata files and build a set of content files they reference.
+ * This catches files like docs/Chat.md whose metadata lives elsewhere
+ * (e.g. lib/extension/Documentation/Chat~uid.metadata.json with "@/docs/Chat.md").
+ */
+async function buildReferencedFileSet() {
+  const referenced = new Set();
+  await _scanMetadataRefs(process.cwd(), referenced);
+  return referenced;
+}
+
+async function _scanMetadataRefs(dir, referenced) {
+  const ig = await loadIgnore();
+  let entries;
+  try {
+    entries = await readdir(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+
+  for (const entry of entries) {
+    const fullPath = join(dir, entry.name);
+    const relPath = relative(process.cwd(), fullPath).replace(/\\/g, '/');
+
+    if (entry.isDirectory()) {
+      if (ig.ignores(relPath + '/') || ig.ignores(relPath)) continue;
+      await _scanMetadataRefs(fullPath, referenced);
+      continue;
+    }
+
+    if (!isMetadataFile(entry.name)) continue;
 
     try {
-      const raw = await readFile(metaPath, 'utf8');
-      if (raw.trim()) {
-        const meta = JSON.parse(raw);
-        hasMetadata = true;
-        isOnServer = !!meta._CreatedOn;
+      const raw = await readFile(fullPath, 'utf8');
+      if (!raw.trim()) continue;
+      const meta = JSON.parse(raw);
+      if (!meta._CreatedOn && !meta.UID) continue; // only count server-confirmed records
+
+      for (const col of (meta._contentColumns || [])) {
+        const val = meta[col];
+        if (typeof val === 'string' && val.startsWith('@')) {
+          const ref = val.substring(1);
+          if (ref.startsWith('/')) {
+            // @/path — absolute from project root
+            referenced.add(ref.substring(1));
+          } else {
+            // @filename — relative to metadata file's directory
+            const metaDir = relative(process.cwd(), dir).replace(/\\/g, '/');
+            const resolved = metaDir ? `${metaDir}/${ref}` : ref;
+            referenced.add(resolved);
+          }
+        }
       }
-    } catch {
-      // No metadata file
-    }
 
-    if (!isOnServer) {
-      results.push(fullPath);
+      // Content records with a Path field may have their file at the project root
+      // (e.g. manifest.json is cloned to root but metadata lives in lib/bins/app/)
+      if (meta._entity === 'content' && meta.Path) {
+        const p = String(meta.Path).replace(/^\//, '');
+        referenced.add(p);
+      }
+    } catch {
+      // skip unreadable metadata
     }
   }
-
-  return results;
 }

package/src/commands/build.js

@@ -0,0 +1,102 @@
+// src/commands/build.js
+import { Command } from 'commander';
+import { relative, basename } from 'path';
+import { loadScripts, loadScriptsLocal, loadConfig, loadAppConfig } from '../lib/config.js';
+import { mergeScriptsConfig, resolveHooks, buildHookEnv, runBuildLifecycle } from '../lib/scripts.js';
+import { log } from '../lib/logger.js';
+
+export const buildCommand = new Command('build')
+  .description('Run the build lifecycle (prebuild → build → postbuild) without pushing')
+  .argument('[path]', 'File or directory to build (default: all targets with a build hook)')
+  .option('--entity <type>', 'Run builds for all targets matching this entity type')
+  .action(async (targetPath, options) => {
+    try {
+      const base = await loadScripts();
+      const local = await loadScriptsLocal();
+
+      if (!base && !local) {
+        if (targetPath) {
+          log.warn('No .dbo/scripts.json found — nothing to build');
+        } else {
+          log.info('No .dbo/scripts.json found');
+        }
+        return;
+      }
+
+      const config = mergeScriptsConfig(base, local);
+      const cfg = await loadConfig();
+      const app = await loadAppConfig();
+      const appConfig = { ...app, domain: cfg.domain };
+
+      let targets = [];
+
+      if (targetPath) {
+        // Single explicit path
+        targets = [targetPath];
+      } else if (options.entity) {
+        // All targets in scripts.json that match the entity type
+        targets = Object.keys(config.targets).filter(t => {
+          const hooks = config.targets[t];
+          return hooks && hooks.build !== undefined;
+        });
+        if (targets.length === 0) {
+          log.info(`No targets with a build hook found for entity type "${options.entity}"`);
+          return;
+        }
+      } else {
+        // All targets in scripts.json that have a build hook
+        targets = Object.keys(config.targets).filter(t => {
+          const hooks = config.targets[t];
+          return hooks && hooks.build !== undefined;
+        });
+        // Also check global scripts for a build hook (runs once, not per-target)
+        if (config.scripts && config.scripts.build !== undefined) {
+          // Run global build once
+          const env = buildHookEnv('', '', appConfig);
+          const hooks = { prebuild: config.scripts.prebuild, build: config.scripts.build, postbuild: config.scripts.postbuild };
+          log.info('Running global build hooks...');
+          const ok = await runBuildLifecycle(hooks, env, process.cwd());
+          if (!ok) {
+            log.error('Global build hook failed');
+            process.exit(1);
+          }
+          if (targets.length === 0) return; // only global, done
+        }
+        if (targets.length === 0) {
+          log.info('No build hooks defined in .dbo/scripts.json targets');
+          return;
+        }
+      }
+
+      let failed = 0;
+      for (const t of targets) {
+        const relPath = t.replace(/\\/g, '/');
+        // Determine entity type from option or empty string
+        let entityType = '';
+        if (options.entity) entityType = options.entity;
+
+        const hooks = resolveHooks(relPath, entityType, config);
+        if (hooks.build === undefined && hooks.prebuild === undefined && hooks.postbuild === undefined) {
+          log.dim(`  No build hooks for ${relPath} — skipping`);
+          continue;
+        }
+
+        log.info(`Building: ${relPath}`);
+        const env = buildHookEnv(relPath, entityType, appConfig);
+        const ok = await runBuildLifecycle(hooks, env, process.cwd());
+        if (!ok) {
+          log.error(`Build failed for "${relPath}"`);
+          failed++;
+          break; // fail-fast: first failure stops execution
+        }
+        log.success(`  Built: ${relPath}`);
+      }
+
+      if (failed > 0) {
+        process.exit(1);
+      }
+    } catch (err) {
+      log.error(err.message);
+      process.exit(1);
+    }
+  });