@dboio/cli 0.4.1

package/src/commands/push.js

@@ -0,0 +1,309 @@
+import { Command } from 'commander';
+import { readFile, readdir, stat, writeFile } 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 { loadConfig } from '../lib/config.js';
+import { setFileTimestamps } from '../lib/timestamps.js';
+
+export const pushCommand = new Command('push')
+  .description('Push local files back to DBO.io using metadata from pull')
+  .argument('<path>', 'File or directory to push')
+  .option('-C, --confirm <value>', 'Commit: true (default) or false', 'true')
+  .option('--ticket <id>', 'Override ticket ID')
+  .option('--meta-only', 'Only push metadata changes, skip file content')
+  .option('--content-only', 'Only push file content, skip metadata columns')
+  .option('-y, --yes', 'Auto-accept all prompts (path refactoring, etc.)')
+  .option('--json', 'Output raw JSON')
+  .option('--jq <expr>', 'Filter JSON response')
+  .option('-v, --verbose', 'Show HTTP request details')
+  .option('--domain <host>', 'Override domain')
+  .action(async (targetPath, options) => {
+    try {
+      const client = new DboClient({ domain: options.domain, verbose: options.verbose });
+      const pathStat = await stat(targetPath);
+
+      if (pathStat.isDirectory()) {
+        await pushDirectory(targetPath, client, options);
+      } else {
+        await pushSingleFile(targetPath, client, options);
+      }
+    } catch (err) {
+      formatError(err);
+      process.exit(1);
+    }
+  });
+
+/**
+ * Push a single file using its companion .metadata.json
+ */
+async function pushSingleFile(filePath, client, options) {
+  // Find the metadata file
+  const dir = dirname(filePath);
+  const base = basename(filePath, extname(filePath));
+  const metaPath = join(dir, `${base}.metadata.json`);
+
+  let meta;
+  try {
+    meta = JSON.parse(await readFile(metaPath, 'utf8'));
+  } catch {
+    log.error(`No metadata found at "${metaPath}". Pull the record first with "dbo content pull" or "dbo output --save".`);
+    process.exit(1);
+  }
+
+  await pushFromMetadata(meta, metaPath, client, options);
+}
+
+/**
+ * Push all records found in a directory (recursive)
+ */
+async function pushDirectory(dirPath, client, options) {
+  const metaFiles = await findMetadataFiles(dirPath);
+
+  if (metaFiles.length === 0) {
+    log.warn(`No .metadata.json files found in "${dirPath}".`);
+    return;
+  }
+
+  log.info(`Found ${metaFiles.length} record(s) to push`);
+
+  let succeeded = 0;
+  let failed = 0;
+
+  for (const metaPath of metaFiles) {
+    let meta;
+    try {
+      meta = JSON.parse(await readFile(metaPath, 'utf8'));
+    } catch (err) {
+      log.warn(`Skipping invalid metadata: ${metaPath} (${err.message})`);
+      failed++;
+      continue;
+    }
+
+    if (!meta.UID && !meta._id) {
+      log.warn(`Skipping "${metaPath}": no UID or _id found`);
+      failed++;
+      continue;
+    }
+
+    if (!meta._entity) {
+      log.warn(`Skipping "${metaPath}": no _entity found`);
+      failed++;
+      continue;
+    }
+
+    // Verify @file references exist
+    const contentCols = meta._contentColumns || [];
+    let missingFiles = false;
+    for (const col of contentCols) {
+      const ref = meta[col];
+      if (ref && ref.startsWith('@')) {
+        const refPath = join(dirname(metaPath), ref.substring(1));
+        try {
+          await stat(refPath);
+        } catch {
+          log.warn(`Skipping "${metaPath}": referenced file "${ref}" not found at "${refPath}"`);
+          missingFiles = true;
+          break;
+        }
+      }
+    }
+    if (missingFiles) { failed++; continue; }
+
+    try {
+      await pushFromMetadata(meta, metaPath, client, options);
+      succeeded++;
+    } catch (err) {
+      log.error(`Failed: ${metaPath} — ${err.message}`);
+      failed++;
+    }
+  }
+
+  log.info(`Push complete: ${succeeded} succeeded, ${failed} failed`);
+}
+
+/**
+ * Build and submit input expressions from a metadata object
+ */
+async function pushFromMetadata(meta, metaPath, client, options) {
+  const uid = meta.UID || meta._id;
+  const entity = meta._entity;
+  const contentCols = new Set(meta._contentColumns || []);
+  const metaDir = dirname(metaPath);
+
+  if (!uid) {
+    throw new Error(`No UID found in ${metaPath}`);
+  }
+  if (!entity) {
+    throw new Error(`No _entity found in ${metaPath}`);
+  }
+
+  // Detect path mismatch
+  if (meta.Path) {
+    await checkPathMismatch(meta, metaPath, options);
+  }
+
+  const dataExprs = [];
+  let metaUpdated = false;
+
+  for (const [key, value] of Object.entries(meta)) {
+    if (shouldSkipColumn(key)) continue;
+    if (key === 'UID') continue; // UID is the identifier, not a column to update
+    if (value === null || value === undefined) continue;
+
+    const isContentCol = contentCols.has(key);
+
+    // --meta-only: skip content columns
+    if (options.metaOnly && isContentCol) continue;
+    // --content-only: skip non-content columns
+    if (options.contentOnly && !isContentCol) continue;
+
+    const strValue = String(value);
+
+    if (strValue.startsWith('@')) {
+      // @filename reference — resolve to actual file path
+      const refFile = strValue.substring(1);
+      const refPath = join(metaDir, refFile);
+      dataExprs.push(`RowUID:${uid};column:${entity}.${key}@${refPath}`);
+    } else {
+      dataExprs.push(`RowUID:${uid};column:${entity}.${key}=${strValue}`);
+    }
+  }
+
+  if (dataExprs.length === 0) {
+    log.warn(`Nothing to push for ${basename(metaPath)}`);
+    return;
+  }
+
+  log.info(`Pushing ${basename(metaPath, '.metadata.json')} (${entity}:${uid}) — ${dataExprs.length} field(s)`);
+
+  const extraParams = { '_confirm': options.confirm };
+  if (options.ticket) extraParams['_OverrideTicketID'] = options.ticket;
+
+  let body = await buildInputBody(dataExprs, extraParams);
+  let result = await client.postUrlEncoded('/api/input/submit', body);
+
+  // Retry with prompted params if needed (ticket, user)
+  const retryParams = await checkSubmitErrors(result);
+  if (retryParams) {
+    Object.assign(extraParams, retryParams);
+    body = await buildInputBody(dataExprs, extraParams);
+    result = await client.postUrlEncoded('/api/input/submit', body);
+  }
+
+  formatResponse(result, { json: options.json, jq: options.jq });
+
+  // Update metadata on disk if path was changed
+  if (metaUpdated) {
+    await writeFile(metaPath, JSON.stringify(meta, null, 2) + '\n');
+    log.dim(`  → Updated ${metaPath}`);
+  }
+
+  if (!result.successful) {
+    throw new Error('Push failed');
+  }
+
+  // Update file timestamps from server response
+  try {
+    const editResults = result.payload?.Results?.Edit || result.data?.Payload?.Results?.Edit || [];
+    if (editResults.length > 0) {
+      const updated = editResults[0]._LastUpdated || editResults[0].LastUpdated;
+      if (updated) {
+        const config = await loadConfig();
+        const serverTz = config.ServerTimezone;
+        if (serverTz) {
+          // Update metadata _LastUpdated and set file mtime
+          meta._LastUpdated = updated;
+          await writeFile(metaPath, JSON.stringify(meta, null, 2) + '\n');
+          await setFileTimestamps(metaPath, meta._CreatedOn, updated, serverTz);
+          // Update content file mtime too
+          const contentCols = meta._contentColumns || [];
+          for (const col of contentCols) {
+            const ref = meta[col];
+            if (ref && String(ref).startsWith('@')) {
+              const contentPath = join(dirname(metaPath), String(ref).substring(1));
+              await setFileTimestamps(contentPath, meta._CreatedOn, updated, serverTz);
+            }
+          }
+        }
+      }
+    }
+  } catch { /* non-critical timestamp update */ }
+}
+
+/**
+ * Detect if a file has been moved to a different directory than its metadata Path suggests
+ */
+async function checkPathMismatch(meta, metaPath, options) {
+  const metaDir = dirname(metaPath);
+  const metaBase = basename(metaPath, '.metadata.json');
+
+  // Find the content file referenced by @filename
+  const contentCols = meta._contentColumns || [];
+  let contentFileName = null;
+  for (const col of contentCols) {
+    const ref = meta[col];
+    if (ref && ref.startsWith('@')) {
+      contentFileName = ref.substring(1);
+      break;
+    }
+  }
+
+  if (!contentFileName) return;
+
+  // Compute the current path based on where the file actually is
+  const currentFilePath = join(metaDir, contentFileName);
+  const currentRelPath = relative(process.cwd(), currentFilePath);
+
+  // Normalize stored path for comparison
+  const storedPath = String(meta.Path).replace(/^\/+|\/+$/g, '');
+  const currentPath = currentRelPath.replace(/\\/g, '/');
+
+  if (storedPath === currentPath) return;
+
+  // Path mismatch detected
+  log.warn(`Path mismatch for "${metaBase}":`);
+  log.label('  Metadata Path', storedPath);
+  log.label('  Current path ', currentPath);
+
+  let updatePath = options.yes;
+  if (!updatePath) {
+    const inquirer = (await import('inquirer')).default;
+    const { confirm } = await inquirer.prompt([{
+      type: 'confirm',
+      name: 'confirm',
+      message: `Update Path column to "${currentPath}"?`,
+      default: true,
+    }]);
+    updatePath = confirm;
+  }
+
+  if (updatePath) {
+    meta.Path = currentPath;
+    // Write updated metadata back to disk
+    await writeFile(join(dirname(metaPath), basename(metaPath)), JSON.stringify(meta, null, 2) + '\n');
+    log.success(`  Path updated to "${currentPath}"`);
+  }
+}
+
+/**
+ * Recursively find all .metadata.json files in a directory
+ */
+async function findMetadataFiles(dir) {
+  const results = [];
+  const entries = await readdir(dir, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const fullPath = join(dir, entry.name);
+    if (entry.isDirectory()) {
+      results.push(...await findMetadataFiles(fullPath));
+    } else if (entry.name.endsWith('.metadata.json')) {
+      results.push(fullPath);
+    }
+  }
+
+  return results;
+}

package/src/commands/status.js

@@ -0,0 +1,41 @@
+import { Command } from 'commander';
+import { loadConfig, isInitialized, getActiveCookiesPath, loadUserInfo } from '../lib/config.js';
+import { loadCookies } from '../lib/cookie-jar.js';
+import { log } from '../lib/logger.js';
+
+export const statusCommand = new Command('status')
+  .description('Show current DBO CLI configuration and session status')
+  .action(async () => {
+    try {
+      const initialized = await isInitialized();
+      const config = await loadConfig();
+
+      log.label('Initialized', initialized ? 'Yes (.dbo/)' : 'No');
+      log.label('Domain', config.domain || '(not set)');
+      log.label('Username', config.username || '(not set)');
+      const userInfo = await loadUserInfo();
+      log.label('User ID', userInfo.userId || '(not set)');
+      log.label('User UID', userInfo.userUid || '(not set — run "dbo login")');
+      log.label('Directory', process.cwd());
+
+      const cookiesPath = await getActiveCookiesPath();
+      const cookies = await loadCookies(cookiesPath);
+      if (cookies.length > 0) {
+        const sessionCookie = cookies.find(c => c.name.startsWith('dboioSession') || c.name.startsWith('ASP.NET'));
+        if (sessionCookie) {
+          const expires = sessionCookie.expiry > 0
+            ? new Date(sessionCookie.expiry * 1000).toISOString()
+            : 'session';
+          log.label('Session', `Active (expires: ${expires})`);
+        } else {
+          log.label('Session', `${cookies.length} cookie(s) stored`);
+        }
+        log.label('Cookies', cookiesPath);
+      } else {
+        log.label('Session', 'No active session. Run "dbo login".');
+      }
+    } catch (err) {
+      log.error(err.message);
+      process.exit(1);
+    }
+  });

package/src/commands/update.js

@@ -0,0 +1,168 @@
+import { Command } from 'commander';
+import { readdir, readFile, copyFile, access, mkdir } from 'fs/promises';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { execSync } from 'child_process';
+import { createHash } from 'crypto';
+import { installClaudeCommands } from './install.js';
+import { log } from '../lib/logger.js';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const CLI_ROOT = join(__dirname, '..', '..');
+const PLUGINS_DIR = join(__dirname, '..', 'plugins', 'claudecommands');
+
+async function fileExists(path) {
+  try { await access(path); return true; } catch { return false; }
+}
+
+function fileHash(content) {
+  return createHash('md5').update(content).digest('hex');
+}
+
+export const updateCommand = new Command('update')
+  .description('Update dbo-cli, plugins, or Claude Code commands')
+  .argument('[target]', 'What to update: cli, plugins, claudecommands')
+  .option('--claudecommand <name>', 'Update a specific Claude command by name')
+  .action(async (target, options) => {
+    try {
+      if (options.claudecommand) {
+        await updateSpecificCommand(options.claudecommand);
+      } else if (target === 'cli') {
+        await updateCli();
+      } else if (target === 'plugins') {
+        await updatePlugins();
+      } else if (target === 'claudecommands') {
+        await updateClaudeCommands();
+      } else {
+        // No target: update CLI + ask about claude commands
+        await updateCli();
+        const inquirer = (await import('inquirer')).default;
+        const { updateCmds } = await inquirer.prompt([{
+          type: 'confirm', name: 'updateCmds',
+          message: 'Also update Claude Code commands?',
+          default: true,
+        }]);
+        if (updateCmds) await updateClaudeCommands();
+      }
+    } catch (err) {
+      log.error(err.message);
+      process.exit(1);
+    }
+  });
+
+async function updateCli() {
+  // Detect install method: git repo or npm global
+  const isGitRepo = await fileExists(join(CLI_ROOT, '.git'));
+  const isInNodeModules = CLI_ROOT.includes('node_modules');
+
+  if (isGitRepo && !isInNodeModules) {
+    log.info('Updating dbo-cli from git...');
+    try {
+      execSync('git pull', { cwd: CLI_ROOT, stdio: 'inherit' });
+      execSync('npm install', { cwd: CLI_ROOT, stdio: 'inherit' });
+      log.success('dbo-cli updated from git');
+    } catch (err) {
+      log.error(`Git update failed: ${err.message}`);
+    }
+  } else {
+    log.info('Updating dbo-cli via npm...');
+    try {
+      execSync('npm update -g @dboio/cli', { stdio: 'inherit' });
+      log.success('dbo-cli updated via npm');
+    } catch (err) {
+      log.error(`npm update failed: ${err.message}`);
+    }
+  }
+
+  // Show current version
+  try {
+    const pkg = JSON.parse(await readFile(join(CLI_ROOT, 'package.json'), 'utf8'));
+    log.label('Version', pkg.version);
+  } catch { /* ignore */ }
+}
+
+async function updatePlugins() {
+  log.info('Updating all plugins...');
+  await updateClaudeCommands();
+}
+
+async function updateClaudeCommands() {
+  const commandsDir = join(process.cwd(), '.claude', 'commands');
+
+  if (!await fileExists(commandsDir)) {
+    log.info('No .claude/commands/ directory found. Installing...');
+    await installClaudeCommands();
+    return;
+  }
+
+  let pluginFiles;
+  try {
+    pluginFiles = (await readdir(PLUGINS_DIR)).filter(f => f.endsWith('.md'));
+  } catch {
+    log.error(`Plugin source not found: ${PLUGINS_DIR}`);
+    return;
+  }
+
+  let updated = 0;
+  let upToDate = 0;
+
+  for (const file of pluginFiles) {
+    const srcPath = join(PLUGINS_DIR, file);
+    const destPath = join(commandsDir, file);
+
+    const srcContent = await readFile(srcPath, 'utf8');
+
+    if (await fileExists(destPath)) {
+      const destContent = await readFile(destPath, 'utf8');
+      if (fileHash(srcContent) === fileHash(destContent)) {
+        upToDate++;
+        continue;
+      }
+      await copyFile(srcPath, destPath);
+      log.success(`Updated .claude/commands/${file}`);
+      updated++;
+    } else {
+      await copyFile(srcPath, destPath);
+      log.success(`Installed .claude/commands/${file} (new)`);
+      updated++;
+    }
+  }
+
+  if (updated > 0) {
+    log.info(`${updated} command(s) updated`);
+    log.warn('Note: Updated commands will be available in new Claude Code sessions (restart any active session).');
+  }
+  if (upToDate > 0) {
+    log.dim(`${upToDate} command(s) already up to date`);
+  }
+}
+
+async function updateSpecificCommand(name) {
+  const fileName = name.endsWith('.md') ? name : `${name}.md`;
+  const srcPath = join(PLUGINS_DIR, fileName);
+  const destPath = join(process.cwd(), '.claude', 'commands', fileName);
+
+  if (!await fileExists(srcPath)) {
+    log.error(`Command plugin "${name}" not found in source`);
+    const available = (await readdir(PLUGINS_DIR)).filter(f => f.endsWith('.md')).map(f => f.replace('.md', ''));
+    if (available.length > 0) log.dim(`  Available: ${available.join(', ')}`);
+    return;
+  }
+
+  if (!await fileExists(destPath)) {
+    log.warn(`"${fileName}" not installed. Run "dbo install --claudecommand ${name}" first.`);
+    return;
+  }
+
+  const srcContent = await readFile(srcPath, 'utf8');
+  const destContent = await readFile(destPath, 'utf8');
+
+  if (fileHash(srcContent) === fileHash(destContent)) {
+    log.success(`${fileName} is already up to date`);
+    return;
+  }
+
+  await copyFile(srcPath, destPath);
+  log.success(`Updated .claude/commands/${fileName}`);
+  log.warn('Note: Updated commands will be available in new Claude Code sessions (restart any active session).');
+}

package/src/commands/upload.js

@@ -0,0 +1,37 @@
+import { Command } from 'commander';
+import { basename } from 'path';
+import { DboClient } from '../lib/client.js';
+import { formatResponse, formatError } from '../lib/formatter.js';
+
+export const uploadCommand = new Command('upload')
+  .description('Upload a file to DBO.io')
+  .argument('<filepath>', 'Local file to upload')
+  .requiredOption('--bin <id>', 'BinID')
+  .requiredOption('--app <id>', 'AppID')
+  .requiredOption('--ownership <type>', 'Ownership: app, user, or system')
+  .requiredOption('--path <dir>', 'Media path')
+  .option('--name <value>', 'Override filename')
+  .option('-C, --confirm <value>', 'Commit: true (default) or false', 'true')
+  .option('--json', 'Output raw JSON')
+  .option('-v, --verbose', 'Show HTTP request details')
+  .option('--domain <host>', 'Override domain')
+  .action(async (filepath, options) => {
+    try {
+      const client = new DboClient({ domain: options.domain, verbose: options.verbose });
+      const fileName = options.name || basename(filepath);
+      const fields = {
+        'RowID:add1;column:media.BinID': options.bin,
+        'RowID:add1;column:media.AppID': options.app,
+        'RowID:add1;column:media.Ownership': options.ownership,
+        'RowID:add1;column:media.Path': options.path,
+        '_confirm': options.confirm,
+      };
+      const files = [{ fieldName: 'file', filePath: filepath, fileName }];
+      const result = await client.postMultipart('/api/input/submit', fields, files);
+      formatResponse(result, { json: options.json });
+      if (!result.successful) process.exit(1);
+    } catch (err) {
+      formatError(err);
+      process.exit(1);
+    }
+  });