@dboio/cli 0.4.1

package/src/commands/content.js

@@ -0,0 +1,143 @@
+import { Command } from 'commander';
+import { writeFile } from 'fs/promises';
+import chalk from 'chalk';
+import { DboClient } from '../lib/client.js';
+import { buildInputBody } from '../lib/input-parser.js';
+import { formatResponse, formatError } from '../lib/formatter.js';
+import { saveToDisk } from '../lib/save-to-disk.js';
+import { log } from '../lib/logger.js';
+
+function collect(value, previous) {
+  return previous.concat([value]);
+}
+
+export const contentCommand = new Command('content')
+  .description('Get, deploy, or pull content from DBO.io')
+  .argument('[uid]', 'Content UID')
+  .option('-o, --output <path>', 'Save content to local file')
+  .option('--format <type>', 'Output format')
+  .option('--no-minify', 'Disable minification')
+  .option('--json', 'Output raw JSON')
+  .option('-v, --verbose', 'Show HTTP request details')
+  .option('--domain <host>', 'Override domain');
+
+// Subcommand: dbo content deploy <uid> <filepath>
+const deployCmd = new Command('deploy')
+  .description('Deploy a local file to a DBO content record')
+  .argument('<uid>', 'Content UID (RowUID)')
+  .argument('<filepath>', 'Local file path')
+  .option('-C, --confirm <value>', 'Commit: true (default) or false', 'true')
+  .option('--ticket <id>', 'Override ticket ID')
+  .option('--json', 'Output raw JSON')
+  .option('-v, --verbose', 'Show HTTP request details')
+  .option('--domain <host>', 'Override domain')
+  .action(async (uid, filepath, options) => {
+    try {
+      const client = new DboClient({ domain: options.domain, verbose: options.verbose });
+      const extraParams = { '_confirm': options.confirm };
+      if (options.ticket) extraParams['_OverrideTicketID'] = options.ticket;
+      const body = await buildInputBody([`RowUID:${uid};column:content.Content@${filepath}`], extraParams);
+      const result = await client.postUrlEncoded('/api/input/submit', body);
+      formatResponse(result, { json: options.json });
+      if (!result.successful) process.exit(1);
+    } catch (err) {
+      formatError(err);
+      process.exit(1);
+    }
+  });
+
+// Subcommand: dbo content pull [uid] [--filter]
+const pullCmd = new Command('pull')
+  .description('Pull content records to local files (uses content entity defaults)')
+  .argument('[uid]', 'Content UID (optional, pull single record)')
+  .option('--filter <expr>', 'Filter expression (repeatable)', collect, [])
+  .option('--maxrows <n>', 'Maximum rows')
+  .option('--json', 'Output raw JSON')
+  .option('-v, --verbose', 'Show HTTP request details')
+  .option('--domain <host>', 'Override domain')
+  .action(async (uid, options) => {
+    try {
+      const client = new DboClient({ domain: options.domain, verbose: options.verbose });
+      const params = { '_format': 'json_raw' };
+      if (options.maxrows) params['_maxrows'] = options.maxrows;
+
+      for (const f of options.filter) {
+        const atIdx = f.indexOf('=');
+        if (atIdx !== -1) {
+          const key = f.substring(0, atIdx);
+          const value = f.substring(atIdx + 1);
+          params[`_filter@${key}`] = value;
+        }
+      }
+
+      let path;
+      if (uid) {
+        path = `/api/output/entity/content/${uid}`;
+      } else {
+        path = '/api/output/entity/content';
+      }
+
+      const result = await client.get(path, params);
+
+      log.success(`Pulled from ${chalk.underline(result.url || '')}`);
+
+      const data = result.payload || result.data;
+
+      if (data && data.raw && typeof data.raw === 'string') {
+        log.error('Received non-JSON response. Check the content UID.');
+        process.exit(1);
+      }
+
+      const rows = Array.isArray(data) ? data : (data?.Rows || data?.rows || [data]);
+
+      if (rows.length === 0) {
+        log.warn('No content records found.');
+        return;
+      }
+
+      log.info(`${rows.length} record(s) to save`);
+
+      const columns = Object.keys(rows[0]);
+      await saveToDisk(rows, columns, {
+        entity: 'content',
+        saveFilename: columns.includes('Name') ? 'Name' : 'UID',
+        savePath: columns.includes('Path') ? 'Path' : null,
+        saveContent: columns.includes('Content') ? 'Content' : null,
+        saveExtension: columns.includes('Extension') ? 'Extension' : null,
+        nonInteractive: false,
+      });
+    } catch (err) {
+      formatError(err);
+      process.exit(1);
+    }
+  });
+
+contentCommand.addCommand(deployCmd);
+contentCommand.addCommand(pullCmd);
+
+// Default action: get content
+contentCommand.action(async (uid, options) => {
+  try {
+    if (!uid) {
+      console.error('Error: provide a content UID or use a subcommand (deploy, pull)');
+      process.exit(1);
+    }
+    const client = new DboClient({ domain: options.domain, verbose: options.verbose });
+    const params = {};
+    if (options.format) params['_format'] = options.format;
+    if (options.noMinify) params['_no_minify'] = 'true';
+
+    const result = await client.get(`/api/content/${uid}`, params);
+
+    if (options.output) {
+      const text = typeof result.data === 'string' ? result.data : (result.data?.raw || JSON.stringify(result.data, null, 2));
+      await writeFile(options.output, text);
+      log.success(`Saved to ${options.output}`);
+    } else {
+      formatResponse(result, { json: options.json });
+    }
+  } catch (err) {
+    formatError(err);
+    process.exit(1);
+  }
+});

package/src/commands/deploy.js

@@ -0,0 +1,89 @@
+import { Command } from 'commander';
+import { readFile } from 'fs/promises';
+import { DboClient } from '../lib/client.js';
+import { buildInputBody } from '../lib/input-parser.js';
+import { formatResponse, formatError } from '../lib/formatter.js';
+import { log } from '../lib/logger.js';
+
+const MANIFEST_FILE = 'dbo.deploy.json';
+
+export const deployCommand = new Command('deploy')
+  .description('Deploy files to DBO.io using a manifest or direct arguments')
+  .argument('[name]', 'Deployment name from dbo.deploy.json (e.g., css:colors)')
+  .option('--all', 'Deploy all entries in the manifest')
+  .option('-C, --confirm <value>', 'Commit: true (default) or false', 'true')
+  .option('--ticket <id>', 'Override ticket ID')
+  .option('--json', 'Output raw JSON')
+  .option('-v, --verbose', 'Show HTTP request details')
+  .option('--domain <host>', 'Override domain')
+  .action(async (name, options) => {
+    try {
+      const client = new DboClient({ domain: options.domain, verbose: options.verbose });
+
+      // Load manifest
+      let manifest;
+      try {
+        const raw = await readFile(MANIFEST_FILE, 'utf8');
+        manifest = JSON.parse(raw);
+      } catch {
+        if (!name) {
+          log.error(`No ${MANIFEST_FILE} found and no deployment name specified.`);
+          log.dim('  Create a dbo.deploy.json or use: dbo content deploy <uid> <filepath>');
+          process.exit(1);
+        }
+      }
+
+      if (!manifest?.deployments) {
+        log.error(`Invalid ${MANIFEST_FILE}: missing "deployments" key.`);
+        process.exit(1);
+      }
+
+      const entries = options.all
+        ? Object.entries(manifest.deployments)
+        : name
+          ? [[name, manifest.deployments[name]]]
+          : [];
+
+      if (entries.length === 0 || (entries.length === 1 && !entries[0][1])) {
+        const available = Object.keys(manifest.deployments).join(', ');
+        log.error(name ? `Deployment "${name}" not found in manifest.` : 'No deployment specified.');
+        log.dim(`  Available: ${available}`);
+        process.exit(1);
+      }
+
+      for (const [entryName, entry] of entries) {
+        if (!entry) {
+          log.warn(`Skipping unknown deployment: ${entryName}`);
+          continue;
+        }
+
+        const entity = entry.entity || 'content';
+        const column = entry.column || 'Content';
+        const uid = entry.uid;
+        const file = entry.file;
+
+        if (!uid || !file) {
+          log.warn(`Skipping "${entryName}": missing uid or file.`);
+          continue;
+        }
+
+        log.info(`Deploying ${entryName}: ${file} → ${entity}.${column} (${uid})`);
+
+        const extraParams = { '_confirm': options.confirm };
+        if (options.ticket) extraParams['_OverrideTicketID'] = options.ticket;
+        const body = await buildInputBody([`RowUID:${uid};column:${entity}.${column}@${file}`], extraParams);
+        const result = await client.postUrlEncoded('/api/input/submit', body);
+
+        if (result.successful) {
+          log.success(`${entryName} deployed`);
+        } else {
+          log.error(`${entryName} failed`);
+          for (const msg of result.messages) log.label('Message', msg);
+          if (!options.all) process.exit(1);
+        }
+      }
+    } catch (err) {
+      formatError(err);
+      process.exit(1);
+    }
+  });

package/src/commands/init.js

@@ -0,0 +1,105 @@
+import { Command } from 'commander';
+import { access } from 'fs/promises';
+import { join } from 'path';
+import { isInitialized, hasLegacyConfig, readLegacyConfig, initConfig, saveCredentials, ensureGitignore } from '../lib/config.js';
+import { installClaudeCommands } from './install.js';
+import { log } from '../lib/logger.js';
+
+export const initCommand = new Command('init')
+  .description('Initialize DBO CLI configuration for the current directory')
+  .option('--domain <host>', 'DBO instance domain (e.g., beta-dev_model.dbo.io)')
+  .option('--username <user>', 'DBO username')
+  .option('--force', 'Overwrite existing configuration')
+  .option('--app <shortName>', 'App short name (for clone)')
+  .option('--clone', 'Clone the app after initialization')
+  .action(async (options) => {
+    try {
+      if (await isInitialized() && !options.force) {
+        log.warn('Already initialized. Use --force to overwrite.');
+        return;
+      }
+
+      let domain = options.domain;
+      let username = options.username;
+
+      // Check for legacy config to offer migration
+      if (!domain && await hasLegacyConfig()) {
+        const legacy = await readLegacyConfig();
+        log.info('Legacy configuration detected (.domain, .username, .password)');
+        const inquirer = (await import('inquirer')).default;
+        const { migrate } = await inquirer.prompt([{
+          type: 'confirm',
+          name: 'migrate',
+          message: `Migrate from legacy config? Domain: ${legacy.domain || '(none)'}`,
+          default: true,
+        }]);
+        if (migrate) {
+          domain = legacy.domain;
+          username = legacy.username;
+        }
+      }
+
+      // Interactive prompts for missing values
+      if (!domain || !username) {
+        const inquirer = (await import('inquirer')).default;
+        const answers = await inquirer.prompt([
+          { type: 'input', name: 'domain', message: 'Domain (e.g., myapp.dbo.io):', default: domain || undefined, when: !domain, validate: v => v ? true : 'Domain is required' },
+          { type: 'input', name: 'username', message: 'Username (email):', when: !username },
+        ]);
+        domain = domain || answers.domain;
+        username = username || answers.username;
+      }
+
+      await initConfig(domain);
+      if (username) {
+        await saveCredentials(username);
+      }
+
+      // Ensure sensitive files are gitignored
+      await ensureGitignore(['.dbo/credentials.json', '.dbo/cookies.txt']);
+
+      log.success(`Initialized .dbo/ for ${domain}`);
+      log.dim('  Run "dbo login" to authenticate.');
+
+      // Clone if requested
+      if (options.clone || options.app) {
+        let appShortName = options.app;
+        if (!appShortName) {
+          const inq = (await import('inquirer')).default;
+          const { appName } = await inq.prompt([{
+            type: 'input', name: 'appName',
+            message: 'App short name to clone:',
+            validate: v => v.trim() ? true : 'App short name is required',
+          }]);
+          appShortName = appName;
+        }
+        const { performClone } = await import('./clone.js');
+        await performClone(null, { app: appShortName, domain });
+      }
+
+      // Offer Claude Code integration
+      const claudeDir = join(process.cwd(), '.claude');
+      const inquirer = (await import('inquirer')).default;
+      let hasClaudeDir = false;
+      try { await access(claudeDir); hasClaudeDir = true; } catch {}
+
+      if (hasClaudeDir) {
+        const { installCmds } = await inquirer.prompt([{
+          type: 'confirm', name: 'installCmds',
+          message: 'Install DBO commands for Claude Code? (adds /dbo slash command)',
+          default: true,
+        }]);
+        if (installCmds) await installClaudeCommands();
+      } else {
+        const { setupClaude } = await inquirer.prompt([{
+          type: 'confirm', name: 'setupClaude',
+          message: 'Set up Claude Code integration? (creates .claude/commands/)',
+          default: false,
+        }]);
+        if (setupClaude) await installClaudeCommands();
+      }
+    } catch (err) {
+      log.error(err.message);
+      process.exit(1);
+    }
+  });

package/src/commands/input.js

@@ -0,0 +1,111 @@
+import { Command } from 'commander';
+import { DboClient } from '../lib/client.js';
+import { buildInputBody, parseFileArg, checkSubmitErrors } from '../lib/input-parser.js';
+import { formatResponse, formatError } from '../lib/formatter.js';
+import { loadAppConfig } from '../lib/config.js';
+import { log } from '../lib/logger.js';
+
+function collect(value, previous) {
+  return previous.concat([value]);
+}
+
+export const inputCommand = new Command('input')
+  .description('Submit CRUD operations to DBO.io (add, edit, delete records)')
+  .requiredOption('-d, --data <expr>', 'DBO input expression (repeatable)', collect, [])
+  .option('-f, --file <field=@path>', 'File attachment for multipart upload (repeatable)', collect, [])
+  .option('-C, --confirm <value>', 'Commit changes: true (default) or false for validation only', 'true')
+  .option('--ticket <id>', 'Override ticket ID (_OverrideTicketID)')
+  .option('--login', 'Auto-login user created by this submission')
+  .option('--transactional', 'Use transactional processing')
+  .option('--json', 'Output raw JSON response')
+  .option('--jq <expr>', 'Filter JSON response with jq-like expression (implies --json)')
+  .option('-v, --verbose', 'Show HTTP request details')
+  .option('--domain <host>', 'Override domain')
+  .action(async (options) => {
+    try {
+      const client = new DboClient({ domain: options.domain, verbose: options.verbose });
+
+      const extraParams = {};
+      extraParams['_confirm'] = options.confirm;
+      if (options.ticket) extraParams['_OverrideTicketID'] = options.ticket;
+      if (options.login) extraParams['_login'] = 'true';
+      if (options.transactional) extraParams['_transactional'] = 'true';
+
+      // Check if data expressions include AppID; if not and config has one, prompt
+      const allDataText = options.data.join(' ');
+      const hasAppId = /\.AppID[=@]/.test(allDataText) || /AppID=/.test(allDataText);
+      if (!hasAppId) {
+        const appConfig = await loadAppConfig();
+        if (appConfig.AppID) {
+          const inquirer = (await import('inquirer')).default;
+          const { appIdChoice } = await inquirer.prompt([{
+            type: 'list',
+            name: 'appIdChoice',
+            message: `You're submitting data without an AppID, but your config has information about the current App. Do you want me to add that Column information along with your submission?`,
+            choices: [
+              { name: `Yes, use AppID ${appConfig.AppID}`, value: 'use_config' },
+              { name: 'No', value: 'none' },
+              { name: 'Enter custom AppID', value: 'custom' },
+            ],
+          }]);
+          if (appIdChoice === 'use_config') {
+            extraParams['AppID'] = String(appConfig.AppID);
+            log.dim(`  Using AppID ${appConfig.AppID} from config`);
+          } else if (appIdChoice === 'custom') {
+            const { customAppId } = await inquirer.prompt([{
+              type: 'input', name: 'customAppId',
+              message: 'Custom AppID:',
+            }]);
+            if (customAppId.trim()) extraParams['AppID'] = customAppId.trim();
+          }
+        }
+      }
+
+      if (options.file.length > 0) {
+        // Multipart mode
+        const fields = { ...extraParams };
+        // Parse data expressions into flat key-value pairs for form fields
+        for (const expr of options.data) {
+          for (const op of expr.split('&')) {
+            const trimmed = op.trim();
+            const eqIdx = trimmed.indexOf('=');
+            if (eqIdx !== -1) {
+              fields[trimmed.substring(0, eqIdx)] = trimmed.substring(eqIdx + 1);
+            } else {
+              fields[trimmed] = '';
+            }
+          }
+        }
+        const files = options.file.map(parseFileArg);
+        let result = await client.postMultipart('/api/input/submit', fields, files);
+
+        // Retry with prompted params if needed (ticket, user)
+        const retryParams = await checkSubmitErrors(result);
+        if (retryParams) {
+          Object.assign(fields, retryParams);
+          result = await client.postMultipart('/api/input/submit', fields, files);
+        }
+
+        formatResponse(result, { json: options.json, jq: options.jq });
+        if (!result.successful) process.exit(1);
+      } else {
+        // URL-encoded mode
+        let body = await buildInputBody(options.data, 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(options.data, extraParams);
+          result = await client.postUrlEncoded('/api/input/submit', body);
+        }
+
+        formatResponse(result, { json: options.json, jq: options.jq });
+        if (!result.successful) process.exit(1);
+      }
+    } catch (err) {
+      formatError(err);
+      process.exit(1);
+    }
+  });

package/src/commands/install.js

@@ -0,0 +1,186 @@
+import { Command } from 'commander';
+import { readdir, readFile, writeFile, mkdir, access, copyFile } from 'fs/promises';
+import { join, dirname, basename } from 'path';
+import { fileURLToPath } from 'url';
+import { execSync } from 'child_process';
+import { log } from '../lib/logger.js';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const PLUGINS_DIR = join(__dirname, '..', 'plugins', 'claudecommands');
+
+async function fileExists(path) {
+  try { await access(path); return true; } catch { return false; }
+}
+
+export const installCommand = new Command('install')
+  .description('Install dbo-cli components (Claude Code commands, plugins)')
+  .argument('[target]', 'What to install: claudecode, claudecommands')
+  .option('--claudecommand <name>', 'Install a specific Claude command by name')
+  .action(async (target, options) => {
+    try {
+      if (options.claudecommand) {
+        await installSpecificCommand(options.claudecommand);
+      } else if (target === 'claudecode') {
+        await installClaudeCode();
+      } else if (target === 'claudecommands') {
+        await installClaudeCommands();
+      } else {
+        // Interactive
+        const inquirer = (await import('inquirer')).default;
+        const { choice } = await inquirer.prompt([{
+          type: 'list', name: 'choice',
+          message: 'What would you like to install?',
+          choices: [
+            'Claude Code commands (adds /dbo to Claude Code)',
+            'Claude Code CLI + commands',
+          ],
+        }]);
+        if (choice.includes('CLI')) {
+          await installClaudeCode();
+        } else {
+          await installClaudeCommands();
+        }
+      }
+    } catch (err) {
+      log.error(err.message);
+      process.exit(1);
+    }
+  });
+
+async function installClaudeCode() {
+  // Check if claude is installed
+  try {
+    const version = execSync('claude --version 2>&1', { encoding: 'utf8' }).trim();
+    log.success(`Claude Code already installed: ${version}`);
+  } catch {
+    log.info('Claude Code not found. Installing...');
+    try {
+      execSync('npm install -g @anthropic-ai/claude-code', { stdio: 'inherit' });
+      log.success('Claude Code installed');
+    } catch (err) {
+      log.error('Failed to install Claude Code. Try manually: npm install -g @anthropic-ai/claude-code');
+      return;
+    }
+  }
+
+  // Then install commands
+  await installClaudeCommands();
+}
+
+export async function installClaudeCommands() {
+  const cwd = process.cwd();
+  const claudeDir = join(cwd, '.claude');
+  const commandsDir = join(claudeDir, 'commands');
+
+  // Check/create .claude/commands/
+  if (!await fileExists(claudeDir)) {
+    const inquirer = (await import('inquirer')).default;
+    const { create } = await inquirer.prompt([{
+      type: 'confirm', name: 'create',
+      message: 'No .claude/ directory found. Create it for Claude Code integration?',
+      default: true,
+    }]);
+    if (!create) {
+      log.dim('Skipped Claude Code setup.');
+      return;
+    }
+  }
+  await mkdir(commandsDir, { recursive: true });
+
+  // Find all plugin source files
+  let pluginFiles;
+  try {
+    pluginFiles = (await readdir(PLUGINS_DIR)).filter(f => f.endsWith('.md'));
+  } catch {
+    log.error(`Plugin source directory not found: ${PLUGINS_DIR}`);
+    return;
+  }
+
+  if (pluginFiles.length === 0) {
+    log.warn('No Claude command plugins found in source.');
+    return;
+  }
+
+  let installed = 0;
+  for (const file of pluginFiles) {
+    const srcPath = join(PLUGINS_DIR, file);
+    const destPath = join(commandsDir, file);
+
+    // Check for existing file
+    if (await fileExists(destPath)) {
+      const inquirer = (await import('inquirer')).default;
+      const { overwrite } = await inquirer.prompt([{
+        type: 'confirm', name: 'overwrite',
+        message: `Overwrite existing .claude/commands/${file}?`,
+        default: false,
+      }]);
+      if (!overwrite) {
+        log.dim(`  Skipped ${file}`);
+        continue;
+      }
+    }
+
+    await copyFile(srcPath, destPath);
+    log.success(`Installed .claude/commands/${file}`);
+    installed++;
+
+    // Add to .gitignore
+    await addToGitignore(cwd, `.claude/commands/${file}`);
+  }
+
+  if (installed > 0) {
+    log.info(`${installed} Claude command(s) installed. Use /dbo in Claude Code.`);
+    log.warn('Note: Commands will be available in new Claude Code sessions (restart any active session).');
+  } else {
+    log.dim('No commands installed.');
+  }
+}
+
+async function installSpecificCommand(name) {
+  const fileName = name.endsWith('.md') ? name : `${name}.md`;
+  const srcPath = join(PLUGINS_DIR, fileName);
+
+  if (!await fileExists(srcPath)) {
+    log.error(`Command plugin "${name}" not found in ${PLUGINS_DIR}`);
+    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;
+  }
+
+  const commandsDir = join(process.cwd(), '.claude', 'commands');
+  await mkdir(commandsDir, { recursive: true });
+
+  const destPath = join(commandsDir, fileName);
+
+  if (await fileExists(destPath)) {
+    const inquirer = (await import('inquirer')).default;
+    const { overwrite } = await inquirer.prompt([{
+      type: 'confirm', name: 'overwrite',
+      message: `Overwrite existing .claude/commands/${fileName}?`,
+      default: false,
+    }]);
+    if (!overwrite) return;
+  }
+
+  await copyFile(srcPath, destPath);
+  log.success(`Installed .claude/commands/${fileName}`);
+  log.warn('Note: Commands will be available in new Claude Code sessions (restart any active session).');
+  await addToGitignore(process.cwd(), `.claude/commands/${fileName}`);
+}
+
+async function addToGitignore(projectDir, pattern) {
+  const gitignorePath = join(projectDir, '.gitignore');
+  let content = '';
+  try {
+    content = await readFile(gitignorePath, 'utf8');
+  } catch { /* no .gitignore yet */ }
+
+  if (content.includes(pattern)) return; // already there
+
+  const addition = content.endsWith('\n') || content === ''
+    ? `\n# DBO CLI Claude Code commands (managed by dbo-cli)\n${pattern}\n`
+    : `\n\n# DBO CLI Claude Code commands (managed by dbo-cli)\n${pattern}\n`;
+
+  await writeFile(gitignorePath, content + addition);
+  log.dim(`  Added ${pattern} to .gitignore`);
+}

package/src/commands/instance.js

@@ -0,0 +1,44 @@
+import { Command } from 'commander';
+import { DboClient } from '../lib/client.js';
+import { formatResponse, formatError } from '../lib/formatter.js';
+
+export const instanceCommand = new Command('instance')
+  .description('Manage DBO.io instances');
+
+instanceCommand
+  .command('export')
+  .description('Export the current instance')
+  .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 (options) => {
+    try {
+      const client = new DboClient({ domain: options.domain, verbose: options.verbose });
+      const result = await client.postUrlEncoded('/api/instance/export', `_confirm=${options.confirm}`);
+      formatResponse(result, { json: options.json });
+      if (!result.successful) process.exit(1);
+    } catch (err) {
+      formatError(err);
+      process.exit(1);
+    }
+  });
+
+instanceCommand
+  .command('build <uid>')
+  .description('Build an instance from a pending instance UID')
+  .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 (uid, options) => {
+    try {
+      const client = new DboClient({ domain: options.domain, verbose: options.verbose });
+      const result = await client.postUrlEncoded(`/api/instance/build/${uid}`, `_confirm=${options.confirm}`);
+      formatResponse(result, { json: options.json });
+      if (!result.successful) process.exit(1);
+    } catch (err) {
+      formatError(err);
+      process.exit(1);
+    }
+  });