@dboio/cli 0.4.1

package/src/lib/client.js

@@ -0,0 +1,161 @@
+import { readFile } from 'fs/promises';
+import { loadConfig, getActiveCookiesPath, getCookiesPath } from './config.js';
+import { loadCookies, buildCookieHeader, parseSetCookieHeaders, saveCookies, mergeCookies } from './cookie-jar.js';
+import { log } from './logger.js';
+
+export class DboClient {
+  constructor(options = {}) {
+    this.domainOverride = options.domain || null;
+    this.verbose = options.verbose || false;
+    this._config = null;
+    this._cookiesPath = null;
+  }
+
+  async getConfig() {
+    if (!this._config) this._config = await loadConfig();
+    return this._config;
+  }
+
+  async getDomain() {
+    if (this.domainOverride) return this.domainOverride;
+    const config = await this.getConfig();
+    if (!config.domain) {
+      throw new Error('No domain configured. Run "dbo init" first.');
+    }
+    return config.domain;
+  }
+
+  async getBaseUrl() {
+    const domain = await this.getDomain();
+    return `https://${domain}`;
+  }
+
+  async getCookiesPath() {
+    if (!this._cookiesPath) this._cookiesPath = await getActiveCookiesPath();
+    return this._cookiesPath;
+  }
+
+  async request(path, options = {}) {
+    const baseUrl = await this.getBaseUrl();
+    let url = `${baseUrl}${path}`;
+    const cookiesPath = await this.getCookiesPath();
+    let cookies = await loadCookies(cookiesPath);
+
+    const maxRedirects = 5;
+    for (let attempt = 0; attempt <= maxRedirects; attempt++) {
+      const headers = { ...options.headers };
+      const cookieHeader = buildCookieHeader(cookies, url);
+      if (cookieHeader) headers['Cookie'] = cookieHeader;
+
+      if (this.verbose) {
+        log.verbose(`${options.method || 'GET'} ${url}`);
+        if (options.body && typeof options.body === 'string') {
+          log.verbose(`Body: ${options.body.substring(0, 200)}${options.body.length > 200 ? '...' : ''}`);
+        }
+      }
+
+      const response = await fetch(url, { ...options, headers, redirect: 'manual' });
+
+      // Persist any Set-Cookie headers
+      const newCookies = parseSetCookieHeaders(response.headers, url);
+      if (newCookies.length > 0) {
+        cookies = mergeCookies(cookies, newCookies);
+        const savePath = getCookiesPath().dbo;
+        await saveCookies(savePath, cookies);
+        this._cookiesPath = savePath;
+      }
+
+      // Handle redirects manually to preserve cookies across domains
+      if (response.status >= 300 && response.status < 400) {
+        const location = response.headers.get('location');
+        if (!location) return response;
+        // Resolve relative redirects
+        url = location.startsWith('http') ? location : new URL(location, url).toString();
+        if (this.verbose) {
+          log.verbose(`Redirect ${response.status} → ${url}`);
+        }
+        continue;
+      }
+
+      // Attach the final URL to the response for display purposes
+      response._finalUrl = url;
+      return response;
+    }
+
+    throw new Error(`Too many redirects (>${maxRedirects})`);
+  }
+
+  async get(path, params = {}) {
+    const query = new URLSearchParams();
+    for (const [key, values] of Object.entries(params)) {
+      const arr = Array.isArray(values) ? values : [values];
+      for (const v of arr) {
+        if (v !== undefined && v !== null) query.append(key, v);
+      }
+    }
+    const qs = query.toString();
+    const fullPath = qs ? `${path}?${qs}` : path;
+    const response = await this.request(fullPath);
+    return this._parseResponse(response);
+  }
+
+  async postUrlEncoded(path, data) {
+    const body = typeof data === 'string' ? data : new URLSearchParams(data).toString();
+    const response = await this.request(path, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+      body,
+    });
+    return this._parseResponse(response);
+  }
+
+  async postMultipart(path, fields, files) {
+    const formData = new FormData();
+    for (const [key, value] of Object.entries(fields)) {
+      formData.append(key, value);
+    }
+    for (const { fieldName, filePath, fileName } of files) {
+      const buffer = await readFile(filePath);
+      const blob = new Blob([buffer]);
+      formData.append(fieldName, blob, fileName);
+    }
+    const response = await this.request(path, { method: 'POST', body: formData });
+    return this._parseResponse(response);
+  }
+
+  /**
+   * Fetch a URL and return the raw response as a Buffer (for binary downloads).
+   */
+  async getBuffer(path) {
+    const response = await this.request(path);
+    if (!response.ok) {
+      throw new Error(`Download failed: ${response.status} for ${path}`);
+    }
+    return Buffer.from(await response.arrayBuffer());
+  }
+
+  async _parseResponse(response) {
+    const text = await response.text();
+    let data;
+    try {
+      data = JSON.parse(text);
+    } catch {
+      data = { raw: text };
+    }
+
+    // DBO API responses come in two shapes:
+    // 1. Standard envelope: { Successful: true, Messages: [], Payload: ... }
+    // 2. Raw data (json_raw format): array of rows or object with _id keys
+    const isEnvelope = data !== null && typeof data === 'object' && 'Successful' in data;
+
+    return {
+      url: response._finalUrl || response.url,
+      status: response.status,
+      ok: response.ok,
+      data,
+      successful: isEnvelope ? data.Successful === true : response.ok,
+      messages: isEnvelope ? (data.Messages || []) : [],
+      payload: isEnvelope ? (data.Payload || null) : data,
+    };
+  }
+}

package/src/lib/columns.js

@@ -0,0 +1,30 @@
+/**
+ * Shared column filtering for DBO.io input submissions.
+ *
+ * These columns are server-managed or session-provided and must never
+ * be included in push/add payloads.
+ */
+
+// Columns that are read-only / auto-generated — never submitted
+const SKIP_COLUMNS = new Set([
+  '_id',
+  '_CreatedOn',
+  '_LastUpdated',
+  '_LastUpdatedUserID',
+  '_LastUpdatedTicketID',
+  '_entity',
+  '_contentColumns',
+]);
+
+/**
+ * Returns true if the given metadata key should be excluded from input submissions.
+ * Skips all SKIP_COLUMNS plus any key starting with _ (except UID).
+ */
+export function shouldSkipColumn(key) {
+  if (SKIP_COLUMNS.has(key)) return true;
+  // Skip system columns starting with _ except UID
+  if (key.startsWith('_') && key !== 'UID') return true;
+  return false;
+}
+
+export { SKIP_COLUMNS };

package/src/lib/config.js

@@ -0,0 +1,269 @@
+import { readFile, writeFile, mkdir, access } from 'fs/promises';
+import { join } from 'path';
+import { log } from './logger.js';
+
+const DBO_DIR = '.dbo';
+const CONFIG_FILE = 'config.json';
+const CREDENTIALS_FILE = 'credentials.json';
+const COOKIES_FILE = 'cookies.txt';
+
+function dboDir() {
+  return join(process.cwd(), DBO_DIR);
+}
+
+function configPath() {
+  return join(dboDir(), CONFIG_FILE);
+}
+
+function credentialsPath() {
+  return join(dboDir(), CREDENTIALS_FILE);
+}
+
+function cookiesPath() {
+  return join(dboDir(), COOKIES_FILE);
+}
+
+async function exists(path) {
+  try {
+    await access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export async function isInitialized() {
+  return exists(dboDir());
+}
+
+export async function hasLegacyConfig() {
+  return exists(join(process.cwd(), '.domain'));
+}
+
+export async function readLegacyConfig() {
+  const cwd = process.cwd();
+  const config = {};
+  try {
+    config.domain = (await readFile(join(cwd, '.domain'), 'utf8')).trim();
+  } catch { /* no legacy domain */ }
+  try {
+    config.username = (await readFile(join(cwd, '.username'), 'utf8')).trim();
+  } catch { /* no legacy username */ }
+  try {
+    config.password = (await readFile(join(cwd, '.password'), 'utf8')).trim();
+  } catch { /* no legacy password */ }
+  return config;
+}
+
+export async function initConfig(domain) {
+  await mkdir(dboDir(), { recursive: true });
+  await writeFile(configPath(), JSON.stringify({ domain }, null, 2) + '\n');
+}
+
+export async function saveCredentials(username) {
+  await mkdir(dboDir(), { recursive: true });
+  // Preserve existing fields (like userUid) — never store password
+  let existing = {};
+  try {
+    existing = JSON.parse(await readFile(credentialsPath(), 'utf8'));
+  } catch { /* no existing file */ }
+  existing.username = username;
+  delete existing.password; // Remove password if present from older versions
+  await writeFile(credentialsPath(), JSON.stringify(existing, null, 2) + '\n');
+}
+
+export async function saveUserInfo({ userId, userUid }) {
+  await mkdir(dboDir(), { recursive: true });
+  let existing = {};
+  try {
+    existing = JSON.parse(await readFile(credentialsPath(), 'utf8'));
+  } catch { /* no existing file */ }
+  if (userId !== undefined) existing.userId = userId;
+  if (userUid !== undefined) existing.userUid = userUid;
+  await writeFile(credentialsPath(), JSON.stringify(existing, null, 2) + '\n');
+}
+
+export async function loadUserInfo() {
+  try {
+    const raw = await readFile(credentialsPath(), 'utf8');
+    const creds = JSON.parse(raw);
+    return {
+      userId: creds.userId || null,
+      userUid: creds.userUid || null,
+    };
+  } catch {
+    return { userId: null, userUid: null };
+  }
+}
+
+export async function loadConfig() {
+  const config = { domain: null, username: null, password: null, ServerTimezone: 'UTC' };
+
+  // Try .dbo/config.json
+  try {
+    const raw = await readFile(configPath(), 'utf8');
+    Object.assign(config, JSON.parse(raw));
+  } catch {
+    // Try legacy .domain file
+    try {
+      config.domain = (await readFile(join(process.cwd(), '.domain'), 'utf8')).trim();
+    } catch { /* no config found */ }
+  }
+
+  // Try .dbo/credentials.json (username only — password is never stored)
+  try {
+    const raw = await readFile(credentialsPath(), 'utf8');
+    const creds = JSON.parse(raw);
+    config.username = creds.username;
+  } catch {
+    // Try legacy .username file
+    try {
+      config.username = (await readFile(join(process.cwd(), '.username'), 'utf8')).trim();
+    } catch { /* no legacy username */ }
+  }
+
+  // Environment variables override (DBO_PASSWORD supported for CI/scripts)
+  if (process.env.DBO_DOMAIN) config.domain = process.env.DBO_DOMAIN;
+  if (process.env.DBO_USERNAME) config.username = process.env.DBO_USERNAME;
+  if (process.env.DBO_PASSWORD) config.password = process.env.DBO_PASSWORD;
+
+  return config;
+}
+
+export function getCookiesPath() {
+  // Prefer .dbo/cookies.txt, fall back to legacy .cookies
+  const dboCookies = join(dboDir(), COOKIES_FILE);
+  const legacyCookies = join(process.cwd(), '.cookies');
+  return { dbo: dboCookies, legacy: legacyCookies };
+}
+
+export async function getActiveCookiesPath() {
+  const paths = getCookiesPath();
+  if (await exists(paths.dbo)) return paths.dbo;
+  if (await exists(paths.legacy)) return paths.legacy;
+  return paths.dbo; // default for new sessions
+}
+
+/**
+ * Merge app metadata into .dbo/config.json.
+ * Preserves existing fields; only sets new ones.
+ */
+export async function updateConfigWithApp({ AppID, AppUID, AppName, AppShortName, ServerTimezone }) {
+  await mkdir(dboDir(), { recursive: true });
+  let existing = {};
+  try {
+    existing = JSON.parse(await readFile(configPath(), 'utf8'));
+  } catch { /* no existing config */ }
+  if (AppID !== undefined) existing.AppID = AppID;
+  if (AppUID !== undefined) existing.AppUID = AppUID;
+  if (AppName !== undefined) existing.AppName = AppName;
+  if (AppShortName !== undefined) existing.AppShortName = AppShortName;
+  if (ServerTimezone !== undefined) existing.ServerTimezone = ServerTimezone;
+  await writeFile(configPath(), JSON.stringify(existing, null, 2) + '\n');
+}
+
+/**
+ * Load app-related fields from .dbo/config.json.
+ */
+export async function loadAppConfig() {
+  try {
+    const raw = await readFile(configPath(), 'utf8');
+    const config = JSON.parse(raw);
+    return {
+      AppID: config.AppID || null,
+      AppUID: config.AppUID || null,
+      AppName: config.AppName || null,
+      AppShortName: config.AppShortName || null,
+    };
+  } catch {
+    return { AppID: null, AppUID: null, AppName: null, AppShortName: null };
+  }
+}
+
+/**
+ * Save clone placement preferences to .dbo/config.json.
+ * mediaPlacement: 'fullpath' | 'bin' | 'ask'
+ * contentPlacement: 'path' | 'bin' | 'ask'
+ */
+export async function saveClonePlacement({ mediaPlacement, contentPlacement }) {
+  await mkdir(dboDir(), { recursive: true });
+  let existing = {};
+  try {
+    existing = JSON.parse(await readFile(configPath(), 'utf8'));
+  } catch { /* no existing config */ }
+  if (mediaPlacement !== undefined) existing.MediaPlacement = mediaPlacement;
+  if (contentPlacement !== undefined) existing.ContentPlacement = contentPlacement;
+  await writeFile(configPath(), JSON.stringify(existing, null, 2) + '\n');
+}
+
+/**
+ * Load clone placement preferences from .dbo/config.json.
+ */
+export async function loadClonePlacement() {
+  try {
+    const raw = await readFile(configPath(), 'utf8');
+    const config = JSON.parse(raw);
+    return {
+      mediaPlacement: config.MediaPlacement || null,
+      contentPlacement: config.ContentPlacement || null,
+    };
+  } catch {
+    return { mediaPlacement: null, contentPlacement: null };
+  }
+}
+
+/**
+ * Save user profile fields (FirstName, LastName, Email) into credentials.json.
+ */
+export async function saveUserProfile({ FirstName, LastName, Email }) {
+  await mkdir(dboDir(), { recursive: true });
+  let existing = {};
+  try {
+    existing = JSON.parse(await readFile(credentialsPath(), 'utf8'));
+  } catch { /* no existing file */ }
+  if (FirstName !== undefined) existing.FirstName = FirstName;
+  if (LastName !== undefined) existing.LastName = LastName;
+  if (Email !== undefined) existing.Email = Email;
+  await writeFile(credentialsPath(), JSON.stringify(existing, null, 2) + '\n');
+}
+
+/**
+ * Load user profile from credentials.json.
+ */
+export async function loadUserProfile() {
+  try {
+    const raw = await readFile(credentialsPath(), 'utf8');
+    const creds = JSON.parse(raw);
+    return {
+      FirstName: creds.FirstName || null,
+      LastName: creds.LastName || null,
+      Email: creds.Email || null,
+    };
+  } catch {
+    return { FirstName: null, LastName: null, Email: null };
+  }
+}
+
+/**
+ * Ensure patterns are in .gitignore. Creates .gitignore if it doesn't exist.
+ */
+export async function ensureGitignore(patterns) {
+  const gitignorePath = join(process.cwd(), '.gitignore');
+  let content = '';
+  try {
+    content = await readFile(gitignorePath, 'utf8');
+  } catch { /* no .gitignore yet */ }
+
+  const toAdd = patterns.filter(p => !content.includes(p));
+  if (toAdd.length === 0) return;
+
+  const isNew = content.length === 0;
+  const needsNewline = !isNew && !content.endsWith('\n');
+  const hasHeader = content.includes('# DBO CLI');
+  const section = needsNewline ? '\n' : '';
+  const header = hasHeader ? '' : (isNew ? '# DBO CLI (sensitive files)\n' : '\n# DBO CLI (sensitive files)\n');
+  const addition = `${section}${header}${toAdd.join('\n')}\n`;
+
+  await writeFile(gitignorePath, content + addition);
+  for (const p of toAdd) log.dim(`  Added ${p} to .gitignore`);
+}

package/src/lib/cookie-jar.js

@@ -0,0 +1,104 @@
+import { readFile, writeFile, mkdir } from 'fs/promises';
+import { dirname } from 'path';
+
+/**
+ * Read/write Netscape cookie format for curl compatibility.
+ * Format: domain\tinclude_subdomains\tpath\tsecure\texpiry\tname\tvalue
+ */
+
+export async function loadCookies(filePath) {
+  try {
+    const text = await readFile(filePath, 'utf8');
+    const cookies = [];
+    for (const line of text.split('\n')) {
+      const trimmed = line.trim();
+      if (!trimmed || trimmed.startsWith('#')) continue;
+      const parts = trimmed.split('\t');
+      if (parts.length >= 7) {
+        cookies.push({
+          domain: parts[0],
+          includeSubdomains: parts[1] === 'TRUE',
+          path: parts[2],
+          secure: parts[3] === 'TRUE',
+          expiry: parseInt(parts[4], 10),
+          name: parts[5],
+          value: parts[6],
+        });
+      }
+    }
+    return cookies;
+  } catch {
+    return [];
+  }
+}
+
+export function buildCookieHeader(cookies, url) {
+  const urlObj = new URL(url);
+  const matching = cookies.filter(c => {
+    const domainMatch = urlObj.hostname === c.domain || urlObj.hostname.endsWith('.' + c.domain);
+    const pathMatch = urlObj.pathname.startsWith(c.path);
+    const secureMatch = !c.secure || urlObj.protocol === 'https:';
+    const notExpired = c.expiry === 0 || c.expiry > Math.floor(Date.now() / 1000);
+    return domainMatch && pathMatch && secureMatch && notExpired;
+  });
+  if (matching.length === 0) return null;
+  return matching.map(c => `${c.name}=${c.value}`).join('; ');
+}
+
+export function parseSetCookieHeaders(headers, url) {
+  const urlObj = new URL(url);
+  const cookies = [];
+  const raw = headers.getSetCookie?.() || [];
+  for (const header of raw) {
+    const parts = header.split(';').map(s => s.trim());
+    const [nameValue, ...attrs] = parts;
+    const eqIdx = nameValue.indexOf('=');
+    if (eqIdx === -1) continue;
+    const name = nameValue.slice(0, eqIdx);
+    const value = nameValue.slice(eqIdx + 1);
+    const cookie = {
+      domain: urlObj.hostname,
+      includeSubdomains: false,
+      path: '/',
+      secure: false,
+      expiry: 0,
+      name,
+      value,
+    };
+    for (const attr of attrs) {
+      const [key, val] = attr.split('=').map(s => s.trim());
+      const lk = key.toLowerCase();
+      if (lk === 'domain') { cookie.domain = val.replace(/^\./, ''); cookie.includeSubdomains = true; }
+      else if (lk === 'path') cookie.path = val;
+      else if (lk === 'secure') cookie.secure = true;
+      else if (lk === 'expires') cookie.expiry = Math.floor(new Date(val).getTime() / 1000);
+      else if (lk === 'max-age') cookie.expiry = Math.floor(Date.now() / 1000) + parseInt(val, 10);
+    }
+    cookies.push(cookie);
+  }
+  return cookies;
+}
+
+export async function saveCookies(filePath, cookies) {
+  await mkdir(dirname(filePath), { recursive: true });
+  const lines = ['# Netscape HTTP Cookie File', '# Generated by dbo-cli', ''];
+  for (const c of cookies) {
+    lines.push([
+      c.domain,
+      c.includeSubdomains ? 'TRUE' : 'FALSE',
+      c.path,
+      c.secure ? 'TRUE' : 'FALSE',
+      c.expiry.toString(),
+      c.name,
+      c.value,
+    ].join('\t'));
+  }
+  await writeFile(filePath, lines.join('\n') + '\n');
+}
+
+export function mergeCookies(existing, incoming) {
+  const map = new Map();
+  for (const c of existing) map.set(`${c.domain}:${c.path}:${c.name}`, c);
+  for (const c of incoming) map.set(`${c.domain}:${c.path}:${c.name}`, c);
+  return [...map.values()];
+}