@alchemint/fuse-cli 0.0.0-stage → 0.1.0

package/src/element-images.mjs

@@ -0,0 +1,257 @@
+import path from 'node:path';
+import { CliError, need, id } from './core.mjs';
+import { uploadWithReceipt } from './assets.mjs';
+
+// DEV-2053 / DEV-2058: a character's, scene's or prop's images live on the
+// library Asset it points to — one 角色設定圖／主圖 (versions, one current)
+// plus 其他圖片; every Creative that points at the Asset sees all of them
+// (DEV-2077 retired the per-Creative picks).
+const ROLES = ['setting', 'other'];
+
+const NOUNS = {
+  character: {
+    flag: '--character',
+    option: 'character',
+    idKey: 'character_id',
+    segment: 'characters',
+    readList: 'characters',
+    setting: '角色設定圖',
+    elementsOf: (elements) =>
+      elements.characters.map((row) => ({ id: row.id, name: row.name })),
+  },
+  art: {
+    flag: '--element',
+    option: 'element',
+    idKey: 'element_id',
+    segment: 'art-elements',
+    readList: 'art_elements',
+    setting: '主圖',
+    elementsOf: (elements) => [
+      ...elements.scene_settings.map((row) => ({
+        id: row.id,
+        name: row.name,
+        type: 'scene',
+      })),
+      ...elements.props.map((row) => ({
+        id: row.id,
+        name: row.name,
+        type: 'prop',
+      })),
+    ],
+  },
+};
+
+const elementImages = (client, creativeId) =>
+  client.get(`/storyboards/${id(creativeId, '--creative')}/image-slots`);
+const librarySummary = (asset) =>
+  asset && {
+    asset_id: asset.asset_id,
+    name: asset.name,
+    usable: asset.usable,
+    ...(asset.usable
+      ? { setting_result_id: asset.representation_result_id }
+      : { reason: asset.reason }),
+  };
+const imagesSummary = (images) => ({
+  ready: images.ready,
+  library_asset: librarySummary(images.library_asset),
+  setting: {
+    current_result_id: images.setting.current_version_id,
+    versions: images.setting.versions.map((version) => ({
+      result_id: version.id,
+      source: version.source,
+      status: version.status,
+      upload_name: version.upload_name,
+    })),
+  },
+  other_images: images.other_images.map((image) => ({
+    result_id: image.id,
+    name: image.name,
+  })),
+});
+// Every image of the element as it reads now: setting versions and other images.
+const imageIdsOf = (images) => [
+  ...images.setting.versions.map((version) => version.id),
+  ...images.other_images.map((image) => image.id),
+];
+
+function command(nounKey) {
+  const noun = NOUNS[nounKey];
+  const imagesOf = (read, elementId) =>
+    read[noun.readList].find((item) => item[noun.idKey] === elementId);
+  const endpoint = (creativeId, elementId) =>
+    `/storyboards/${id(creativeId, '--creative')}/story-elements/${noun.segment}/${id(elementId, noun.flag)}`;
+
+  // image-uploads: setting → a candidate 角色設定圖／主圖 version on the
+  // element's Asset; other → a 其他圖片 on the Asset.
+  // The first upload creates the library Asset. The receipt keeps the images
+  // from before the upload, so the new one identifies where it landed.
+  const upload = (options, context) => ({
+    kind: `${nounKey}_image_upload`,
+    command: `${nounKey} upload`,
+    async metadata(media) {
+      const role = need(options.role, '--role (setting|other)');
+      if (!ROLES.includes(role))
+        throw new CliError(2, 'INVALID_ROLE', 'Use --role setting or other.');
+      return {
+        creative_id: need(options.creative, '--creative'),
+        [noun.idKey]: need(options[noun.option], noun.flag),
+        role,
+        name: (options.name || path.basename(media)).slice(0, 100),
+      };
+    },
+    async accept(receipt, save) {
+      const { creative_id, role, name } = receipt.metadata;
+      const elementId = receipt.metadata[noun.idKey];
+      if (!receipt.images_before) {
+        const before = imagesOf(
+          await elementImages(context.client, creative_id),
+          elementId,
+        );
+        receipt.images_before = imageIdsOf(before);
+        await save();
+      }
+      const after = imagesOf(
+        await context.client.post(
+          `${endpoint(creative_id, elementId)}/image-uploads`,
+          { receipt_id: receipt.ready_receipt_id, role, name },
+        ),
+        elementId,
+      );
+      const added = imageIdsOf(after).filter(
+        (imageId) => !receipt.images_before.includes(imageId),
+      );
+      if (added.length !== 1)
+        throw new CliError(
+          5,
+          'UPLOAD_IMAGE_UNKNOWN',
+          `The upload was accepted, but the image is not identifiable; read fuse ${nounKey} list.`,
+        );
+      receipt.result_id = added[0];
+      receipt.asset_id = after.library_asset.asset_id;
+    },
+    async result(receipt, file) {
+      const { creative_id, role } = receipt.metadata;
+      const elementId = receipt.metadata[noun.idKey];
+      const images = imagesOf(
+        await elementImages(context.client, creative_id),
+        elementId,
+      );
+      const landed =
+        role === 'setting'
+          ? images.setting.versions.some(
+              (version) => version.id === receipt.result_id,
+            )
+          : images.other_images.some((image) => image.id === receipt.result_id);
+      if (!landed || images.library_asset?.asset_id !== receipt.asset_id)
+        throw new CliError(
+          4,
+          'UPLOAD_READBACK_DIFFERS',
+          `The uploaded image does not read back on the ${nounKey}.`,
+        );
+      return {
+        creative_id,
+        [noun.idKey]: elementId,
+        role,
+        asset_id: receipt.asset_id,
+        result_id: receipt.result_id,
+        current: images.setting.current_version_id === receipt.result_id,
+        receipt: file,
+        upload_session_id: receipt.session_id,
+        ready_receipt_id: receipt.ready_receipt_id,
+      };
+    },
+  });
+
+  return async (action, positional, options, context) => {
+    if (action === 'list') {
+      const creativeId = need(options.creative, '--creative');
+      const [elements, read] = await Promise.all([
+        context.client.get(`/storyboards/${id(creativeId)}/story-elements`),
+        elementImages(context.client, creativeId),
+      ]);
+      if (options.full) return { story_elements: elements, images: read };
+      return {
+        creative_id: creativeId,
+        [noun.readList]: noun.elementsOf(elements).map((row) => ({
+          [noun.idKey]: row.id,
+          name: row.name,
+          ...(row.type ? { type: row.type } : {}),
+          ...imagesSummary(imagesOf(read, row.id)),
+        })),
+      };
+    }
+    if (action === 'upload')
+      return uploadWithReceipt(options, context, upload(options, context));
+    const creativeId = need(options.creative, '--creative');
+    const elementId = need(options[noun.option], noun.flag);
+    const base = endpoint(creativeId, elementId);
+    const done = (read, expected, code, message) => {
+      const images = imagesOf(read, elementId);
+      if (!expected(images)) throw new CliError(4, code, message);
+      return {
+        creative_id: creativeId,
+        [noun.idKey]: elementId,
+        ...imagesSummary(images),
+      };
+    };
+    if (action === 'adopt') {
+      const resultId = need(options.result, '--result');
+      return done(
+        await context.client.post(`${base}/setting-image`, {
+          result_id: resultId,
+        }),
+        (images) => images.setting.current_version_id === resultId,
+        'ADOPTION_READBACK_DIFFERS',
+        `The ${nounKey} does not read back the adopted ${noun.setting}.`,
+      );
+    }
+    if (action === 'link') {
+      const assetId = need(options.asset, '--asset');
+      return done(
+        await context.client.request('PUT', `${base}/library-asset`, {
+          asset_id: assetId,
+        }),
+        (images) => images.library_asset?.asset_id === assetId,
+        'LINK_READBACK_DIFFERS',
+        `The ${nounKey} does not read back the requested library Asset.`,
+      );
+    }
+    // image delete (DEV-2176): the image lives on the element's library Asset,
+    // so the delete goes to the Asset. The element read before it names the
+    // Asset and proves the image is one of this element's images now; the read
+    // after it proves the image is gone.
+    if (action === 'image' && positional === 'delete') {
+      const resultId = need(options.result, '--result');
+      const before = imagesOf(
+        await elementImages(context.client, creativeId),
+        elementId,
+      );
+      if (!before.library_asset || !imageIdsOf(before).includes(resultId))
+        throw new CliError(
+          4,
+          'IMAGE_NOT_FOUND',
+          `The ${nounKey} has no image ${resultId}; read fuse ${nounKey} list.`,
+        );
+      await context.client.request(
+        'DELETE',
+        `/assets/${id(before.library_asset.asset_id, 'asset')}/images/${id(resultId, '--result')}`,
+      );
+      const after = done(
+        await elementImages(context.client, creativeId),
+        (images) => !imageIdsOf(images).includes(resultId),
+        'DELETE_READBACK_DIFFERS',
+        `The ${nounKey} still reads back image ${resultId}.`,
+      );
+      return { ...after, deleted_result_id: resultId };
+    }
+    throw new CliError(
+      2,
+      'UNKNOWN_COMMAND',
+      `Use ${nounKey} list, upload, adopt, link, or image delete.`,
+    );
+  };
+}
+
+export const character = command('character');
+export const art = command('art');

package/src/main.mjs

@@ -0,0 +1,276 @@
+#!/usr/bin/env node
+import { parseArgs } from 'node:util';
+import {
+  apiBase,
+  Client,
+  CliError,
+  loadCredential,
+  errorData,
+  project,
+} from './core.mjs';
+import { auth } from './auth.mjs';
+import { models, videoSubmit, job, cancel } from './video.mjs';
+import { download } from './download.mjs';
+import { batch } from './batch.mjs';
+import { assets } from './assets.mjs';
+import { art, character } from './element-images.mjs';
+import { creative, script, shot, take } from './creative.mjs';
+import { prompt } from './prompt.mjs';
+import { version } from './versions.mjs';
+
+const stringFlags = [
+  'api-url',
+  'fields',
+  'device-name',
+  'timeout',
+  'stage',
+  'key',
+  'request-file',
+  'receipt',
+  'creative',
+  'generation-target',
+  'entry',
+  'shot',
+  'job',
+  'result',
+  'asset',
+  'out',
+  'state',
+  'limit',
+  'idempotency-key',
+  'file',
+  'version-id',
+  'episode',
+  'name',
+  'seed-file',
+  'page',
+  'cursor',
+  'type',
+  'content-type',
+  'pricing-key',
+  'character',
+  'element',
+  'kind',
+  'number',
+  'from',
+  'to',
+];
+const booleanFlags = [
+  'json',
+  'help',
+  'version',
+  'no-browser',
+  'full',
+  'resume',
+  'retry-rejected',
+];
+const help = `FUSE CLI 0.1.0 — Node 22; normal FUSE API, no GPU or database access.
+
+fuse auth login [--no-browser] [--device-name NAME]  # browser approval, independent session
+fuse auth status | auth logout                     # read identity / revoke this session
+fuse models list --stage video | models show --key EXACT_PRICING_KEY
+fuse video submit --creative UUID --request-file request.json --receipt take.json
+fuse video submit --receipt take.json --resume       # reconcile exact saved body/key
+fuse video submit --receipt take.json --resume --retry-rejected  # explicitly retry an unaccepted rejection
+fuse job show --receipt take.json
+fuse job watch --receipt take.json --timeout 30m     # read only; exiting does not cancel
+fuse job cancel --receipt take.json | job cancel --job UUID  # queued in FUSE (refunds the owner), or an open-source take already on its machine (no charge; the machine is told to stop)
+fuse download take --receipt take.json --out take.mp4
+fuse download take --creative UUID --shot N [--result UUID] --out take.mp4  # selected take unless --result
+fuse download asset --asset UUID --result UUID --out asset.png
+fuse batch plan comparison.json --out comparison.plan.json  # read API; freeze inputs
+fuse batch run comparison.plan.json --state ./run --timeout 2h
+fuse batch status ./run | batch resume ./run | batch download ./run --out ./videos
+fuse batch cancel ./run                              # stop the batch writer first; cancels queued Jobs and open-source takes on their machine, withdraws unsubmitted items
+
+fuse asset list [--cursor UUID] [--type character|scene|prop]
+fuse asset show --asset UUID [--out asset.json]
+fuse asset upload --file previz.mp4 --content-type video/mp4 --request-file asset.json --receipt upload.json
+fuse asset upload --receipt upload.json --resume     # same Upload session, ready then Asset adoption
+fuse asset link --asset UUID --request-file links.json  # {creative_ids,asset_ids}
+fuse asset unlink --asset UUID --creative UUID      # remove from that Creative's collection; stays in the library
+fuse asset canonical --asset UUID --result UUID     # make that setting-image version current
+fuse asset update --asset UUID --name NAME
+fuse character list --creative UUID                 # each character's library Asset, 角色設定圖 versions and 其他圖片
+fuse character upload --creative UUID --character UUID --role setting|other --file image.png --content-type image/png --receipt upload.json [--name NAME]
+                                                   # setting: candidate 角色設定圖 version; other: a 其他圖片 on the Asset
+fuse character upload --receipt upload.json --resume # same Upload session and acceptance
+fuse character adopt --creative UUID --character UUID --result UUID  # make that 角色設定圖 version current on the Asset
+fuse character link --creative UUID --character UUID --asset UUID  # point the character at another library character Asset
+fuse character image delete --creative UUID --character UUID --result UUID  # delete an uploaded image: a candidate 角色設定圖 version or a 其他圖片
+fuse art list --creative UUID                       # each scene/prop's library Asset, 主圖 versions and 其他圖片
+fuse art upload --creative UUID --element UUID --role setting|other --file image.png --content-type image/png --receipt upload.json [--name NAME]
+                                                   # setting: candidate 主圖 version; other: a 其他圖片 on the Asset
+fuse art upload --receipt upload.json --resume      # same Upload session and acceptance
+fuse art adopt --creative UUID --element UUID --result UUID  # make that 主圖 version current on the Asset
+fuse art link --creative UUID --element UUID --asset UUID  # point the scene/prop at another library Asset of the same type
+fuse art image delete --creative UUID --element UUID --result UUID  # delete an uploaded image: a candidate 主圖 version or a 其他圖片
+fuse creative create --seed-file seed.txt --entry idea|script --generation-target script|video --receipt creative.json
+                                                   # idea: pitch_package then Episode scripts; script: imported verbatim (video adds storyboards)
+fuse creative list --page 1 --limit 20 | creative show --creative UUID
+fuse creative rename --creative UUID --name NAME
+fuse script get --creative UUID --version-id UUID [--out script.json]  # lists each Episode: number, episode_id, title, shot_count, editing
+fuse script get --creative UUID --version-id UUID --episode N|UUID --out episode.json  # one Episode as a script put body
+fuse script put --creative UUID --version-id UUID --episode N|UUID --file episode.json  # {shots,deleted_shot_ids}: one Episode
+fuse script episode add --creative UUID --version-id UUID --name TITLE  # appended as the last Episode
+fuse script episode rename --creative UUID --version-id UUID --episode N|UUID --name TITLE
+fuse script episode move --creative UUID --version-id UUID --episode N|UUID --to N  # it becomes Episode N
+fuse shot update --creative UUID --shot N --request-file shot.json
+fuse shot move --creative UUID --shot N --request-file position.json  # {position}: playback order
+fuse version list --creative UUID --shot N [--stage i2v|t2i]   # every version: draft / queued / running / succeeded / failed
+fuse version new --creative UUID --shot N [--stage i2v] [--from 2] [--request-file draft.json]
+                                                   # adds the next number as a draft; --from copies that version's draft
+fuse version draft get --creative UUID --shot N --number 4 [--stage i2v] --out draft.json
+fuse version draft set --creative UUID --shot N --number 4 [--stage i2v] --request-file draft.json
+fuse version submit --creative UUID --shot N --number 4 [--stage i2v] --receipt v4.json [--request-file body.json]
+fuse version submit --receipt v4.json --resume [--retry-rejected]   # same receipt discipline as video submit
+fuse version delete --creative UUID --shot N --number 4 [--stage i2v]   # drafts only; numbers are never reused
+fuse prompt optimize --request-file refine.json --receipt prompt.json
+fuse prompt result --job REQUEST_UUID --out suggestion.json
+fuse prompt adopt --creative UUID --shot N --number 4 --job REQUEST_UUID --request-file adopted-draft.json
+fuse take select --creative UUID --shot N --result UUID
+
+Creative create acceptance unknown is preserved; it is never blindly retried.
+Script writes save one Episode and stop when someone else is editing it; optimization never auto-adopts or submits video.
+Global: --api-url https://fuse.alchemint.xyz/api, --json, --fields field,field,
+--full (explicit detailed read), --help, --version. Pipe output defaults to JSON.
+Private request/receipt files retain the complete prompt and ordered references.
+The receipt path must be new, or use --resume to reconcile that exact intent.
+A plan contains finite items; each has key, creative_id, request_file and optional
+idempotency_key/source/receipt_file. Requests are unmodified CreateJob video JSON.
+Submission exit 0 means accepted, not completed. Exit 2 input, 3 auth, 4 rejected,
+5 unknown transport/acceptance, 6 wait deadline/partial, 7 failed awaited Job.
+Use FUSE_TOKEN only for a legitimately issued session; do not extract Web tokens.
+`;
+let options = {},
+  command = 'fuse',
+  json = !process.stdout.isTTY,
+  streaming = false;
+const controller = new AbortController();
+process.once('SIGINT', () => controller.abort());
+process.once('SIGTERM', () => controller.abort());
+function output(ok, data, error = null, event) {
+  const envelope = {
+    schema_version: 1,
+    command,
+    ok,
+    data: project(data, options.fields),
+    error,
+    ...(event ? { event } : {}),
+  };
+  if (json) process.stdout.write(`${JSON.stringify(envelope)}\n`);
+  else if (!ok)
+    process.stderr.write(
+      `${command}: ${error.code}: ${error.message}${error.receipt ? `\nReceipt: ${error.receipt}` : ''}\n`,
+    );
+  else if (data?.help) process.stdout.write(data.help);
+  else
+    process.stdout.write(
+      `${command}: ${JSON.stringify(project(data, options.fields))}\n`,
+    );
+}
+try {
+  const parsed = parseArgs({
+    allowPositionals: true,
+    options: {
+      ...Object.fromEntries(
+        stringFlags.map((key) => [key, { type: 'string' }]),
+      ),
+      ...Object.fromEntries(
+        booleanFlags.map((key) => [key, { type: 'boolean' }]),
+      ),
+    },
+  });
+  options = parsed.values;
+  json = options.json || !process.stdout.isTTY;
+  const [noun, action, positional] = parsed.positionals;
+  const positionalCount =
+    noun === 'batch' ||
+    (noun === 'version' && action === 'draft') ||
+    (noun === 'script' && action === 'episode') ||
+    ((noun === 'character' || noun === 'art') && action === 'image')
+      ? 3
+      : 2;
+  if (parsed.positionals.length > positionalCount)
+    throw new CliError(
+      2,
+      'INVALID_ARGUMENT',
+      'Unexpected positional argument. Run fuse --help for the command shape.',
+    );
+  command = [noun, action].filter(Boolean).join(' ') || 'fuse';
+  if (options.version)
+    output(true, { version: '0.1.0', node: process.version });
+  else if (options.help || !noun) output(true, { help });
+  else {
+    const base = apiBase(options['api-url']);
+    const client = new Client(
+      base,
+      await loadCredential(base),
+      controller.signal,
+    );
+    const context = {
+      client,
+      signal: controller.signal,
+      progress: (message) => process.stderr.write(`${message}\n`),
+      event: (event, data) => output(true, data, null, event),
+    };
+    let data;
+    if (noun === 'auth') data = await auth(action, options, context);
+    else if (noun === 'models' && ['list', 'show'].includes(action))
+      data = await models(action, options, context);
+    else if (noun === 'video' && action === 'submit')
+      data = await videoSubmit(options, context);
+    else if (noun === 'job' && action === 'cancel')
+      data = await cancel(options, context);
+    else if (noun === 'job' && ['show', 'watch'].includes(action)) {
+      streaming = action === 'watch';
+      data = await job(action, options, context);
+    } else if (noun === 'download')
+      data = await download(action, options, context);
+    else if (noun === 'asset') data = await assets(action, options, context);
+    else if (noun === 'character' || noun === 'art') {
+      command = [noun, action, action === 'image' ? positional : null]
+        .filter(Boolean)
+        .join(' ');
+      data = await (noun === 'character' ? character : art)(
+        action,
+        positional,
+        options,
+        context,
+      );
+    } else if (noun === 'creative')
+      data = await creative(action, options, context);
+    else if (noun === 'script') {
+      command = [noun, action, action === 'episode' ? positional : null]
+        .filter(Boolean)
+        .join(' ');
+      data = await script(action, positional, options, context);
+    } else if (noun === 'shot') data = await shot(action, options, context);
+    else if (noun === 'prompt') data = await prompt(action, options, context);
+    else if (noun === 'version') {
+      command = [noun, action, action === 'draft' ? positional : null]
+        .filter(Boolean)
+        .join(' ');
+      data = await version(action, positional, options, context);
+    } else if (noun === 'take') data = await take(action, options, context);
+    else if (noun === 'batch')
+      data = await batch(action, positional, options, context);
+    else
+      throw new CliError(
+        2,
+        'UNKNOWN_COMMAND',
+        'Unknown command. Run fuse --help.',
+      );
+    output(true, data, null, streaming ? 'complete' : undefined);
+  }
+} catch (error) {
+  if (error.code?.startsWith('ERR_PARSE_ARGS'))
+    error = new CliError(2, 'INVALID_ARGUMENT', error.message);
+  output(
+    false,
+    error.data || null,
+    errorData(error),
+    streaming ? 'error' : undefined,
+  );
+  process.exitCode = error.exit || 2;
+}

package/src/mutations.mjs

@@ -0,0 +1,125 @@
+import path from 'node:path';
+import { randomUUID } from 'node:crypto';
+import {
+  CliError,
+  need,
+  subject,
+  sameSubject,
+  readJson,
+  writeJson,
+  exists,
+  digest,
+  withWriter,
+  errorData,
+} from './core.mjs';
+
+/** Persist one named intent. This is not a POST retry policy: only the explicit
+ * prompt optimization owner supplies its existing idempotency contract. */
+export async function recordedMutation(
+  kind,
+  endpoint,
+  body,
+  options,
+  context,
+  summarize,
+  idempotent = false,
+) {
+  const file = path.resolve(need(options.receipt, '--receipt'));
+  return withWriter(`${file}.lock`, async () => {
+    const owner = await subject(context.client);
+    let receipt;
+    if (await exists(file)) {
+      receipt = await readJson(file);
+      sameSubject(receipt, owner);
+      if (
+        !options.resume ||
+        receipt.schema_version !== 1 ||
+        receipt.kind !== kind ||
+        receipt.endpoint !== endpoint ||
+        digest(receipt.request) !== receipt.request_sha256
+      )
+        throw new CliError(
+          2,
+          'RECEIPT_EXISTS',
+          'Use the original receipt to inspect this intent; it cannot be replaced.',
+        );
+      if (receipt.accepted) return { ...receipt.accepted, receipt: file };
+      if (!idempotent || receipt.state === 'rejected')
+        throw new CliError(
+          5,
+          'MUTATION_UNRESOLVED',
+          'This non-replayable intent needs reconciliation through its existing owner read. It was not resubmitted.',
+          { receipt: file },
+        );
+    } else {
+      if (options.resume)
+        throw new CliError(
+          2,
+          'RECEIPT_NOT_FOUND',
+          'Resume requires the existing receipt file.',
+        );
+      receipt = {
+        schema_version: 1,
+        kind,
+        ...owner,
+        endpoint,
+        request: body,
+        request_sha256: digest(body),
+        state: 'prepared',
+        created_at: new Date().toISOString(),
+        ...(idempotent
+          ? { idempotency_key: options['idempotency-key'] || randomUUID() }
+          : {}),
+      };
+      await writeJson(file, receipt, true);
+    }
+    receipt.state = 'submitting';
+    await writeJson(file, receipt);
+    try {
+      const result = await context.client.post(
+        receipt.endpoint,
+        receipt.request,
+        idempotent
+          ? { headers: { 'X-Idempotency-Key': receipt.idempotency_key } }
+          : undefined,
+      );
+      const accepted = summarize(result);
+      if (
+        Object.entries(accepted).some(
+          ([key, value]) =>
+            key.endsWith('_id') &&
+            !(
+              (typeof value === 'string' && value.length) ||
+              (Number.isInteger(value) && value > 0)
+            ),
+        )
+      )
+        throw new CliError(
+          5,
+          'RESPONSE_UNKNOWN',
+          'The response did not identify the accepted object. Reconcile this saved intent.',
+        );
+      receipt.accepted = accepted;
+      receipt.state = 'accepted';
+      await writeJson(file, receipt);
+      return { ...receipt.accepted, receipt: file };
+    } catch (error) {
+      if (!(error instanceof CliError))
+        error = new CliError(
+          5,
+          'RECEIPT_UNKNOWN',
+          'Acceptance could not be recorded. Keep this intent and reconcile it.',
+        );
+      receipt.state =
+        error.exit === 5
+          ? 'unknown'
+          : error.exit === 3
+            ? 'auth_required'
+            : 'rejected';
+      receipt.error = errorData(error);
+      await writeJson(file, receipt);
+      error.receipt = file;
+      throw error;
+    }
+  });
+}