@elixpo/lixblogs-cli 1.3.3 → 1.4.2

package/src/auth/ElixpoAuthProvider.js

@@ -1,281 +0,0 @@
-import { AuthProvider } from "./AuthProvider.js";
-
-const DEVICE_GRANT = "urn:ietf:params:oauth:grant-type:device_code";
-const SUPPORTED_CONTRACT_MAJOR = 1;
-const DEFAULT_TIMEOUT_MS = 15_000;
-
-const SAFE_ERROR_MESSAGES = {
-  access_denied: "Login was denied.",
-  authorization_pending: "Login is awaiting approval.",
-  expired_token: "The device authorization expired. Start login again.",
-  invalid_client: "The LixBlogs CLI client is not registered for this environment.",
-  invalid_grant: "This session is no longer valid. Log in again.",
-  invalid_request: "Accounts rejected the authentication request.",
-  invalid_scope: "The requested LixBlogs permissions are not available for this client.",
-  server_error: "Accounts could not complete authentication. Try again later.",
-  slow_down: "Accounts requested slower polling.",
-  temporarily_unavailable: "Accounts is temporarily unavailable. Try again later.",
-};
-
-export class AuthProviderError extends Error {
-  constructor(code, { status = 0, requiresLogin = false } = {}) {
-    super(SAFE_ERROR_MESSAGES[code] || "Authentication failed.");
-    this.name = "AuthProviderError";
-    this.code = code || "authentication_failed";
-    this.status = status;
-    this.requiresLogin = requiresLogin;
-  }
-}
-
-export class CompatibilityError extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "CompatibilityError";
-    this.code = "incompatible_accounts_contract";
-  }
-}
-
-function versionParts(value) {
-  return String(value || "0.0.0")
-    .split(".")
-    .slice(0, 3)
-    .map((part) => Number.parseInt(part, 10) || 0);
-}
-
-function versionAtLeast(current, minimum) {
-  const left = versionParts(current);
-  const right = versionParts(minimum);
-  for (let index = 0; index < 3; index += 1) {
-    if (left[index] !== right[index]) return left[index] > right[index];
-  }
-  return true;
-}
-
-function normalizeBaseUrl(value) {
-  const url = new URL(value);
-  url.pathname = url.pathname.replace(/\/$/, "");
-  url.search = "";
-  url.hash = "";
-  if (url.protocol !== "https:" && url.hostname !== "localhost" && url.hostname !== "127.0.0.1") {
-    throw new CompatibilityError("Accounts must use HTTPS outside local development.");
-  }
-  return url.toString().replace(/\/$/, "");
-}
-
-async function responseJson(response) {
-  try {
-    return await response.json();
-  } catch {
-    throw new AuthProviderError("server_error", { status: response.status });
-  }
-}
-
-function oauthError(payload, response) {
-  const code = typeof payload?.error === "string" ? payload.error : "server_error";
-  return new AuthProviderError(code, {
-    status: response.status,
-    requiresLogin: code === "invalid_grant" || code === "access_denied" || code === "expired_token",
-  });
-}
-
-function tokenResponse(payload, response) {
-  if (!response.ok) throw oauthError(payload, response);
-  if (
-    typeof payload?.access_token !== "string" ||
-    typeof payload?.refresh_token !== "string" ||
-    !Number.isFinite(Number(payload?.expires_in))
-  ) {
-    throw new AuthProviderError("server_error", { status: response.status });
-  }
-  return {
-    accessToken: payload.access_token,
-    refreshToken: payload.refresh_token,
-    expiresInSeconds: Number(payload.expires_in),
-    scopes: typeof payload.scope === "string" ? payload.scope.split(/\s+/).filter(Boolean) : [],
-  };
-}
-
-export class ElixpoAuthProvider extends AuthProvider {
-  constructor({
-    accountsBaseUrl = "https://accounts.elixpo.com",
-    clientId = "lixblogs-cli-prod",
-    audience = "blogs.elixpo.com",
-    cliVersion = "1.2.0",
-    fetchImpl = globalThis.fetch,
-    timeoutMs = DEFAULT_TIMEOUT_MS,
-  } = {}) {
-    super();
-    if (typeof fetchImpl !== "function") throw new TypeError("A fetch implementation is required.");
-    this.accountsBaseUrl = normalizeBaseUrl(accountsBaseUrl);
-    this.clientId = clientId;
-    this.audience = audience;
-    this.cliVersion = cliVersion;
-    this.fetchImpl = fetchImpl;
-    this.timeoutMs = timeoutMs;
-    this._metadata = null;
-    this._discoveryPromise = null;
-  }
-
-  get providerId() {
-    return "elixpo";
-  }
-
-  async _fetch(url, options = {}) {
-    const controller = new AbortController();
-    const timeout = setTimeout(() => controller.abort(), this.timeoutMs);
-    try {
-      return await this.fetchImpl(url, {
-        ...options,
-        signal: options.signal || controller.signal,
-        headers: { accept: "application/json", ...options.headers },
-      });
-    } catch {
-      throw new AuthProviderError("temporarily_unavailable");
-    } finally {
-      clearTimeout(timeout);
-    }
-  }
-
-  async discover({ scopes = [] } = {}) {
-    if (!this._metadata) {
-      if (!this._discoveryPromise) this._discoveryPromise = this._loadDiscovery();
-      try {
-        this._metadata = await this._discoveryPromise;
-      } finally {
-        this._discoveryPromise = null;
-      }
-    }
-
-    const unsupported = scopes.filter((scope) => !this._metadata.scopes_supported.includes(scope));
-    if (unsupported.length) throw new AuthProviderError("invalid_scope");
-    return this._metadata;
-  }
-
-  async _loadDiscovery() {
-    const response = await this._fetch(`${this.accountsBaseUrl}/.well-known/oauth-authorization-server`);
-    const metadata = await responseJson(response);
-    if (!response.ok) throw new AuthProviderError("temporarily_unavailable", { status: response.status });
-
-    const contractMajor = versionParts(metadata.elixpo_contract_version)[0];
-    if (contractMajor !== SUPPORTED_CONTRACT_MAJOR) {
-      throw new CompatibilityError("Accounts uses an unsupported device-flow contract version.");
-    }
-    if (!versionAtLeast(this.cliVersion, metadata.elixpo_min_compatible_cli_version)) {
-      throw new CompatibilityError(
-        `This CLI is too old for Accounts. Upgrade to version ${metadata.elixpo_min_compatible_cli_version} or newer.`,
-      );
-    }
-    if (!Array.isArray(metadata.grant_types_supported) || !metadata.grant_types_supported.includes(DEVICE_GRANT)) {
-      throw new CompatibilityError("Accounts does not advertise OAuth device authorization.");
-    }
-
-    const requiredEndpoints = [
-      "device_authorization_endpoint",
-      "token_endpoint",
-      "revocation_endpoint",
-    ];
-    for (const field of requiredEndpoints) {
-      if (typeof metadata[field] !== "string") {
-        throw new CompatibilityError(`Accounts discovery is missing ${field}.`);
-      }
-      const endpoint = new URL(metadata[field]);
-      const accounts = new URL(this.accountsBaseUrl);
-      if (endpoint.origin !== accounts.origin) {
-        throw new CompatibilityError(`Accounts discovery returned an untrusted ${field}.`);
-      }
-    }
-
-    return {
-      ...metadata,
-      scopes_supported: Array.isArray(metadata.scopes_supported) ? metadata.scopes_supported : [],
-    };
-  }
-
-  async requestDeviceCode({ scopes }) {
-    const metadata = await this.discover({ scopes });
-    const response = await this._fetch(metadata.device_authorization_endpoint, {
-      method: "POST",
-      headers: { "content-type": "application/json" },
-      body: JSON.stringify({
-        client_id: this.clientId,
-        scope: scopes.join(" "),
-        audience: this.audience,
-      }),
-    });
-    const payload = await responseJson(response);
-    if (!response.ok) throw oauthError(payload, response);
-    if (
-      typeof payload.device_code !== "string" ||
-      typeof payload.user_code !== "string" ||
-      typeof payload.verification_uri !== "string"
-    ) {
-      throw new AuthProviderError("server_error", { status: response.status });
-    }
-    return {
-      deviceCode: payload.device_code,
-      userCode: payload.user_code,
-      verificationUri: payload.verification_uri,
-      verificationUriComplete: payload.verification_uri_complete || payload.verification_uri,
-      expiresInSeconds: Number(payload.expires_in) || 600,
-      pollIntervalSeconds: Number(payload.interval) || 5,
-    };
-  }
-
-  async pollDeviceCode({ deviceCode }) {
-    const metadata = await this.discover();
-    const body = new URLSearchParams({
-      grant_type: DEVICE_GRANT,
-      device_code: deviceCode,
-      client_id: this.clientId,
-    });
-    const response = await this._fetch(metadata.token_endpoint, {
-      method: "POST",
-      headers: { "content-type": "application/x-www-form-urlencoded" },
-      body,
-    });
-    const payload = await responseJson(response);
-    if (response.ok) return { status: "approved", token: tokenResponse(payload, response) };
-    if (payload?.error === "authorization_pending") return { status: "pending" };
-    if (payload?.error === "slow_down") {
-      const polling = metadata.elixpo_device_flow_polling || {};
-      const increase = Math.max(
-        5,
-        Number(polling.slow_down_interval_seconds || 10) - Number(polling.interval_seconds || 5),
-      );
-      return { status: "slow_down", pollIntervalIncreaseSeconds: increase };
-    }
-    if (payload?.error === "access_denied") return { status: "denied" };
-    if (payload?.error === "expired_token") return { status: "expired" };
-    throw oauthError(payload, response);
-  }
-
-  async refresh({ refreshToken, scopes }) {
-    const metadata = await this.discover({ scopes: scopes || [] });
-    const body = new URLSearchParams({
-      grant_type: "refresh_token",
-      refresh_token: refreshToken,
-      client_id: this.clientId,
-    });
-    if (scopes?.length) body.set("scope", scopes.join(" "));
-    const response = await this._fetch(metadata.token_endpoint, {
-      method: "POST",
-      headers: { "content-type": "application/x-www-form-urlencoded" },
-      body,
-    });
-    const payload = await responseJson(response);
-    return tokenResponse(payload, response);
-  }
-
-  async revoke({ token }) {
-    const metadata = await this.discover();
-    const response = await this._fetch(metadata.revocation_endpoint, {
-      method: "POST",
-      headers: { "content-type": "application/x-www-form-urlencoded" },
-      body: new URLSearchParams({ token, client_id: this.clientId }),
-    });
-    if (!response.ok) {
-      const payload = await responseJson(response);
-      throw oauthError(payload, response);
-    }
-  }
-}

package/src/auth/MockAuthProvider.js

@@ -1,170 +0,0 @@
-import { AuthProvider } from "./AuthProvider.js";
-
-/**
- * MockAuthProvider — deterministic, in-memory device-flow simulation for
- * development and tests. Never talks to a real server.
- *
- * Per maintainer direction: this exists so CLI/UI work isn't blocked while
- * accounts.elixpo.com's device-flow support has no confirmed ETA. This must
- * never be reachable in a production configuration — see
- * assertNotProduction() in productionGate.js, which every provider
- * constructor call should be routed through at the call site.
- *
- * States simulated (mirroring "Device login, refresh, logout, revocation,
- * expiry, denial, and polling errors are tested" from #135's acceptance
- * criteria):
- *   - approved (successful login)
- *   - pending (still polling)
- *   - denied
- *   - expired
- *   - invalid/unknown device code
- *   - slow_down (RFC 8628 §3.5 style rate-limit signal)
- *   - refresh success / refresh failure
- *   - revoke
- *
- * Scenario selection is deterministic and driven by the deviceCode's prefix,
- * not randomness — so tests are reproducible. See SCENARIO_PREFIX below.
- *
- * --- Open questions from elixpo/blogs.elixpo#137, resolved by implementer ---
- * - Mock states: slow_down added (see above), matching RFC 8628 rather than
- *   inventing a bespoke rate-limit shape, so the real ElixpoAuthProvider can
- *   follow the same contract later.
- * - Polling/backoff: on slow_down, caller must increase its poll interval by
- *   SLOW_DOWN_INTERVAL_INCREASE_SECONDS before polling again. No other
- *   backoff logic in the mock itself — backoff is the CLI's responsibility,
- *   not the provider's.
- * Flagged for the maintainer to override if a different behavior is wanted.
- */
-
-const SCENARIO_PREFIX = {
-  APPROVE_IMMEDIATELY: "mock-approve-",
-  PENDING_THEN_APPROVE: "mock-pending-then-approve-",
-  DENY: "mock-deny-",
-  EXPIRE: "mock-expire-",
-  SLOW_DOWN_THEN_APPROVE: "mock-slow-down-then-approve-",
-};
-
-// Mirrors RFC 8628 §3.5: on slow_down, the client must increase its polling
-// interval by this many seconds. Real ElixpoAuthProvider should follow the
-// same contract so CLI polling logic doesn't need a provider-specific branch.
-const SLOW_DOWN_INTERVAL_INCREASE_SECONDS = 5;
-
-let counter = 0;
-function nextId(prefix) {
-  counter += 1;
-  return `${prefix}${counter}`;
-}
-
-export class MockAuthProvider extends AuthProvider {
-  constructor() {
-    super();
-    /** @type {Map<string, { scenario: string, pollCount: number, createdAt: number, scopes: string[] }>} */
-    this._devicesCodes = new Map();
-    /** @type {Set<string>} revoked tokens */
-    this._revoked = new Set();
-    /** @type {Set<string>} tokens that will fail on next refresh (for testing refresh failure) */
-    this._refreshWillFail = new Set();
-  }
-
-  get providerId() {
-    return "mock";
-  }
-
-  /**
-   * @param {{ scopes: string[], scenario?: keyof typeof SCENARIO_PREFIX }} params
-   *   `scenario` lets tests/dev deterministically choose which path this
-   *   device code will take. Defaults to APPROVE_IMMEDIATELY.
-   */
-  async requestDeviceCode({ scopes, scenario = "APPROVE_IMMEDIATELY" }) {
-    const prefix = SCENARIO_PREFIX[scenario] ?? SCENARIO_PREFIX.APPROVE_IMMEDIATELY;
-    const deviceCode = nextId(prefix);
-    const userCode = deviceCode.slice(-6).toUpperCase();
-
-    this._devicesCodes.set(deviceCode, {
-      scenario,
-      pollCount: 0,
-      createdAt: Date.now(),
-      scopes: [...scopes],
-    });
-
-    return {
-      deviceCode,
-      userCode,
-      verificationUri: "https://mock.lixblogs.local/device",
-      verificationUriComplete: `https://mock.lixblogs.local/device?user_code=${encodeURIComponent(userCode)}`,
-      expiresInSeconds: scenario === "EXPIRE" ? 1 : 600,
-      pollIntervalSeconds: 1,
-    };
-  }
-
-  async pollDeviceCode({ deviceCode }) {
-    const record = this._devicesCodes.get(deviceCode);
-
-    if (!record) {
-      // Unknown/invalid code — distinct from "expired": this code never existed.
-      return { status: "denied" };
-    }
-
-    if (record.scenario === "EXPIRE") {
-      return { status: "expired" };
-    }
-
-    if (record.scenario === "DENY") {
-      return { status: "denied" };
-    }
-
-    if (record.scenario === "PENDING_THEN_APPROVE") {
-      record.pollCount += 1;
-      if (record.pollCount < 2) {
-        return { status: "pending" };
-      }
-      // fall through to approve on the 2nd+ poll
-    }
-
-    if (record.scenario === "SLOW_DOWN_THEN_APPROVE") {
-      record.pollCount += 1;
-      if (record.pollCount < 2) {
-        return {
-          status: "slow_down",
-          pollIntervalIncreaseSeconds: SLOW_DOWN_INTERVAL_INCREASE_SECONDS,
-        };
-      }
-      // fall through to approve on the 2nd+ poll
-    }
-
-    return {
-      status: "approved",
-      token: {
-        accessToken: `mock-access-${deviceCode}`,
-        refreshToken: `mock-refresh-${deviceCode}`,
-        expiresInSeconds: 3600,
-        scopes: record.scopes,
-      },
-    };
-  }
-
-  async refresh({ refreshToken, scopes = [] }) {
-    if (this._revoked.has(refreshToken)) {
-      throw new Error("refresh token has been revoked");
-    }
-    if (this._refreshWillFail.has(refreshToken)) {
-      throw new Error("mock refresh failure (test-injected)");
-    }
-    return {
-      accessToken: `mock-access-refreshed-${refreshToken}`,
-      refreshToken,
-      expiresInSeconds: 3600,
-      scopes,
-    };
-  }
-
-  async revoke({ token }) {
-    // Must not throw if already revoked — revocation is idempotent.
-    this._revoked.add(token);
-  }
-
-  /** Test helper: force the next refresh() call for this token to fail. */
-  _simulateRefreshFailureFor(refreshToken) {
-    this._refreshWillFail.add(refreshToken);
-  }
-}

package/src/auth/productionGate.js

@@ -1,44 +0,0 @@
-/**
- * Production safety gate.
- *
- * Maintainer's explicit requirement (verbatim):
- *   "Production login must remain explicitly unavailable until the real
- *   issuer, polling, refresh, scope, and revocation contract is approved —
- *   no copied cookies or fallback credentials."
- *
- * This must fail loudly and immediately — not silently degrade, not warn
- * and continue. Every call site that constructs an AuthProvider must route
- * through assertProviderAllowed() first.
- *
- * Accounts now publishes the approved RFC 8628 contract, so production is
- * enabled only for ElixpoAuthProvider. The deterministic mock remains usable
- * in explicit development/test environments and can never cross this gate.
- */
-
-const APPROVED_PRODUCTION_PROVIDER_ID = "elixpo";
-
-export class ProductionAuthGateError extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "ProductionAuthGateError";
-  }
-}
-
-/**
- * @param {{ providerId: string, environment: string }} params
- *   `environment` should come from explicit config, not inferred/guessed.
- */
-export function assertProviderAllowed({ providerId, environment }) {
-  const isProduction = environment === "production";
-
-  if (!isProduction) {
-    return; // any provider (including mock) is fine outside production
-  }
-
-  if (providerId !== APPROVED_PRODUCTION_PROVIDER_ID) {
-    throw new ProductionAuthGateError(
-      `Provider "${providerId}" is not approved for production. ` +
-        `Only "${APPROVED_PRODUCTION_PROVIDER_ID}" may be used in production.`
-    );
-  }
-}

package/src/cli/contract.js

@@ -1,46 +0,0 @@
-export const EXIT_CODES = Object.freeze({
-  OK: 0,
-  ERROR: 1,
-  USAGE: 2,
-  CONFLICT: 3,
-  AUTH: 4,
-  CONFIRMATION: 5,
-});
-
-const TOP_LEVEL_ALIASES = Object.freeze({
-  login: ['auth', 'login'],
-  logout: ['auth', 'logout'],
-  whoami: ['auth', 'whoami'],
-  profiles: ['auth', 'profiles'],
-  use: ['auth', 'use'],
-});
-
-export function normalizeCommand(positionals) {
-  const [command, ...rest] = positionals;
-  const alias = TOP_LEVEL_ALIASES[command];
-  return alias ? [...alias, ...rest] : positionals;
-}
-
-export function errorEnvelope(error, fallbackCode = 'cli_error') {
-  if (error && typeof error === 'object' && error.error && !Array.isArray(error.error)) return error;
-  const value = error && typeof error === 'object' ? error : { message: String(error || 'Command failed.') };
-  return {
-    ok: false,
-    error: {
-      code: value.code || fallbackCode,
-      message: value.message || 'Command failed.',
-      hint: value.hint || null,
-      requestId: value.requestId || null,
-      ...(value.details ? { details: value.details } : {}),
-    },
-  };
-}
-
-export function requireConfirmation(options, action) {
-  if (options.yes) return;
-  const error = new Error(`${action} requires --yes in non-interactive operation.`);
-  error.code = 'confirmation_required';
-  error.hint = `Review the operation, then run it again with --yes.`;
-  error.exitCode = EXIT_CODES.CONFIRMATION;
-  throw error;
-}

package/src/cli/ui.js

@@ -1,54 +0,0 @@
-const ANSI = Object.freeze({
-  reset: "\u001b[0m",
-  bold: "\u001b[1m",
-  dim: "\u001b[2m",
-  violet: "\u001b[38;5;141m",
-  green: "\u001b[38;5;42m",
-});
-
-export function colorEnabled(stream = process.stdout, env = process.env) {
-  return Boolean(stream.isTTY) && env.NO_COLOR === undefined && env.TERM !== "dumb";
-}
-
-function paint(value, code, enabled) {
-  return enabled ? `${code}${value}${ANSI.reset}` : value;
-}
-
-export function loginChallenge({ url, code, expiresInSeconds, profile, interactive, color = false }) {
-  const title = `${paint("◆", ANSI.violet, color)} ${paint("LixBlogs", ANSI.bold, color)}`;
-  const instruction = interactive
-    ? "Press Enter to open here, or use the URL on another device."
-    : "Open the URL in any browser and approve this device.";
-  return [
-    "",
-    `  ${title}`,
-    `  ${paint("Device login", ANSI.dim, color)}`,
-    "  ─────────────────────────────────────────",
-    `  URL      ${url}`,
-    `  Code     ${paint(code, ANSI.bold, color)}`,
-    `  Expires  ${Math.ceil(expiresInSeconds / 60)} min`,
-    profile
-      ? `  Profile  ${profile} ${paint("(local credential slot)", ANSI.dim, color)}`
-      : `  Profile  ${paint("your Accounts username after approval", ANSI.dim, color)}`,
-    "",
-    `  ${instruction}`,
-    "  No localhost callback or exposed port is required.",
-    "",
-  ].join("\n");
-}
-
-export function successLine(message, color = false) {
-  return `  ${paint("✓", ANSI.green, color)} ${message}`;
-}
-
-export function listenForEnter({ input = process.stdin, open, url }) {
-  if (!input.isTTY || typeof open !== "function") return () => {};
-  const onData = () => { Promise.resolve(open(url)).catch(() => {}); };
-  input.setEncoding?.("utf8");
-  input.once("data", onData);
-  input.resume?.();
-  return () => {
-    input.off?.("data", onData);
-    input.pause?.();
-  };
-}

package/src/commands/analytics/index.js

@@ -1,57 +0,0 @@
-import { writeFile } from 'node:fs/promises';
-
-const DIMENSIONS = new Set(['overview', 'timeline', 'posts', 'sources', 'devices', 'countries']);
-const RANGES = new Set(['7d', '30d', '90d', '12m', 'custom']);
-
-function normalizedOptions(options = {}) {
-  const dimension = options.dimension || 'overview';
-  const range = options.range || (options.from || options.to ? 'custom' : '30d');
-  if (!DIMENSIONS.has(dimension)) throw new Error(`Unsupported analytics dimension: ${dimension}.`);
-  if (!RANGES.has(range)) throw new Error(`Unsupported analytics range: ${range}.`);
-  if (range === 'custom' && (!options.from || !options.to)) throw new Error('Custom analytics ranges require --from and --to.');
-  return {
-    scope: options.scope?.[0] || options.publication || 'personal',
-    range,
-    from: options.from,
-    to: options.to,
-    dimension,
-    limit: options.limit,
-    cursor: options.cursor,
-  };
-}
-
-export async function analyticsQuery({ client, options }) {
-  return client.query(normalizedOptions(options));
-}
-
-function csvCell(value) {
-  const text = value === null || value === undefined ? '' : typeof value === 'object' ? JSON.stringify(value) : String(value);
-  return /[",\n]/.test(text) ? `"${text.replaceAll('"', '""')}"` : text;
-}
-
-function rowsFromPayload(payload) {
-  const values = payload?.data?.values;
-  if (Array.isArray(values)) return values;
-  if (values?.labels && Array.isArray(values.labels)) {
-    return values.labels.map((label, index) => ({ label, views: values.views?.[index] || 0, reads: values.reads?.[index] || 0 }));
-  }
-  if (values?.totals) return Object.entries(values.totals).map(([metric, value]) => ({ metric, value, previous: values.previous?.[metric], change: values.changes?.[metric] }));
-  return [];
-}
-
-export async function analyticsExport({ client, options }) {
-  if (!options.output) throw new Error('Analytics export requires --output <file>.');
-  const format = options.format || 'json';
-  if (!['json', 'csv'].includes(format)) throw new Error('Analytics export format must be json or csv.');
-  const payload = await client.query(normalizedOptions(options));
-  let content;
-  if (format === 'json') {
-    content = `${JSON.stringify(payload, null, 2)}\n`;
-  } else {
-    const rows = rowsFromPayload(payload);
-    const columns = [...new Set(rows.flatMap((row) => Object.keys(row)))];
-    content = `${columns.map(csvCell).join(',')}\n${rows.map((row) => columns.map((column) => csvCell(row[column])).join(',')).join('\n')}\n`;
-  }
-  await writeFile(options.output, content, { encoding: 'utf8', flag: 'wx' });
-  return { output: options.output, format, rows: rowsFromPayload(payload).length };
-}