@dboio/cli 0.8.2 → 0.9.3

package/src/commands/push.js

@@ -1,8 +1,8 @@
 import { Command } from 'commander';
-import { readFile, stat, writeFile } from 'fs/promises';
+import { readFile, stat, writeFile, rename as fsRename, mkdir } 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 { buildInputBody, checkSubmitErrors, getSessionUserOverride } from '../lib/input-parser.js';
 import { formatResponse, formatError } from '../lib/formatter.js';
 import { log } from '../lib/logger.js';
 import { shouldSkipColumn } from '../lib/columns.js';
@@ -11,9 +11,11 @@ import { checkStoredTicket, applyStoredTicketToSubmission, clearRecordTicket, cl
 import { checkModifyKey, isModifyKeyError, handleModifyKeyError } from '../lib/modify-key.js';
 import { resolveTransactionKey } from '../lib/transaction-key.js';
 import { setFileTimestamps } from '../lib/timestamps.js';
+import { stripUidFromFilename, renameToUidConvention, hasUidInFilename } from '../lib/filenames.js';
 import { findMetadataFiles } from '../lib/diff.js';
 import { loadIgnore } from '../lib/ignore.js';
 import { detectChangedColumns, findBaselineEntry } from '../lib/delta.js';
+import { BINS_DIR } from '../lib/structure.js';
 
 /**
  * Resolve an @reference file path to an absolute filesystem path.
@@ -91,6 +93,8 @@ async function processPendingDeletes(client, options, modifyKey = null, transact
     const extraParams = { '_confirm': options.confirm || 'true' };
     if (options.ticket) extraParams['_OverrideTicketID'] = options.ticket;
     if (modifyKey) extraParams['_modify_key'] = modifyKey;
+    const cachedUser2 = getSessionUserOverride();
+    if (cachedUser2) extraParams['_OverrideUserID'] = cachedUser2;
 
     const body = await buildInputBody([entry.expression], extraParams);
 
@@ -124,7 +128,7 @@ async function processPendingDeletes(client, options, modifyKey = null, transact
           deletedUids.push(entry.UID);
         } else {
           log.error(`  Failed to delete "${entry.name}"`);
-          formatResponse(retryResponse, { json: options.json, jq: options.jq });
+          formatResponse(retryResponse, { json: options.json, jq: options.jq, verbose: options.verbose });
           remaining.push(entry);
         }
       } else if (result.successful) {
@@ -132,7 +136,7 @@ async function processPendingDeletes(client, options, modifyKey = null, transact
         deletedUids.push(entry.UID);
       } else {
         log.error(`  Failed to delete "${entry.name}"`);
-        formatResponse(result, { json: options.json, jq: options.jq });
+        formatResponse(result, { json: options.json, jq: options.jq, verbose: options.verbose });
         remaining.push(entry);
       }
     } catch (err) {
@@ -141,6 +145,12 @@ async function processPendingDeletes(client, options, modifyKey = null, transact
     }
   }
 
+  // Move __WILL_DELETE__ files to Trash/ for successfully deleted records
+  for (const entry of sync.delete) {
+    if (!deletedUids.includes(entry.UID)) continue;
+    await moveWillDeleteToTrash(entry);
+  }
+
   // Remove edit entries for successfully deleted records (spec requirement)
   if (deletedUids.length > 0) {
     sync.edit = (sync.edit || []).filter(e => !deletedUids.includes(e.UID));
@@ -155,6 +165,65 @@ async function processPendingDeletes(client, options, modifyKey = null, transact
   }
 }
 
+/**
+ * Move __WILL_DELETE__-prefixed files associated with a sync entry to Trash/.
+ */
+async function moveWillDeleteToTrash(entry) {
+  if (!entry.metaPath) return;
+
+  const trashDir = join(process.cwd(), 'trash');
+  await mkdir(trashDir, { recursive: true });
+
+  const metaDir = dirname(entry.metaPath);
+  const metaBase = basename(entry.metaPath);
+  const willDeleteMeta = join(metaDir, `__WILL_DELETE__${metaBase}`);
+
+  const filesToMove = [];
+
+  try {
+    await stat(willDeleteMeta);
+    filesToMove.push({ from: willDeleteMeta, to: join(trashDir, metaBase) });
+
+    // Read the __WILL_DELETE__ metadata to find associated content files
+    const rawMeta = await readFile(willDeleteMeta, 'utf8');
+    const deletedMeta = JSON.parse(rawMeta);
+    for (const col of (deletedMeta._contentColumns || [])) {
+      const ref = deletedMeta[col];
+      if (ref && String(ref).startsWith('@')) {
+        const refFile = String(ref).substring(1);
+        const willDeleteContent = join(metaDir, `__WILL_DELETE__${refFile}`);
+        try {
+          await stat(willDeleteContent);
+          filesToMove.push({ from: willDeleteContent, to: join(trashDir, refFile) });
+        } catch {}
+      }
+    }
+    if (deletedMeta._mediaFile && String(deletedMeta._mediaFile).startsWith('@')) {
+      const refFile = String(deletedMeta._mediaFile).substring(1);
+      const willDeleteMedia = join(metaDir, `__WILL_DELETE__${refFile}`);
+      try {
+        await stat(willDeleteMedia);
+        filesToMove.push({ from: willDeleteMedia, to: join(trashDir, refFile) });
+      } catch {}
+    }
+  } catch {
+    // No __WILL_DELETE__ metadata file — nothing to move
+    return;
+  }
+
+  for (const { from, to } of filesToMove) {
+    // Handle Trash collision: append timestamp
+    let destPath = to;
+    try { await stat(destPath); destPath = `${to}.${Date.now()}`; } catch {}
+    try {
+      await fsRename(from, destPath);
+      log.dim(`  Moved to trash: ${basename(destPath)}`);
+    } catch (err) {
+      log.warn(`  Could not move to trash: ${from} — ${err.message}`);
+    }
+  }
+}
+
 /**
  * Push a single file using its companion .metadata.json
  */
@@ -440,13 +509,18 @@ async function pushFromMetadata(meta, metaPath, client, options, changedColumns
   if (options.ticket) extraParams['_OverrideTicketID'] = options.ticket;
   else if (storedTicket) extraParams['_OverrideTicketID'] = storedTicket;
   if (modifyKey) extraParams['_modify_key'] = modifyKey;
+  const cachedUser = getSessionUserOverride();
+  if (cachedUser) extraParams['_OverrideUserID'] = cachedUser;
 
   let result;
 
   if (isMediaUpload) {
     // Media file upload: use multipart/form-data
-    const mediaFileName = String(meta._mediaFile).substring(1);
-    const mediaFilePath = resolveAtReference(mediaFileName, metaDir);
+    const mediaLocalName = String(meta._mediaFile).substring(1);
+    const mediaFilePath = resolveAtReference(mediaLocalName, metaDir);
+    const mediaUid = meta.UID || meta._id;
+    const mediaUploadName = meta.Filename
+      || stripUidFromFilename(mediaLocalName, mediaUid);
 
     // Ensure at least one data expression to identify the row for the server
     if (dataExprs.length === 0 && meta.Filename) {
@@ -461,7 +535,7 @@ async function pushFromMetadata(meta, metaPath, client, options, changedColumns
       }
     }
 
-    const files = [{ fieldName: 'file', filePath: mediaFilePath, fileName: mediaFileName }];
+    const files = [{ fieldName: 'file', filePath: mediaFilePath, fileName: mediaUploadName }];
     result = await client.postMultipart('/api/input/submit', fields, files);
   } else {
     let body = await buildInputBody(dataExprs, extraParams);
@@ -499,8 +573,11 @@ async function pushFromMetadata(meta, metaPath, client, options, changedColumns
     Object.assign(extraParams, params);
 
     if (isMediaUpload) {
-      const mediaFileName = String(meta._mediaFile).substring(1);
-      const mediaFilePath = resolveAtReference(mediaFileName, metaDir);
+      const retryLocalName = String(meta._mediaFile).substring(1);
+      const retryFilePath = resolveAtReference(retryLocalName, metaDir);
+      const retryUid = meta.UID || meta._id;
+      const retryUploadName = meta.Filename
+        || stripUidFromFilename(retryLocalName, retryUid);
       const fields = { ...extraParams };
       for (const expr of dataExprs) {
         const eqIdx = expr.indexOf('=');
@@ -508,7 +585,7 @@ async function pushFromMetadata(meta, metaPath, client, options, changedColumns
           fields[expr.substring(0, eqIdx)] = expr.substring(eqIdx + 1);
         }
       }
-      const files = [{ fieldName: 'file', filePath: mediaFilePath, fileName: mediaFileName }];
+      const files = [{ fieldName: 'file', filePath: retryFilePath, fileName: retryUploadName }];
       result = await client.postMultipart('/api/input/submit', fields, files);
     } else {
       const body = await buildInputBody(dataExprs, extraParams);
@@ -516,7 +593,7 @@ async function pushFromMetadata(meta, metaPath, client, options, changedColumns
     }
   }
 
-  formatResponse(result, { json: options.json, jq: options.jq });
+  formatResponse(result, { json: options.json, jq: options.jq, verbose: options.verbose });
 
   // Update metadata on disk if path was changed
   if (metaUpdated) {
@@ -531,6 +608,25 @@ async function pushFromMetadata(meta, metaPath, client, options, changedColumns
   // Clean up per-record ticket on success
   await clearRecordTicket(uid || id);
 
+  // Post-UID rename: if the record lacked a UID and the server returned one
+  try {
+    const editResults2 = result.payload?.Results?.Edit || result.data?.Payload?.Results?.Edit || [];
+    const addResults2 = result.payload?.Results?.Add || result.data?.Payload?.Results?.Add || [];
+    const allResults = [...editResults2, ...addResults2];
+    if (allResults.length > 0 && !meta.UID) {
+      const serverUID = allResults[0].UID;
+      if (serverUID && !hasUidInFilename(basename(metaPath), serverUID)) {
+        const config2 = await loadConfig();
+        const renameResult = await renameToUidConvention(meta, metaPath, serverUID, allResults[0]._LastUpdated, config2.ServerTimezone);
+        if (renameResult.newMetaPath !== metaPath) {
+          log.success(`  Renamed to ~${serverUID} convention`);
+          // Update metaPath reference for subsequent timestamp operations
+          // (metaPath is const, but timestamp update below re-reads from meta)
+        }
+      }
+    }
+  } catch { /* non-critical rename */ }
+
   // Update file timestamps from server response
   try {
     const editResults = result.payload?.Results?.Edit || result.data?.Payload?.Results?.Edit || [];
@@ -569,29 +665,29 @@ async function pushFromMetadata(meta, metaPath, client, options, changedColumns
 /**
  * Normalize a local file path for comparison with server-side Path.
  *
- * The Bins/ directory is used for local file organization and does not reflect
+ * The bins/ directory is used for local file organization and does not reflect
  * the actual server-side serving path. This function strips organizational prefixes
  * to enable correct path comparison during push operations.
  *
  * **Directory Structure:**
- * - `Bins/` — Local organizational root (always stripped)
- * - `Bins/app/` — Special case: the "app" subdirectory is also stripped because it's
- *   purely organizational. Files in Bins/app/ are served from the app root without
+ * - `bins/` — Local organizational root (always stripped)
+ * - `bins/app/` — Special case: the "app" subdirectory is also stripped because it's
+ *   purely organizational. Files in bins/app/ are served from the app root without
  *   the "app/" prefix on the server.
- * - `Bins/custom_name/` — Custom bin directories (tpl/, ticket_test/, etc.) are
+ * - `bins/custom_name/` — Custom bin directories (tpl/, ticket_test/, etc.) are
  *   preserved because they represent actual bin hierarchies that serve from their
  *   directory name.
  *
  * **Why "app/" is special:**
- * The main app bin is placed in Bins/app/ locally for organization, but server-side
+ * The main app bin is placed in bins/app/ locally for organization, but server-side
  * these files are served from the root path (no "app/" prefix). Other custom bins
  * like "tpl/" maintain their directory name in the serving path.
  *
  * Examples:
- *   "Bins/app/assets/css/file.css" → "assets/css/file.css" (strips Bins/app/)
- *   "Bins/tpl/header.html" → "tpl/header.html" (preserves tpl/)
- *   "Bins/assets/css/file.css" → "assets/css/file.css" (strips Bins/ only)
- *   "Sites/MySite/content/page.html" → "Sites/MySite/content/page.html" (unchanged)
+ *   "bins/app/assets/css/file.css" → "assets/css/file.css" (strips bins/app/)
+ *   "bins/tpl/header.html" → "tpl/header.html" (preserves tpl/)
+ *   "bins/assets/css/file.css" → "assets/css/file.css" (strips bins/ only)
+ *   "site/MySite/content/page.html" → "site/MySite/content/page.html" (unchanged)
  *
  * @param {string} localPath - Relative path from project root
  * @returns {string} - Normalized path for comparison with metadata Path column
@@ -603,10 +699,10 @@ function normalizePathForComparison(localPath) {
   // Strip leading and trailing slashes
   const cleaned = normalized.replace(/^\/+|\/+$/g, '');
 
-  // Check if path starts with "Bins/" organizational directory
-  if (cleaned.startsWith('Bins/')) {
-    // Remove "Bins/" prefix (length = 5)
-    const withoutBins = cleaned.substring(5);
+  // Check if path starts with bins/ organizational directory
+  const binsPrefix = BINS_DIR + '/';
+  if (cleaned.startsWith(binsPrefix)) {
+    const withoutBins = cleaned.substring(binsPrefix.length);
 
     // Special case: strip "app/" organizational subdirectory
     // This is the only special subdirectory - all others (tpl/, assets/, etc.) are preserved
@@ -642,8 +738,12 @@ async function checkPathMismatch(meta, metaPath, options) {
 
   if (!contentFileName) return;
 
-  // Compute the current path based on where the file actually is
-  const currentFilePath = join(metaDir, contentFileName);
+  // Compute the current path based on where the file actually is.
+  // Strip the ~UID from the filename — the metadata Path is the canonical
+  // server path and never contains the local ~UID suffix.
+  const uid = meta.UID;
+  const serverFileName = uid ? stripUidFromFilename(contentFileName, uid) : contentFileName;
+  const currentFilePath = join(metaDir, serverFileName);
   const currentRelPath = relative(process.cwd(), currentFilePath);
 
   // Normalize both paths for comparison

package/src/commands/rm.js

@@ -1,5 +1,5 @@
 import { Command } from 'commander';
-import { readFile, unlink, stat, rm as fsRm } from 'fs/promises';
+import { readFile, unlink, stat, rm as fsRm, rename } from 'fs/promises';
 import { join, dirname, basename, extname } from 'path';
 import { log } from '../lib/logger.js';
 import { formatError } from '../lib/formatter.js';
@@ -12,6 +12,7 @@ export const rmCommand = new Command('rm')
   .argument('<path>', 'File, metadata.json, or directory to remove')
   .option('-f, --force', 'Skip confirmation prompts')
   .option('--keep-local', 'Only stage server deletion, do not delete local files')
+  .option('--hard', 'Immediately delete local files (no Trash; legacy behavior)')
   .action(async (targetPath, options) => {
     try {
       const pathStat = await stat(targetPath).catch(() => null);
@@ -113,21 +114,35 @@ async function rmFileRecord(metaPath, options, { skipPrompt = false } = {}) {
     }
   }
 
-  // Stage deletion
+  // Stage deletion (include metaPath for Trash workflow in push.js)
   const expression = `RowID:del${rowId};entity:${entity}=true`;
-  await addDeleteEntry({ UID: uid, RowID: rowId, entity, name: displayName, expression });
+  await addDeleteEntry({ UID: uid, RowID: rowId, entity, name: displayName, expression, metaPath });
   log.success(`  Staged: ${displayName} → ${expression}`);
 
   // Remove from app.json
   await removeAppJsonReference(metaPath);
 
-  // Delete local files
+  // Handle local files
   if (!options.keepLocal) {
-    for (const f of localFiles) {
-      try {
-        await unlink(f);
-        log.dim(`  Deleted ${f}`);
-      } catch { /* file may not exist */ }
+    if (options.hard) {
+      // --hard: original behavior — immediate delete
+      for (const f of localFiles) {
+        try { await unlink(f); log.dim(`  Deleted ${f}`); } catch {}
+      }
+    } else {
+      // Default: rename to __WILL_DELETE__ prefix
+      for (const f of localFiles) {
+        const fDir = dirname(f);
+        const fName = basename(f);
+        if (fName.startsWith('__WILL_DELETE__')) continue; // idempotency guard
+        const willDeletePath = join(fDir, `__WILL_DELETE__${fName}`);
+        try {
+          await rename(f, willDeletePath);
+          log.dim(`  Staged for delete: ${willDeletePath}`);
+        } catch (err) {
+          log.warn(`  Could not rename ${f}: ${err.message}`);
+        }
+      }
     }
   }
 
@@ -196,18 +211,35 @@ async function rmFile(filePath, options) {
   }
 
   const expression = `RowID:del${rowId};entity:${entity}=true`;
-  await addDeleteEntry({ UID: uid, RowID: rowId, entity, name: displayName, expression });
+  await addDeleteEntry({ UID: uid, RowID: rowId, entity, name: displayName, expression, metaPath });
   log.success(`Staged deletion: ${expression}`);
 
   await removeAppJsonReference(metaPath);
 
   if (!options.keepLocal) {
-    for (const f of localFiles) {
-      try {
-        await unlink(f);
-        log.dim(`  Deleted ${f}`);
-      } catch {
-        log.warn(`  Could not delete ${f} (may not exist)`);
+    if (options.hard) {
+      // --hard: original behavior — immediate delete
+      for (const f of localFiles) {
+        try {
+          await unlink(f);
+          log.dim(`  Deleted ${f}`);
+        } catch {
+          log.warn(`  Could not delete ${f} (may not exist)`);
+        }
+      }
+    } else {
+      // Default: rename to __WILL_DELETE__ prefix
+      for (const f of localFiles) {
+        const fDir = dirname(f);
+        const fName = basename(f);
+        if (fName.startsWith('__WILL_DELETE__')) continue; // idempotency guard
+        const willDeletePath = join(fDir, `__WILL_DELETE__${fName}`);
+        try {
+          await rename(f, willDeletePath);
+          log.dim(`  Staged for delete: ${willDeletePath}`);
+        } catch (err) {
+          log.warn(`  Could not rename ${f}: ${err.message}`);
+        }
       }
     }
   }

package/src/lib/filenames.js

@@ -0,0 +1,151 @@
+/**
+ * Filename convention helpers for the UID tilde convention.
+ * All entity files use <basename>~<uid>.<ext> as the local filename.
+ */
+
+import { rename, writeFile } from 'fs/promises';
+import { join, dirname, basename, extname } from 'path';
+
+/**
+ * Build a UID-bearing filename following the tilde convention.
+ * If name === uid, omit the tilde suffix (avoids <uid>~<uid>).
+ *
+ * @param {string} name  - Sanitized base name (no extension)
+ * @param {string} uid   - Server-assigned UID
+ * @param {string} [ext] - File extension WITHOUT leading dot (e.g. 'css', 'png', '')
+ * @returns {string}     - e.g. "colors~abc123.css" or "abc123.css" or "colors~abc123"
+ */
+export function buildUidFilename(name, uid, ext = '') {
+  const base = (name === uid) ? uid : `${name}~${uid}`;
+  return ext ? `${base}.${ext}` : base;
+}
+
+/**
+ * Strip the ~<uid> portion from a local filename.
+ * Used when the local file is "logo~def456.png" but the upload should send "logo.png".
+ *
+ * If the uid is not found in the filename, returns localName unchanged.
+ *
+ * @param {string} localName  - e.g. "logo~def456.png"
+ * @param {string} uid        - e.g. "def456"
+ * @returns {string}          - e.g. "logo.png"
+ */
+export function stripUidFromFilename(localName, uid) {
+  if (!uid || !localName) return localName;
+  const marker = `~${uid}`;
+  const idx = localName.indexOf(marker);
+  if (idx === -1) return localName;
+  return localName.slice(0, idx) + localName.slice(idx + marker.length);
+}
+
+/**
+ * Check whether a filename already contains ~<uid>.
+ */
+export function hasUidInFilename(filename, uid) {
+  return typeof filename === 'string' && typeof uid === 'string'
+    && filename.includes(`~${uid}`);
+}
+
+/**
+ * Detect whether a metadata filename uses the OLD dot-separated convention:
+ *   <name>.<uid>.metadata.json
+ * where uid is a sequence of ≥10 lowercase alphanumeric characters.
+ *
+ * Returns { name, uid } or null.
+ */
+export function detectLegacyDotUid(filename) {
+  const match = filename.match(/^(.+)\.([a-z0-9]{10,})\.metadata\.json$/);
+  return match ? { name: match[1], uid: match[2] } : null;
+}
+
+/**
+ * Rename a file pair (content + metadata) to the ~uid convention after server assigns a UID.
+ * Updates @reference values inside the metadata file.
+ * Restores file timestamps from _LastUpdated.
+ *
+ * @param {Object} meta        - Current metadata object
+ * @param {string} metaPath    - Absolute path to the .metadata.json file
+ * @param {string} uid         - Newly assigned UID from server
+ * @param {string} lastUpdated - Server _LastUpdated value
+ * @param {string} serverTz    - Timezone for timestamp conversion
+ * @returns {Promise<{ newMetaPath: string, newFilePath: string|null }>}
+ */
+export async function renameToUidConvention(meta, metaPath, uid, lastUpdated, serverTz) {
+  const metaDir = dirname(metaPath);
+  const metaBase = basename(metaPath, '.metadata.json'); // e.g. "colors" or "logo.png"
+
+  if (hasUidInFilename(metaBase, uid)) {
+    return { newMetaPath: metaPath, newFilePath: null }; // already renamed
+  }
+
+  // For media files: metaBase = "logo.png", newBase = "logo~uid.png"
+  // For content files: metaBase = "colors", newBase = "colors~uid"
+  const metaBaseExt = extname(metaBase); // ".png" for media metadata, "" for content metadata
+  let newMetaBase;
+  if (metaBaseExt) {
+    // Media: "logo.png" → "logo~uid.png"
+    const nameWithoutExt = metaBase.slice(0, -metaBaseExt.length);
+    newMetaBase = `${buildUidFilename(nameWithoutExt, uid)}${metaBaseExt}`;
+  } else {
+    // Content/entity-dir: "colors" → "colors~uid"
+    newMetaBase = buildUidFilename(metaBase, uid);
+  }
+
+  const newMetaPath = join(metaDir, `${newMetaBase}.metadata.json`);
+
+  // Update metadata in memory
+  meta.UID = uid;
+  const updatedMeta = { ...meta };
+
+  // Rename content files referenced in _contentColumns and _mediaFile
+  const contentCols = [...(meta._contentColumns || [])];
+  if (meta._mediaFile) contentCols.push('_mediaFile');
+
+  let newFilePath = null;
+
+  for (const col of contentCols) {
+    const ref = meta[col];
+    if (!ref || !String(ref).startsWith('@')) continue;
+
+    const oldRefFile = String(ref).substring(1);
+    const oldFilePath = join(metaDir, oldRefFile);
+
+    // Compute new filename: insert uid
+    const oldExt = extname(oldRefFile); // ".css", ".png"
+    const oldBase = basename(oldRefFile, oldExt); // "colors" or "logo"
+    const newRefBase = buildUidFilename(oldBase, uid);
+    const newRefFile = oldExt ? `${newRefBase}${oldExt}` : newRefBase;
+    const newRefPath = join(metaDir, newRefFile);
+
+    try {
+      await rename(oldFilePath, newRefPath);
+      updatedMeta[col] = `@${newRefFile}`;
+      if (!newFilePath) newFilePath = newRefPath;
+    } catch {
+      // File may already be renamed or may not exist
+    }
+  }
+
+  // Write updated metadata to new path
+  await writeFile(newMetaPath, JSON.stringify(updatedMeta, null, 2) + '\n');
+
+  // Remove old metadata file if it's different from newMetaPath
+  if (metaPath !== newMetaPath) {
+    try { await rename(metaPath, newMetaPath); } catch { /* already written above */ }
+  }
+
+  // Restore timestamps
+  if (serverTz && lastUpdated) {
+    const { setFileTimestamps } = await import('./timestamps.js');
+    for (const col of contentCols) {
+      const ref = updatedMeta[col];
+      if (ref && String(ref).startsWith('@')) {
+        const fp = join(metaDir, String(ref).substring(1));
+        try { await setFileTimestamps(fp, lastUpdated, lastUpdated, serverTz); } catch {}
+      }
+    }
+    try { await setFileTimestamps(newMetaPath, lastUpdated, lastUpdated, serverTz); } catch {}
+  }
+
+  return { newMetaPath, newFilePath, updatedMeta };
+}

package/src/lib/formatter.js

@@ -16,19 +16,30 @@ export function formatResponse(result, options = {}) {
   }
 
   if (result.successful) {
-    log.success(`Request successful ${chalk.dim(result.url || '')}`);
+    log.success('Request successful');
+    // Show the payload as compact highlighted JSON so the user sees what changed
+    if (result.payload) {
+      printJsonCompact(result.payload);
+    }
   } else {
-    log.error(`Request failed ${chalk.dim(result.url || '')}`);
-  }
-
-  if (result.messages && result.messages.length > 0) {
-    for (const msg of result.messages) {
-      log.label('Message', msg);
+    log.error('Request failed');
+    if (result.messages && result.messages.length > 0) {
+      for (const msg of result.messages) {
+        log.label('Message', truncateParamValues(String(msg)));
+      }
+    }
+    // On failure: show compact response summary; full JSON only with --verbose
+    if (result.data) {
+      if (options.verbose) {
+        log.plain('');
+        log.dim('─── Response JSON ───');
+        printJson(result.data);
+      } else {
+        log.plain('');
+        log.dim('─── Response (use -v for full JSON) ───');
+        printJsonCompact(result.data);
+      }
     }
-  }
-
-  if (result.payload) {
-    formatPayload(result.payload, options);
   }
 }
 
@@ -301,6 +312,77 @@ function printJson(data) {
   log.plain(colored);
 }
 
+/**
+ * Print JSON with syntax highlighting, truncating long string values.
+ * Strings over 120 chars are collapsed to a short preview + byte count.
+ */
+function printJsonCompact(data) {
+  const json = JSON.stringify(data, (key, value) => {
+    if (typeof value === 'string' && value.length > 120) {
+      const preview = value.substring(0, 60).replace(/\n/g, '\\n');
+      const kb = (value.length / 1024).toFixed(1);
+      return `${preview}… (${kb} KB)`;
+    }
+    return value;
+  }, 2);
+  if (!json) { log.plain('null'); return; }
+
+  const colored = json.replace(
+    /("(?:[^"\\]|\\.)*")\s*:/g,
+    (match, k) => chalk.cyan(k) + ':'
+  ).replace(
+    /:\s*("(?:[^"\\]|\\.)*")/g,
+    (match, val) => ': ' + chalk.green(val)
+  ).replace(
+    /:\s*(\d+\.?\d*)/g,
+    (match, num) => ': ' + chalk.yellow(num)
+  ).replace(
+    /:\s*(true|false|null)/g,
+    (match, val) => ': ' + chalk.magenta(val)
+  );
+
+  log.plain(colored);
+}
+
+/**
+ * Truncate long parameter values in server error messages.
+ * SQL debug output contains lines like "  @Content = <entire HTML file>" —
+ * collapse those so the terminal isn't flooded.
+ *
+ * Strategy: split on lines, find "  @Param = value" lines where the value
+ * portion (everything after " = ") spans many characters, and collapse.
+ */
+function truncateParamValues(text) {
+  const lines = text.split('\n');
+  const result = [];
+  let i = 0;
+
+  while (i < lines.length) {
+    const paramMatch = lines[i].match(/^(\s*@\w+\s*=\s*)(.*)/);
+    if (paramMatch) {
+      const prefix = paramMatch[1]; // "  @Content = "
+      // Collect continuation lines (lines that don't start a new @param or section marker)
+      let value = paramMatch[2];
+      while (i + 1 < lines.length && !lines[i + 1].match(/^\s*@\w+\s*=/) && !lines[i + 1].match(/^\[/)) {
+        i++;
+        value += '\n' + lines[i];
+      }
+      if (value.length > 120) {
+        const preview = value.substring(0, 60).replace(/\n/g, ' ').trim();
+        const kb = (value.length / 1024).toFixed(1);
+        result.push(`${prefix}${preview}... (${kb} KB)`);
+      } else {
+        result.push(`${prefix}${value}`);
+      }
+    } else {
+      result.push(lines[i]);
+    }
+    i++;
+  }
+
+  return result.join('\n');
+}
+
 export function formatError(err) {
   if (err.message) {
     log.error(err.message);