@dboio/cli 0.9.6 → 0.10.1

package/src/commands/rm.js

@@ -172,7 +172,7 @@ async function rmFile(filePath, options) {
     process.exit(1);
   }
   if (!rowId) {
-    log.error(`No row ID found in "${metaPath}". Cannot build delete expression.`);
+    log.error(`No row ID found in "${metaPath}". Cannot build delete expression.\n  Metadata needs _id or ${entity.charAt(0).toUpperCase() + entity.slice(1)}ID. Run "dbo pull" to populate.`);
     process.exit(1);
   }
 

package/src/commands/sync.js

@@ -0,0 +1,68 @@
+import { Command } from 'commander';
+import { log } from '../lib/logger.js';
+import { loadConfig, loadAppConfig, saveAppJsonBaseline } from '../lib/config.js';
+import { DboClient } from '../lib/client.js';
+import { decodeBase64Fields } from './clone.js';
+
+export const syncCommand = new Command('sync')
+  .description('Synchronise local state with the server')
+  .option('--baseline', 'Re-fetch server state and update .dbo/.app_baseline.json (does not modify local files)')
+  .action(async (options) => {
+    if (!options.baseline) {
+      log.warn('No sync mode specified. Use --baseline to reset the baseline file.');
+      process.exit(1);
+    }
+
+    const config = await loadConfig();
+    if (!config.domain) {
+      log.error('No domain configured. Run "dbo init" first.');
+      process.exit(1);
+    }
+
+    const appConfig = await loadAppConfig();
+    if (!appConfig.AppShortName) {
+      log.error('No AppShortName found. Run "dbo clone" first.');
+      process.exit(1);
+    }
+
+    const ora = (await import('ora')).default;
+    const spinner = ora('Syncing baseline from server...').start();
+
+    const client = new DboClient({ domain: config.domain, verbose: options.verbose });
+
+    let result;
+    try {
+      result = await client.get(`/api/app/object/${appConfig.AppShortName}`);
+    } catch (err) {
+      spinner.fail(`Failed to fetch app JSON: ${err.message}`);
+      process.exit(1);
+    }
+
+    const data = result.payload || result.data;
+
+    let appRecord;
+    if (Array.isArray(data)) {
+      appRecord = data.length > 0 ? data[0] : null;
+    } else if (data?.Rows?.length > 0) {
+      appRecord = data.Rows[0];
+    } else if (data?.rows?.length > 0) {
+      appRecord = data.rows[0];
+    } else if (data && typeof data === 'object' && (data.UID || data.ShortName)) {
+      appRecord = data;
+    } else {
+      appRecord = null;
+    }
+
+    if (!appRecord) {
+      spinner.fail(`No app found with ShortName "${appConfig.AppShortName}"`);
+      process.exit(1);
+    }
+
+    // Deep clone and decode base64 fields (same logic as clone's saveBaselineFile)
+    const baseline = JSON.parse(JSON.stringify(appRecord));
+    decodeBase64Fields(baseline);
+
+    await saveAppJsonBaseline(baseline);
+    spinner.succeed('.dbo/.app_baseline.json updated from server');
+    log.dim('  Run "dbo push" to sync local changes against the new baseline');
+  });

package/src/lib/config.js

@@ -1,4 +1,4 @@
-import { readFile, writeFile, mkdir, access } from 'fs/promises';
+import { readFile, writeFile, mkdir, access, chmod, unlink } from 'fs/promises';
 import { join } from 'path';
 import { log } from './logger.js';
 
@@ -8,7 +8,7 @@ const CONFIG_LOCAL_FILE = 'config.local.json';
 const CREDENTIALS_FILE = 'credentials.json';
 const COOKIES_FILE = 'cookies.txt';
 const SYNCHRONIZE_FILE = 'synchronize.json';
-const BASELINE_FILE = '.app.json';
+const BASELINE_FILE = '.app_baseline.json';
 
 function dboDir() {
   return join(process.cwd(), DBO_DIR);
@@ -693,10 +693,10 @@ export async function ensureGitignore(patterns) {
   for (const p of toAdd) log.dim(`  Added ${p} to .gitignore`);
 }
 
-// ─── Baseline (.app.json) ─────────────────────────────────────────────────
+// ─── Baseline (.dbo/.app_baseline.json) ───────────────────────────────────
 
-function baselinePath() {
-  return join(process.cwd(), BASELINE_FILE);
+export function baselinePath() {
+  return join(dboDir(), BASELINE_FILE);
 }
 
 /**
@@ -707,11 +707,38 @@ export async function hasBaseline() {
 }
 
 /**
- * Load .app.json baseline file (tracks server state for delta detection).
+ * Load .dbo/.app_baseline.json baseline file.
+ * Auto-migrates from legacy root .app.json if the new path does not exist.
  */
 export async function loadAppJsonBaseline() {
+  const newPath = baselinePath();
+
+  // Legacy migration: root .app.json → .dbo/.app_baseline.json
+  if (!(await exists(newPath))) {
+    const legacyPath = join(process.cwd(), '.app.json');
+    if (await exists(legacyPath)) {
+      let parsed;
+      try {
+        parsed = JSON.parse(await readFile(legacyPath, 'utf8'));
+      } catch {
+        log.warn('Could not migrate .app.json — file is not valid JSON. Delete it manually and run "dbo clone" to recreate the baseline.');
+        return null;
+      }
+      await mkdir(dboDir(), { recursive: true });
+      await writeFile(newPath, JSON.stringify(parsed, null, 2) + '\n');
+      try { await chmod(newPath, 0o444); } catch { /* ignore */ }
+      try {
+        await unlink(legacyPath);
+      } catch {
+        log.warn('Migrated baseline but could not delete root .app.json — please remove it manually.');
+      }
+      log.dim('Migrated .app.json → .dbo/.app_baseline.json (system-managed baseline)');
+      return parsed;
+    }
+  }
+
   try {
-    const raw = await readFile(baselinePath(), 'utf8');
+    const raw = await readFile(newPath, 'utf8');
     return JSON.parse(raw);
   } catch {
     return null;
@@ -719,10 +746,24 @@ export async function loadAppJsonBaseline() {
 }
 
 /**
- * Save .app.json baseline file.
+ * Save .dbo/.app_baseline.json baseline file.
+ * Temporarily widens permissions before writing (chmod 0o644),
+ * then restores read-only (chmod 0o444) after writing.
  */
 export async function saveAppJsonBaseline(data) {
+  await mkdir(dboDir(), { recursive: true });
+
+  try {
+    await chmod(baselinePath(), 0o644);
+  } catch { /* file doesn't exist yet — first write */ }
+
   await writeFile(baselinePath(), JSON.stringify(data, null, 2) + '\n');
+
+  try {
+    await chmod(baselinePath(), 0o444);
+  } catch {
+    log.warn('⚠ Could not set baseline file permissions — ensure .dbo/.app_baseline.json is not manually edited');
+  }
 }
 
 /**

package/src/lib/delta.js

@@ -1,37 +1,26 @@
 import { readFile, stat } from 'fs/promises';
 import { join, dirname } from 'path';
 import { log } from './logger.js';
+import { loadAppJsonBaseline, saveAppJsonBaseline } from './config.js';
 
 /**
- * Load the baseline file (.app.json) from disk.
+ * Load the baseline file from disk.
+ * Delegates to loadAppJsonBaseline() in config.js for the canonical path.
  *
- * @param {string} cwd - Current working directory
  * @returns {Promise<Object|null>} - Baseline JSON or null if not found
  */
-export async function loadBaseline(cwd = process.cwd()) {
-  const baselinePath = join(cwd, '.app.json');
-  try {
-    const raw = await readFile(baselinePath, 'utf8');
-    return JSON.parse(raw);
-  } catch (err) {
-    if (err.code === 'ENOENT') {
-      return null; // Baseline doesn't exist
-    }
-    log.warn(`Failed to parse .app.json: ${err.message}`);
-    return null;
-  }
+export async function loadBaseline() {
+  return loadAppJsonBaseline();
 }
 
 /**
- * Save baseline data to .app.json file.
+ * Save baseline data to disk.
+ * Delegates to saveAppJsonBaseline() in config.js for the canonical path.
  *
  * @param {Object} data - Baseline JSON data
- * @param {string} cwd - Current working directory
  */
-export async function saveBaseline(data, cwd = process.cwd()) {
-  const { writeFile } = await import('fs/promises');
-  const baselinePath = join(cwd, '.app.json');
-  await writeFile(baselinePath, JSON.stringify(data, null, 2), 'utf8');
+export async function saveBaseline(data) {
+  return saveAppJsonBaseline(data);
 }
 
 /**
@@ -48,12 +37,31 @@ export function findBaselineEntry(baseline, entity, uid) {
     return null;
   }
 
+  // Check top-level array first
   const entityArray = baseline.children[entity];
-  if (!Array.isArray(entityArray)) {
-    return null;
+  if (Array.isArray(entityArray)) {
+    const found = entityArray.find(item => item.UID === uid);
+    if (found) return found;
+  }
+
+  // For output hierarchy entities (output_value, output_value_filter,
+  // output_value_entity_column_rel), also search nested inside each
+  // output record's .children — server nests them per-output.
+  if (entity !== 'output') {
+    const outputs = baseline.children.output;
+    if (Array.isArray(outputs)) {
+      for (const o of outputs) {
+        if (!o.children) continue;
+        const nested = o.children[entity];
+        if (Array.isArray(nested)) {
+          const found = nested.find(item => item.UID === uid);
+          if (found) return found;
+        }
+      }
+    }
   }
 
-  return entityArray.find(item => item.UID === uid) || null;
+  return null;
 }
 
 /**
@@ -127,6 +135,13 @@ export async function detectChangedColumns(metaPath, baseline) {
       const baselineValue = normalizeValue(baselineEntry[columnName]);
 
       if (currentValue !== baselineValue) {
+        // Skip Extension column when baseline is null/empty — clone derives
+        // it from the filename for local use but it's not a user change.
+        if (columnName === 'Extension'
+            && !baselineValue
+            && (baselineEntry[columnName] === null || baselineEntry[columnName] === undefined)) {
+          continue;
+        }
         changedColumns.push(columnName);
       }
     }
@@ -154,7 +169,7 @@ export async function detectChangedColumns(metaPath, baseline) {
  * @param {Object} metadata - Metadata object
  * @returns {string[]} - Array of user column names
  */
-function getAllUserColumns(metadata) {
+export function getAllUserColumns(metadata) {
   return Object.keys(metadata).filter(col => !shouldSkipColumn(col));
 }
 
@@ -164,7 +179,7 @@ function getAllUserColumns(metadata) {
  * @param {string} columnName - Column name
  * @returns {boolean} - True if should skip
  */
-function shouldSkipColumn(columnName) {
+export function shouldSkipColumn(columnName) {
   // Skip system columns starting with underscore, UID, and children
   return columnName.startsWith('_') ||
          columnName === 'UID' ||
@@ -177,7 +192,7 @@ function shouldSkipColumn(columnName) {
  * @param {*} value - Value to check
  * @returns {boolean} - True if reference
  */
-function isReference(value) {
+export function isReference(value) {
   return typeof value === 'string' && value.startsWith('@');
 }
 
@@ -189,7 +204,7 @@ function isReference(value) {
  * @param {string} baseDir - Base directory containing metadata
  * @returns {string} - Absolute file path
  */
-function resolveReferencePath(reference, baseDir) {
+export function resolveReferencePath(reference, baseDir) {
   const refPath = reference.substring(1); // Strip leading @
   if (refPath.startsWith('/')) {
     return join(process.cwd(), refPath);
@@ -203,7 +218,7 @@ function resolveReferencePath(reference, baseDir) {
  * @param {*} value - Value to normalize
  * @returns {string} - Normalized string value
  */
-function normalizeValue(value) {
+export function normalizeValue(value) {
   if (value === null || value === undefined) {
     return '';
   }
@@ -215,3 +230,75 @@ function normalizeValue(value) {
 
   return String(value).trim();
 }
+
+// ─── Compound Output Delta Detection ────────────────────────────────────────
+
+const _OUTPUT_DOC_KEYS = ['column', 'join', 'filter'];
+
+/**
+ * Detect changed columns across a compound output file (root + inline children).
+ *
+ * @param {string} metaPath - Path to the root output JSON file
+ * @param {Object} baseline - The baseline JSON
+ * @returns {Promise<{ root: string[], children: Object<string, string[]> }>}
+ *   root: changed column names on the root output entity
+ *   children: { uid: [changedCols] } for each inline child entity
+ */
+export async function detectOutputChanges(metaPath, baseline) {
+  const metaRaw = await readFile(metaPath, 'utf8');
+  const meta = JSON.parse(metaRaw);
+  const metaDir = dirname(metaPath);
+
+  // Detect root changes
+  const root = await _detectEntityChanges(meta, baseline, metaDir);
+
+  // Detect child changes recursively via children.{column,join,filter}
+  const children = {};
+  if (meta.children) {
+    await _walkChildrenForChanges(meta.children, baseline, metaDir, children);
+  }
+
+  return { root, children };
+}
+
+async function _detectEntityChanges(entity, baseline, metaDir) {
+  const { UID, _entity } = entity;
+  const baselineEntry = findBaselineEntry(baseline, _entity, UID);
+  if (!baselineEntry) {
+    return getAllUserColumns(entity);
+  }
+  const changed = [];
+  for (const [col, val] of Object.entries(entity)) {
+    if (shouldSkipColumn(col) || col === 'children') continue;
+    if (isReference(val)) {
+      const refPath = resolveReferencePath(val, metaDir);
+      if (await compareFileContent(refPath, baselineEntry[col])) changed.push(col);
+    } else {
+      if (normalizeValue(val) !== normalizeValue(baselineEntry[col])) {
+        // Skip Extension column when baseline is null/empty (same as detectChangedColumns)
+        if (col === 'Extension'
+            && !normalizeValue(baselineEntry[col])
+            && (baselineEntry[col] === null || baselineEntry[col] === undefined)) {
+          continue;
+        }
+        changed.push(col);
+      }
+    }
+  }
+  return changed;
+}
+
+async function _walkChildrenForChanges(childrenObj, baseline, metaDir, result) {
+  for (const docKey of _OUTPUT_DOC_KEYS) {
+    const entityArray = childrenObj[docKey];
+    if (!Array.isArray(entityArray) || entityArray.length === 0) continue;
+    for (const child of entityArray) {
+      const changed = await _detectEntityChanges(child, baseline, metaDir);
+      result[child.UID] = changed;
+      // Recurse into child's own children (e.g. column[0].children.filter)
+      if (child.children) {
+        await _walkChildrenForChanges(child.children, baseline, metaDir, result);
+      }
+    }
+  }
+}

package/src/lib/diff.js

@@ -48,9 +48,15 @@ export async function findMetadataFiles(dir, ig) {
       const relPath = relative(process.cwd(), fullPath).replace(/\\/g, '/');
       if (!ig.ignores(relPath)) results.push(fullPath);
     } else if (entry.name.startsWith('_output~') && entry.name.endsWith('.json') && !entry.name.includes('.CustomSQL.')) {
-      // Output hierarchy files: _output~<name>~<uid>.json and nested entity files
-      const relPath = relative(process.cwd(), fullPath).replace(/\\/g, '/');
-      if (!ig.ignores(relPath)) results.push(fullPath);
+      // Output hierarchy root files only: _output~<name>~<uid>.json
+      // Exclude old-format child output files — they contain a dot-prefixed
+      // child-type segment (.column~, .join~, .filter~) before .json.
+      // Root output files never have these segments, even when <name> contains dots.
+      const isChildFile = /\.(column|join|filter)~/.test(entry.name);
+      if (!isChildFile) {
+        const relPath = relative(process.cwd(), fullPath).replace(/\\/g, '/');
+        if (!ig.ignores(relPath)) results.push(fullPath);
+      }
     }
   }
 

package/src/lib/folder-icon.js

@@ -0,0 +1,120 @@
+import { execFile } from 'child_process';
+import { writeFile, stat, access } from 'fs/promises';
+import { join } from 'path';
+import { promisify } from 'util';
+
+const execFileAsync = promisify(execFile);
+
+/**
+ * Best-effort: apply the system trash/recycle-bin icon to a folder.
+ * Never throws — all errors are silently swallowed.
+ *
+ * @param {string} folderPath  Absolute path to the trash directory
+ */
+export async function applyTrashIcon(folderPath) {
+  try {
+    const s = await stat(folderPath);
+    if (!s.isDirectory()) return;
+
+    switch (process.platform) {
+      case 'darwin':
+        await applyMacIcon(folderPath);
+        break;
+      case 'win32':
+        await applyWindowsIcon(folderPath);
+        break;
+      case 'linux':
+        await applyLinuxIcon(folderPath);
+        break;
+    }
+  } catch {
+    // Best-effort — never propagate
+  }
+}
+
+/**
+ * Re-apply the trash icon only if the icon marker file is missing.
+ * Much cheaper than applyTrashIcon — skips the osascript/attrib call
+ * when the icon is already in place.
+ *
+ * Call this after moving files into trash/ to self-heal the icon
+ * in case the user cleared the directory contents.
+ *
+ * @param {string} folderPath  Absolute path to the trash directory
+ */
+export async function ensureTrashIcon(folderPath) {
+  try {
+    switch (process.platform) {
+      case 'darwin': {
+        // macOS: Icon\r file exists when icon is applied
+        const iconFile = join(folderPath, 'Icon\r');
+        try { await access(iconFile); return; } catch { /* missing — re-apply */ }
+        await applyMacIcon(folderPath);
+        break;
+      }
+      case 'win32': {
+        const iniPath = join(folderPath, 'desktop.ini');
+        try { await access(iniPath); return; } catch { /* missing */ }
+        await applyWindowsIcon(folderPath);
+        break;
+      }
+      case 'linux': {
+        const dirFile = join(folderPath, '.directory');
+        try { await access(dirFile); return; } catch { /* missing */ }
+        await applyLinuxIcon(folderPath);
+        break;
+      }
+    }
+  } catch {
+    // Best-effort — never propagate
+  }
+}
+
+// ── macOS ──────────────────────────────────────────────────────────────
+
+const MACOS_TRASH_ICON =
+  '/System/Library/CoreServices/CoreTypes.bundle/Contents/Resources/TrashIcon.icns';
+
+async function applyMacIcon(folderPath) {
+  await access(MACOS_TRASH_ICON);
+
+  const script =
+    'use framework "AppKit"\n' +
+    `set iconImage to (current application's NSImage's alloc()'s initWithContentsOfFile:"${MACOS_TRASH_ICON}")\n` +
+    `(current application's NSWorkspace's sharedWorkspace()'s setIcon:iconImage forFile:"${folderPath}" options:0)`;
+
+  await execFileAsync('osascript', ['-e', script], { timeout: 5000 });
+}
+
+// ── Windows ────────────────────────────────────────────────────────────
+
+async function applyWindowsIcon(folderPath) {
+  const iniPath = join(folderPath, 'desktop.ini');
+  const iniContent =
+    '[.ShellClassInfo]\r\nIconResource=%SystemRoot%\\System32\\shell32.dll,31\r\n';
+
+  await writeFile(iniPath, iniContent);
+  await execFileAsync('attrib', ['+H', '+S', iniPath], { timeout: 5000 });
+  await execFileAsync('attrib', ['+S', folderPath], { timeout: 5000 });
+}
+
+// ── Linux ──────────────────────────────────────────────────────────────
+
+async function applyLinuxIcon(folderPath) {
+  // KDE Dolphin — .directory file
+  await writeFile(
+    join(folderPath, '.directory'),
+    '[Desktop Entry]\nIcon=user-trash\n',
+  );
+
+  // GNOME Nautilus — gio metadata (may not be available on KDE-only systems)
+  try {
+    await execFileAsync(
+      'gio',
+      ['set', folderPath, 'metadata::custom-icon-name', 'user-trash'],
+      { timeout: 5000 },
+    );
+  } catch {
+    // gio not available — .directory file is enough for KDE
+  }
+}

package/src/lib/ignore.js

@@ -16,12 +16,12 @@ const DEFAULT_FILE_CONTENT = `# DBO CLI ignore patterns
 .dboignore
 *.dboio.json
 app.json
-.app.json
 dbo.deploy.json
 
 # Editor / IDE / OS
 .DS_Store
 Thumbs.db
+Icon\\r
 .idea/
 .vscode/
 *.codekit3

package/src/lib/input-parser.js

@@ -1,6 +1,6 @@
 import { readFile } from 'fs/promises';
 import { log } from './logger.js';
-import { loadUserInfo, loadTicketSuggestionOutput } from './config.js';
+import { loadConfig, loadUserInfo, loadTicketSuggestionOutput } from './config.js';
 import { buildTicketExpression, setGlobalTicket, setRecordTicket, getGlobalTicket, getRecordTicket, setTicketingRequired } from './ticketing.js';
 import { DboClient } from './client.js';
 
@@ -186,7 +186,6 @@ export async function checkSubmitErrors(result, context = {}) {
   if (needsUser && !userResolved) {
     log.warn(`This operation requires an authenticated user (${matchedUserPattern}).`);
     log.dim('  Your session may have expired, or you may not be logged in.');
-    log.dim('  You can log in with "dbo login" to avoid this prompt in the future.');
 
     const stored = await loadUserInfo();
 
@@ -197,6 +196,7 @@ export async function checkSubmitErrors(result, context = {}) {
         name: 'userChoice',
         message: 'User ID Required:',
         choices: [
+          { name: 'Re-login now (recommended)', value: '_relogin' },
           { name: `Use session user (ID: ${stored.userId})`, value: stored.userId },
           { name: 'Enter a different User ID', value: '_custom' },
         ],
@@ -210,9 +210,19 @@ export async function checkSubmitErrors(result, context = {}) {
       });
     } else {
       prompts.push({
-        type: 'input',
-        name: 'userValue',
+        type: 'list',
+        name: 'userChoice',
         message: 'User ID Required:',
+        choices: [
+          { name: 'Re-login now', value: '_relogin' },
+          { name: 'Enter User ID manually', value: '_custom' },
+        ],
+      });
+      prompts.push({
+        type: 'input',
+        name: 'customUserValue',
+        message: 'User ID:',
+        when: (answers) => answers.userChoice === '_custom',
         validate: v => v.trim() ? true : 'User ID is required',
       });
     }
@@ -233,12 +243,29 @@ export async function checkSubmitErrors(result, context = {}) {
 
   if (answers.ticketId) retryParams['_OverrideTicketID'] = answers.ticketId.trim();
 
-  const userValue = answers.userValue
-    || (answers.userChoice === '_custom' ? answers.customUserValue : answers.userChoice);
-  if (userValue) {
-    const resolved = userValue.trim();
-    retryParams['_OverrideUserID'] = resolved;
-    _sessionUserOverride = resolved; // cache for remaining records in this batch
+  if (answers.userChoice === '_relogin') {
+    // Run login flow inline, then use the stored user ID
+    try {
+      const config = await loadConfig();
+      const { performLogin } = await import('../commands/login.js');
+      await performLogin(config.domain);
+      const refreshed = await loadUserInfo();
+      if (refreshed.userId) {
+        retryParams['_OverrideUserID'] = refreshed.userId;
+        _sessionUserOverride = refreshed.userId;
+      }
+    } catch (err) {
+      log.error(`Re-login failed: ${err.message}`);
+      return null;
+    }
+  } else {
+    const userValue = answers.userValue
+      || (answers.userChoice === '_custom' ? answers.customUserValue : answers.userChoice);
+    if (userValue) {
+      const resolved = userValue.trim();
+      retryParams['_OverrideUserID'] = resolved;
+      _sessionUserOverride = resolved;
+    }
   }
 
   return retryParams;