@crombolo/cli 0.14.4 → 0.16.0

package/src/commands/content/publish.ts

@@ -0,0 +1,21 @@
+import { BaseCommand } from '../../base.ts'
+import { publishArgs, publishFlags, publishPages, publishSpec } from '../../support/publish.ts'
+
+export default class ContentPublish extends BaseCommand {
+  static override summary = 'take a page live; --descendants for the branch below it'
+  static override description = '--culture per culture; --at and --until schedule it instead.'
+  static override args = publishArgs
+  static override flags = publishFlags
+  static override audit = {
+    category: 'content',
+    action: 'Publish',
+    entityType: 'Document',
+  } as const
+  static override spec = publishSpec
+
+  async run() {
+    const { args, flags } = await this.parse(ContentPublish)
+    this.auditKey = args.page
+    return publishPages(this, true, args.page, flags)
+  }
+}

package/src/commands/content/revert.ts

@@ -0,0 +1,137 @@
+import { recordInLedger } from '@crombolo/data'
+import { backupBefore, bootstrapDatabase } from '@crombolo/server'
+import {
+  isRevertResolution,
+  REVERT_RESOLUTIONS,
+  type RevertResolution,
+  revertResolutionsFor,
+  revertRun,
+} from '@crombolo/transfer'
+import { Args, Flags } from '@oclif/core'
+import { BaseCommand } from '../../base.ts'
+import * as ops from '../../operations/commands.ts'
+import { here } from '../../support/describe.ts'
+import { backupTaken, many } from '../../support/flags.ts'
+import { siteConfig } from '../../support/site.ts'
+
+export default class ContentRevert extends BaseCommand {
+  static override summary = 'put an import back, restoring what the site served'
+  static override description = [
+    'Values and published state are restored; nodes the run created are unpublished and recycled.',
+    'A revert is itself a run, so it can be reverted in turn.',
+  ].join('\n\n')
+  static override args = {
+    run: Args.string({
+      required: true,
+      description: 'the run id: `crombolo content runs` lists them',
+    }),
+  }
+  static override flags = {
+    resolve: many(`answer a finding: <key>=${REVERT_RESOLUTIONS.join('|')}`, '<answer>'),
+    'resolve-all': Flags.string({
+      summary: 'answer every finding the same way',
+      options: [...REVERT_RESOLUTIONS],
+    }),
+    force: Flags.boolean({ summary: 'revert over changes made since the run' }),
+    'backup-taken': backupTaken,
+  }
+  static override audit = { category: 'content', action: 'Revert', entityType: 'Document' } as const
+  static override spec = {
+    effects: 'non_idempotent',
+    cardinality: 'single',
+    outputFields: [
+      { name: 'runId', type: 'string' },
+      { name: 'reverted', type: 'string' },
+      { name: 'restored', type: 'array', items: { type: 'string' } },
+      { name: 'recycled', type: 'array', items: { type: 'string' } },
+      { name: 'files', type: 'object' },
+      { name: 'backup', type: 'string', nullable: true },
+    ],
+    errors: ['usage', 'refused', 'not_found'],
+  } as const
+
+  async run() {
+    const { args, flags } = await this.parse(ContentRevert)
+    const runId = args.run
+    this.auditKey = runId
+    const resolutions: Record<string, RevertResolution> = {}
+    for (const pair of flags.resolve) {
+      const eq = pair.indexOf('=')
+      const choice = eq >= 0 ? pair.slice(eq + 1) : ''
+      if (eq < 0 || !isRevertResolution(choice))
+        this.fail('usage', `--resolve wants <key>=${REVERT_RESOLUTIONS.join('|')}, not "${pair}".`)
+      resolutions[pair.slice(0, eq)] = choice
+    }
+    const config = await siteConfig()
+    const backup = await backupBefore(config, {
+      reason: 'content-revert',
+      backupTaken: flags['backup-taken'],
+    })
+    if (backup.path) this.progress(`  backup   ${backup.path}`)
+
+    const { db } = await bootstrapDatabase(config)
+    try {
+      const started = performance.now()
+      const result = await revertRun(db, runId, {
+        resolutions,
+        resolveAll: flags['resolve-all'] as RevertResolution | undefined,
+        force: flags.force,
+        nodeId: config.nodeId,
+        backOfficePath: config.backOfficePath,
+      })
+
+      if (!result.runId)
+        this.fail(
+          'refused',
+          'revert refused. Nothing was changed.',
+          'Answer the findings with --resolve, or pass --force.',
+          result.check.findings.map((f) => ({
+            kind: f.kind,
+            code: f.code,
+            message: f.message,
+            answers: revertResolutionsFor(f.code),
+          })),
+        )
+
+      // The files an install replaced come back from the run's own copies, not
+      // from git: these files are editable in the backoffice, so a site need not
+      // be a checkout at all.
+      const files = await ops.revertSections(db, config, runId)
+      for (const file of files.restored) this.say(`  restored ${here(file)}`)
+      for (const file of files.removed) this.say(`  removed  ${here(file)}  (created by that run)`)
+      if (files.schema) this.say(`  schema   ${files.schema}`)
+      if (files.dictionary) this.say('  restored the dictionary')
+
+      for (const key of result.restored) this.say(`  restored ${key}`)
+      for (const key of result.recycled) this.say(`  recycled ${key}  (created by that run)`)
+      for (const entry of result.check.plan.filter((p) => p.action === 'skip'))
+        this.say(`  left     ${entry.name}`)
+      await recordInLedger(db, {
+        name: `content revert ${runId}`,
+        kind: 'revert',
+        durationMs: Math.round(performance.now() - started),
+        appliedBy: config.nodeId,
+        note: `run ${result.runId}`,
+      })
+      this.say(
+        `\nReverted ${runId} as run ${result.runId}. ` +
+          `\`crombolo content revert ${result.runId}\` would put it back again.`,
+      )
+      return {
+        runId: result.runId,
+        reverted: runId,
+        restored: result.restored,
+        recycled: result.recycled,
+        files: {
+          restored: files.restored.map(here),
+          removed: files.removed.map(here),
+          schema: files.schema ?? null,
+          dictionary: Boolean(files.dictionary),
+        },
+        backup: backup.path ?? null,
+      }
+    } finally {
+      await db.close()
+    }
+  }
+}

package/src/commands/content/runs.ts

@@ -0,0 +1,62 @@
+import { TransferRunRepository } from '@crombolo/data'
+import { bootstrapDatabase } from '@crombolo/server'
+import { BaseCommand } from '../../base.ts'
+import { page, pageFlags, pagination } from '../../support/flags.ts'
+import { siteConfig } from '../../support/site.ts'
+
+export default class ContentRuns extends BaseCommand {
+  static override summary = 'the imports applied here, newest first'
+  static override flags = { ...pageFlags(20) }
+  static override spec = {
+    effects: 'read_only',
+    cardinality: 'unbounded',
+    pagination,
+    fieldsArg: '--fields',
+    outputFields: [
+      { name: 'id', type: 'string' },
+      { name: 'startedAt', type: 'string' },
+      { name: 'direction', type: 'string' },
+      { name: 'status', type: 'string' },
+      { name: 'nodeCount', type: 'integer' },
+      { name: 'bundleId', type: 'string' },
+      { name: 'bundleLabel', type: 'string', nullable: true },
+      { name: 'appliedBy', type: 'string', nullable: true },
+    ],
+  } as const
+
+  async run() {
+    const { flags } = await this.parse(ContentRuns)
+    const { db } = await bootstrapDatabase(await siteConfig())
+    try {
+      const repository = new TransferRunRepository(db)
+      const [runs, total] = await Promise.all([
+        repository.recent(flags.limit, flags.offset),
+        repository.count(),
+      ])
+      if (runs.length === 0) this.say('No content has been imported here.')
+      const items = runs.map((run) => ({
+        id: run.id,
+        startedAt: run.startedAt.toISOString(),
+        direction: run.direction,
+        status: run.status,
+        nodeCount: run.nodeCount,
+        bundleId: run.bundleId,
+        bundleLabel: run.bundleLabel ?? null,
+        appliedBy: run.appliedBy ?? null,
+      }))
+      for (const run of items)
+        this.say(
+          `  ${run.startedAt}  ${run.direction.padEnd(6)} ${run.status.padEnd(8)} ` +
+            `${run.id}  ${run.nodeCount} node(s)  bundle ${run.bundleId}` +
+            `${run.appliedBy ? `  by ${run.appliedBy}` : ''}${run.bundleLabel ? `  (${run.bundleLabel})` : ''}`,
+        )
+      if (flags.offset + runs.length < total)
+        this.say(
+          `  … ${total - flags.offset - runs.length} more: --offset ${flags.offset + runs.length}`,
+        )
+      return page(items, total, flags)
+    } finally {
+      await db.close()
+    }
+  }
+}

package/src/commands/content/unpublish.ts

@@ -0,0 +1,21 @@
+import { BaseCommand } from '../../base.ts'
+import { publishArgs, publishFlags, publishPages, publishSpec } from '../../support/publish.ts'
+
+export default class ContentUnpublish extends BaseCommand {
+  static override summary = 'take a page down; --descendants for the branch below it'
+  static override description = '--culture per culture; --at and --until schedule it instead.'
+  static override args = publishArgs
+  static override flags = publishFlags
+  static override audit = {
+    category: 'content',
+    action: 'Unpublish',
+    entityType: 'Document',
+  } as const
+  static override spec = publishSpec
+
+  async run() {
+    const { args, flags } = await this.parse(ContentUnpublish)
+    this.auditKey = args.page
+    return publishPages(this, false, args.page, flags)
+  }
+}

package/src/commands/dictionary/export.ts

@@ -0,0 +1,49 @@
+import { mkdir, writeFile } from 'node:fs/promises'
+import { join } from 'node:path'
+import { DictionaryRepository } from '@crombolo/data'
+import { bootstrapDatabase, dictionaryToUdt, writeDictionaryUdt } from '@crombolo/server'
+import { Flags } from '@oclif/core'
+import { BaseCommand } from '../../base.ts'
+import { here } from '../../support/describe.ts'
+import { siteConfig } from '../../support/site.ts'
+
+/**
+ * The dictionary stays in the database, because translators work in
+ * production where `schema/` is read-only — so this is how a lower environment
+ * gets the translations.
+ */
+export default class DictionaryExport extends BaseCommand {
+  static override summary = "the dictionary as Umbraco's .udt, to seed another environment"
+  static override flags = {
+    out: Flags.string({ summary: 'the file to write', helpValue: '<file.udt>', required: true }),
+    key: Flags.string({ summary: 'only this item and its children', helpValue: '<uuid>' }),
+  }
+  static override spec = {
+    effects: 'idempotent',
+    cardinality: 'single',
+    outputFields: [
+      { name: 'wrote', type: 'string' },
+      { name: 'items', type: 'integer' },
+    ],
+    errors: ['not_found'],
+  } as const
+
+  async run() {
+    const { flags } = await this.parse(DictionaryExport)
+    const { db } = await bootstrapDatabase(await siteConfig())
+    try {
+      const items = await dictionaryToUdt(new DictionaryRepository(db), flags.key)
+      if (items.length === 0)
+        this.fail('not_found', 'Nothing to export: this site has no dictionary items.')
+      await mkdir(join(flags.out, '..'), { recursive: true })
+      await writeFile(flags.out, writeDictionaryUdt(items))
+      const count = (list: typeof items): number =>
+        list.reduce((total, item) => total + 1 + count(item.children), 0)
+      this.say(`  wrote    ${here(flags.out)}`)
+      this.say(`  items    ${count(items)}`)
+      return { wrote: here(flags.out), items: count(items) }
+    } finally {
+      await db.close()
+    }
+  }
+}

package/src/commands/dictionary/import.ts

@@ -0,0 +1,46 @@
+import { existsSync } from 'node:fs'
+import { bootstrapDatabase, importDictionaryUdt } from '@crombolo/server'
+import { Args } from '@oclif/core'
+import { BaseCommand } from '../../base.ts'
+import { siteConfig } from '../../support/site.ts'
+
+export default class DictionaryImport extends BaseCommand {
+  static override summary = 'apply a .udt file: items upsert by key'
+  static override description =
+    'A translation for a language this site has not got is skipped, and said so.'
+  static override args = { file: Args.string({ required: true, description: 'the .udt file' }) }
+  static override audit = {
+    category: 'settings',
+    action: 'Import',
+    entityType: 'DictionaryItem',
+  } as const
+  static override spec = {
+    effects: 'idempotent',
+    cardinality: 'single',
+    outputFields: [
+      { name: 'imported', type: 'integer' },
+      { name: 'skipped', type: 'array', items: { type: 'string' } },
+    ],
+    errors: ['not_found', 'refused'],
+  } as const
+
+  async run() {
+    const { args } = await this.parse(DictionaryImport)
+    if (!existsSync(args.file)) this.fail('not_found', `No file at ${args.file}.`)
+    const { db } = await bootstrapDatabase(await siteConfig())
+    try {
+      const outcome = await importDictionaryUdt(db, await Bun.file(args.file).text(), null)
+      if (!outcome.ok) this.fail('refused', `refused: ${outcome.reason}`)
+      this.say(`  imported ${outcome.imported} item(s)`)
+      // Umbraco's own behaviour, and worth saying out loud rather than dropping
+      // translations silently: a language this site has not got is skipped.
+      if (outcome.skipped.length > 0)
+        this.say(
+          `  skipped  translations for ${outcome.skipped.join(', ')} — no such language here`,
+        )
+      return { imported: outcome.imported, skipped: outcome.skipped }
+    } finally {
+      await db.close()
+    }
+  }
+}

package/src/commands/domains/apply.ts

@@ -0,0 +1,23 @@
+import { BaseCommand } from '../../base.ts'
+import { appliedFields, applyDomains } from '../../support/domains.ts'
+import { siteConfig } from '../../support/site.ts'
+
+export default class DomainsApply extends BaseCommand {
+  static override summary = 'apply domains.toml here, as a boot does'
+  static override audit = {
+    category: 'settings',
+    action: 'ApplyDomains',
+    entityType: 'Domain',
+  } as const
+  static override spec = {
+    effects: 'idempotent',
+    cardinality: 'bounded',
+    outputFields: appliedFields,
+    errors: ['refused'],
+  } as const
+
+  async run() {
+    await this.parse(DomainsApply)
+    return applyDomains(this, await siteConfig())
+  }
+}

package/src/commands/domains/clear.ts

@@ -0,0 +1,27 @@
+import { Args } from '@oclif/core'
+import { BaseCommand } from '../../base.ts'
+import { appliedFields, rewriteDomains } from '../../support/domains.ts'
+import { siteConfig } from '../../support/site.ts'
+
+export default class DomainsClear extends BaseCommand {
+  static override summary = 'unbind a page, in the file and in the database'
+  static override args = {
+    page: Args.string({ required: true, description: 'a path, a uuid, or / for the root page' }),
+  }
+  static override audit = {
+    category: 'settings',
+    action: 'ClearDomains',
+    entityType: 'Domain',
+  } as const
+  static override spec = {
+    effects: 'idempotent',
+    cardinality: 'bounded',
+    outputFields: [{ name: 'wrote', type: 'string' }, ...appliedFields],
+    errors: ['not_found', 'refused'],
+  } as const
+
+  async run() {
+    const { args } = await this.parse(DomainsClear)
+    return rewriteDomains(this, await siteConfig(), args.page, [])
+  }
+}

package/src/commands/domains/index.ts

@@ -0,0 +1,6 @@
+import DomainsList from './list.ts'
+
+/** `crombolo domains` on its own lists them. */
+export default class Domains extends DomainsList {
+  static override hidden = true
+}

package/src/commands/domains/list.ts

@@ -0,0 +1,86 @@
+import { DomainRepository, NodeRepository } from '@crombolo/data'
+import { bootstrapDatabase, DOMAINS_FILE, resolvePlaceholders } from '@crombolo/server'
+import { BaseCommand } from '../../base.ts'
+import { readDeclarations } from '../../support/domains.ts'
+import { siteConfig } from '../../support/site.ts'
+
+export default class DomainsList extends BaseCommand {
+  static override summary = 'the hostnames domains.toml declares, and what is bound here'
+  static override spec = {
+    effects: 'read_only',
+    cardinality: 'bounded',
+    outputFields: [
+      {
+        name: 'file',
+        type: 'array',
+        items: {
+          type: 'object',
+          fields: [
+            { name: 'node', type: 'string' },
+            { name: 'host', type: 'string' },
+            { name: 'resolved', type: 'string' },
+            { name: 'missing', type: 'array', items: { type: 'string' } },
+            { name: 'culture', type: 'string', nullable: true },
+          ],
+        },
+      },
+      {
+        name: 'bound',
+        type: 'array',
+        items: {
+          type: 'object',
+          fields: [
+            { name: 'node', type: 'string' },
+            { name: 'host', type: 'string' },
+            { name: 'culture', type: 'string', nullable: true },
+          ],
+        },
+      },
+    ],
+  } as const
+
+  async run() {
+    await this.parse(this.ctor)
+    const config = await siteConfig()
+    const { read, declarations } = readDeclarations(this, config)
+    const { db } = await bootstrapDatabase(config)
+    try {
+      if (!read) this.say(`No ${DOMAINS_FILE}; nothing is deployed from a file here.`)
+      const file = declarations.map((declaration) => {
+        const resolved = resolvePlaceholders(declaration.host)
+        // What the file says, and what it comes to here, which is the whole
+        // point of a placeholder and the first thing to check when one is wrong.
+        const note =
+          resolved.missing.length > 0
+            ? `  (${resolved.missing.join(', ')} not set here)`
+            : resolved.value !== declaration.host
+              ? ` → ${resolved.value}`
+              : ''
+        this.say(
+          `  file     ${declaration.node.padEnd(24)} ${declaration.host}${note}${declaration.culture ? `  ${declaration.culture}` : ''}`,
+        )
+        return {
+          node: declaration.node,
+          host: declaration.host,
+          resolved: resolved.value,
+          missing: resolved.missing,
+          culture: declaration.culture ?? null,
+        }
+      })
+      // What the database actually answers on, which is the thing a person is
+      // usually asking about when a hostname is not working.
+      const nodes = new NodeRepository(db)
+      const bound = []
+      for (const row of await new DomainRepository(db).all()) {
+        const node = (await nodes.byId(row.nodeId))?.text ?? String(row.nodeId)
+        this.say(
+          `  bound    ${node.padEnd(24)} ${row.domainName}${row.isoCode ? `  ${row.isoCode}` : ''}`,
+        )
+        bound.push({ node, host: row.domainName, culture: row.isoCode ?? null })
+      }
+      return { file, bound }
+    } finally {
+      await db.close()
+    }
+  }
+}

package/src/commands/domains/set.ts

@@ -0,0 +1,55 @@
+import type { DomainDeclaration } from '@crombolo/server'
+import { Args, Flags } from '@oclif/core'
+import { BaseCommand } from '../../base.ts'
+import { appliedFields, rewriteDomains } from '../../support/domains.ts'
+import { many } from '../../support/flags.ts'
+import { siteConfig } from '../../support/site.ts'
+
+export default class DomainsSet extends BaseCommand {
+  static override summary = "write a page's hostnames to domains.toml and apply it"
+  static override description =
+    `The page's hostnames are replaced, so running it twice is running it once. \${VAR} in a host is read from the environment when it is applied.`
+  static override examples = [
+    '<%= config.bin %> domains set / --host example.com --host fr.example.com=fr-FR',
+  ]
+  static override args = {
+    page: Args.string({ required: true, description: 'a path, a uuid, or / for the root page' }),
+  }
+  static override flags = {
+    host: many('a hostname, with its culture after =; repeatable', '<host>[=<culture>]'),
+    'default-culture': Flags.string({ summary: "the page's fallback culture", helpValue: '<iso>' }),
+  }
+  static override audit = {
+    category: 'settings',
+    action: 'SetDomains',
+    entityType: 'Domain',
+  } as const
+  static override spec = {
+    effects: 'idempotent',
+    cardinality: 'bounded',
+    outputFields: [{ name: 'wrote', type: 'string' }, ...appliedFields],
+    errors: ['usage', 'not_found', 'refused'],
+  } as const
+
+  async run() {
+    const { args, flags } = await this.parse(DomainsSet)
+    const defaultCulture = flags['default-culture']
+    if (flags.host.length === 0 && !defaultCulture)
+      this.fail('usage', 'domains set needs --host <host>[=<culture>], or --default-culture <iso>.')
+    const add: DomainDeclaration[] = []
+    if (flags.host.length === 0 && defaultCulture)
+      add.push({ node: args.page, host: '', defaultCulture })
+    for (const [index, entry] of flags.host.entries()) {
+      const [host = '', culture] = entry.split('=')
+      add.push({
+        node: args.page,
+        host,
+        culture,
+        // The node's own fallback culture belongs to the node, so it is written
+        // once rather than repeated on every hostname.
+        defaultCulture: index === 0 ? defaultCulture : undefined,
+      })
+    }
+    return rewriteDomains(this, await siteConfig(), args.page, add)
+  }
+}

package/src/commands/domains/undo.ts

@@ -0,0 +1,29 @@
+import { undoDomainsFile } from '@crombolo/server'
+import { BaseCommand } from '../../base.ts'
+import { here } from '../../support/describe.ts'
+import { appliedFields, applyDomains } from '../../support/domains.ts'
+import { siteConfig } from '../../support/site.ts'
+
+export default class DomainsUndo extends BaseCommand {
+  static override summary = 'put back the file the last write replaced, and apply it'
+  static override audit = {
+    category: 'settings',
+    action: 'UndoDomains',
+    entityType: 'Domain',
+  } as const
+  static override spec = {
+    effects: 'non_idempotent',
+    cardinality: 'bounded',
+    outputFields: [{ name: 'restored', type: 'string' }, ...appliedFields],
+    errors: ['not_found', 'refused'],
+  } as const
+
+  async run() {
+    await this.parse(DomainsUndo)
+    const config = await siteConfig()
+    const undone = await undoDomainsFile(config.siteDir)
+    if (!undone.ok) this.fail('not_found', undone.message ?? 'There is nothing to undo.')
+    this.say(`  restored ${here(undone.file)}`)
+    return { restored: here(undone.file), ...(await applyDomains(this, config)) }
+  }
+}

package/src/commands/export.ts

@@ -0,0 +1,100 @@
+import { resolve } from 'node:path'
+import { packageNameFor } from '@crombolo/transfer'
+import { Flags } from '@oclif/core'
+import { BaseCommand } from '../base.ts'
+import * as ops from '../operations/commands.ts'
+import { counted, describeBytes, here } from '../support/describe.ts'
+import { passphraseToSeal } from '../support/prompt.ts'
+import { siteConfig } from '../support/site.ts'
+
+/** The whole site as one file (story 104). */
+export default class Export extends BaseCommand {
+  static override summary =
+    'write the whole site to one file, to move it to another machine or host'
+  static override description = [
+    'Schema, components, styles, scripts, dictionary, every page and media item and their files. Domains and people stay behind unless --with-members or --with-users, which are encrypted.',
+    '--anonymise replaces every personal value as it writes.',
+  ].join('\n\n')
+  static override examples = ['<%= config.bin %> export --site --out site.tgz']
+  static override flags = {
+    site: Flags.boolean({
+      summary: 'the whole site (required: a part of it is `content export`)',
+      required: true,
+    }),
+    out: Flags.string({ summary: 'the file to write', helpValue: '<file.tgz>' }),
+    'no-media': Flags.boolean({ summary: 'leave the media files out' }),
+    drafts: Flags.boolean({ summary: 'drafts too' }),
+    'with-members': Flags.boolean({ summary: 'members, encrypted' }),
+    'with-users': Flags.boolean({ summary: 'back-office users, encrypted' }),
+    anonymise: Flags.boolean({ summary: 'replace every personal value as it writes' }),
+    name: Flags.string({ summary: "the package's npm name", helpValue: '<npm name>' }),
+    'package-version': Flags.string({ summary: "the package's version", helpValue: '<version>' }),
+  }
+  static override spec = {
+    effects: 'non_idempotent',
+    cardinality: 'single',
+    outputFields: [
+      { name: 'out', type: 'string' },
+      { name: 'package', type: 'object' },
+      { name: 'counts', type: 'object' },
+      { name: 'sections', type: 'object' },
+      { name: 'media', type: 'object' },
+      { name: 'people', type: 'object' },
+      { name: 'anonymised', type: 'integer', nullable: true },
+    ],
+    errors: ['usage', 'auth', 'io'],
+  } as const
+
+  async run() {
+    const { flags } = await this.parse(Export)
+    const config = await siteConfig()
+    const withPeople = flags['with-members'] || flags['with-users']
+    const out = resolve(
+      flags.out ??
+        `${packageNameFor(`${config.siteName}-site`)}-${new Date().toISOString().slice(0, 10)}.tgz`,
+    )
+    const result = await ops.siteExport(config, {
+      out,
+      media: !flags['no-media'],
+      drafts: flags.drafts,
+      withMembers: flags['with-members'],
+      withUsers: flags['with-users'],
+      anonymise: flags.anonymise,
+      passphrase:
+        withPeople && !(flags.anonymise && !flags['with-members'])
+          ? await passphraseToSeal()
+          : undefined,
+      package: { name: flags.name, version: flags['package-version'] },
+    })
+    this.say(`  wrote    ${here(result.out)}`)
+    this.say(`  package  ${result.package.name}@${result.package.version} (private)`)
+    this.say(`  content  ${counted(result.counts, 'none')}, unencrypted`)
+    if (Object.keys(result.sections).length > 0) this.say(`  files    ${counted(result.sections)}`)
+    if (result.media.omitted)
+      this.say(
+        '  media    left out (--no-media): importing it brings the media items without their files',
+      )
+    else
+      this.say(`  media    ${result.media.carried} file(s), ${describeBytes(result.media.bytes)}`)
+    for (const key of result.media.missing)
+      this.warning(`  missing  ${key} is not in this environment's media store`)
+    if (result.people.members + result.people.users > 0)
+      this.say(
+        `  people   ${result.people.members} member(s), ${result.people.users} user(s), encrypted`,
+      )
+    else this.say('  people   left out: pass --with-members or --with-users to bring them')
+    if (result.anonymised !== undefined)
+      this.say(
+        `  anonymised  ${result.anonymised} email address(es) replaced; no back-office users`,
+      )
+    return {
+      out: here(result.out),
+      package: result.package,
+      counts: result.counts,
+      sections: result.sections,
+      media: result.media,
+      people: result.people,
+      anonymised: result.anonymised ?? null,
+    }
+  }
+}