owned-account-pool-cli 0.1.0 → 0.2.0

package/README.md

@@ -1,6 +1,6 @@
 # 自有账号池 CLI
 
-面向 `https://handover.luckyjun.top` 的账号池与任务登记工具。支持交互登录、选择客户和账号、录入帖子与独立评论、编辑原稿、提交任务和失败恢复。
+面向 `https://handover.luckyjun.top` 的账号池与任务登记工具。支持交互登录、选择客户和账号、录入帖子与独立评论、上传图片、编辑原稿、提交任务和失败恢复。
 
 ## 安装
 
@@ -24,7 +24,7 @@ owned-pool post create
 owned-pool comment create
 ```
 
-命令会依次收集缺失的账号密码、客户、帖子用途、回复目标、社区、账号来源、权重阈值、账号、标题、正文、留存要求以及保存方式。正文支持直接输入、UTF-8 文件和系统编辑器，备注可留空。
+命令会依次收集缺失的账号密码、客户、帖子用途、回复目标、社区、账号来源、权重阈值、账号、标题、图片、正文、留存要求以及保存方式。正文支持直接输入、UTF-8 文件和系统编辑器，备注可留空。
 
 评论使用自有账号，回复社区通过服务端解析目标 URL 获得。账号选择保留服务端资格限制。草稿保存与提交通过 `--draft`、`--submit` 选择，也可在终端回答。
 
@@ -72,7 +72,23 @@ owned-pool tasks edit 123 --body-file ./updated.md --draft
 owned-pool tasks submit 123
 ```
 
-编辑保留已有素材及可编辑的跟帖，写入携带任务版本。新增录入支持文本原稿，图片可通过系统网页补充。
+编辑保留已有素材及可编辑的跟帖，写入携带任务版本。
+
+## 图片上传
+
+从 0.2.0 起，录入与编辑命令支持重复传入 `--image`，按传入顺序追加图片。交互模式会询问是否添加图片，随后逐个输入文件路径。
+
+```sh
+owned-pool post create --image ./cover.png --image "./产品展示.jpg"
+owned-pool comment create --image ./reference.webp
+owned-pool tasks edit 123 --image ./extra.png --draft --non-interactive
+```
+
+上传遵循当前网页的限制，支持静态 JPEG、PNG、WebP，单张最多 5 MiB，每个任务最多 10 张，包含已有素材。图片帖的正文可留空。非交互模式省略 `--image` 时继续处理现有内容。
+
+CLI 在写入前检查全部图片，先保存原稿，再逐张以 multipart 上传 `file` 和最新 `version`。每张成功上传的素材立即保存到任务，完整上传后才执行 `--submit`。编辑时图片追加到已有素材末尾。
+
+恢复文件会记录图片路径、内容摘要和已完成的素材 ID。遇到上传响应丢失，恢复时读取任务并下载新增原图核对摘要，确认成功后继续后续图片。出现并发修改或摘要不一致时返回错误供核对。待上传的本地图片需保持原路径和内容。
 
 写入失败时返回任务 ID 和本地恢复文件路径。该文件包含原稿内容，保存在用户目录 `.owned-account-pool/recovery`。使用返回的恢复命令继续操作，成功后自动清理。
 
@@ -110,4 +126,4 @@ node bin/owned-pool.js --help
 npm pack --dry-run
 ```
 
-接口依据本目录 2026-11-11 的 API 文档及站点前端调用。测试覆盖模拟服务的认证、CSRF、录入、分页选择、版本冲突、恢复、更新提示和 CLI 入口。
+接口依据本目录 2026-11-11 的 API 文档及站点前端调用。测试覆盖模拟服务的认证、CSRF、录入、图片 multipart 上传、分页选择、版本冲突、恢复、更新提示和 CLI 入口。

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "owned-account-pool-cli",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "自有账号池 CLI，交互登录、客户与账号选择、帖子和评论任务录入",
   "type": "module",
   "bin": {

package/skills/owned-account-pool/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: owned-account-pool
-description: 使用 owned-pool CLI 查询自有账号池、客户和登记任务，录入或编辑帖子与评论原稿，提交给发布人员，并在 npm 包有新版本时提醒用户。适用于 handover.luckyjun.top 自有账号发布系统。
+description: 使用 owned-pool CLI 查询自有账号池、客户和登记任务，录入或编辑帖子与评论原稿、上传图片、提交给发布人员，并在 npm 包有新版本时提醒用户。适用于 handover.luckyjun.top 自有账号发布系统。
 ---
 
 # 自有账号池 CLI
@@ -56,10 +56,22 @@ owned-pool comment create --client 12 --account account-opaque-id --target-url "
 - 留存 `--retention-hours` 取 `24`、`48`、`72`、`168`、`720` 小时。
 - `--draft` 保存草稿，`--submit` 保存后提交给发布人员。依据用户要求选择，缺少要求时询问。
 - 长正文、多行内容使用 UTF-8 的 `--body-file`。可选备注在非交互模式下省略即为空。
+- 图片上传需要 CLI 0.2.0 起，使用可重复的 `--image <路径>`，参数顺序即追加顺序。支持静态 JPEG、PNG、WebP，每张最多 5 MiB，每个任务包含已有素材最多 10 张。图片帖可省略正文。
 - `--dry-run` 用于检查收集完成的录入方案。它包含登录和只读查询。
 
 成功结果包含 `task_id`、`status`、`version`。向用户汇报任务 ID 与状态。此工作流记录系统任务，Reddit 实际发布由发布人员执行。
 
+## 图片录入
+
+用户提供本地图片或可访问的附件路径时，把路径加入录入或编辑命令。需要图片且路径缺失时询问用户。交互命令会询问是否添加图片，非交互模式省略图片参数时沿用现有内容。多个文件依次使用 `--image`，含空格的路径加引号。
+
+```sh
+owned-pool post create --image ./cover.png --image "./产品展示.jpg"
+owned-pool tasks edit 123 --image ./extra.webp --draft --non-interactive --json
+```
+
+CLI 先保存原稿，再按最新任务版本逐张上传并保存，全部成功后执行提交。上传结果的 `uploaded_assets` 包含本轮新增素材 ID，保留其原始类型。
+
 ## 编辑、提交与恢复
 
 ```sh
@@ -72,4 +84,6 @@ owned-pool tasks resume "恢复文件的完整路径" --non-interactive --json
 
 录入分为创建任务和保存原稿。写入中断时，错误中包含 `recovery_file` 和 `next_command`。优先恢复既有任务。创建请求结果未知时，先查 `tasks list`，找到对应任务，再使用 `tasks resume ... --task-id ID`。恢复文件保存在用户目录 `.owned-account-pool/recovery`，含录入正文，成功恢复后清理。
 
+图片上传中断也沿用恢复命令。保留待上传文件的原路径与内容，CLI 会核对内容摘要，复用已确认成功的图片。上传响应丢失时，CLI 根据任务新增素材及下载原图的摘要判断结果。`UPLOAD_CONFLICT` 表示任务变化或素材摘要不匹配，需要读取最新任务并核对，随后合并用户要求。
+
 本 CLI 覆盖账号查询与任务登记流程。客户绑定、账号资格等服务端配置问题按接口错误提示处理。

package/src/api.js

@@ -19,17 +19,18 @@ export class ApiClient {
     this.loggedIn = false;
   }
 
-  async request(method, path, { query = {}, body, timeout = this.timeout } = {}) {
+  async request(method, path, { query = {}, body, responseType = 'json', timeout = this.timeout } = {}) {
     assert(path.startsWith('/api/'), 'INVALID_PATH', '接口路径须以 /api/ 开头。');
     const url = new URL(path, this.baseUrl);
     assert(url.origin === this.baseUrl, 'INVALID_PATH', '接口路径必须属于当前服务。');
     for (const [key, value] of Object.entries(query)) {
       if (value !== undefined && value !== null && value !== '') url.searchParams.set(key, value);
     }
-    const headers = { Accept: 'application/json' };
+    const multipart = body instanceof FormData;
+    const headers = { Accept: responseType === 'buffer' ? '*/*' : 'application/json' };
     const cookie = await this.jar.getCookieString(url.href);
     if (cookie) headers.Cookie = cookie;
-    if (body !== undefined) headers['Content-Type'] = 'application/json';
+    if (body !== undefined && !multipart) headers['Content-Type'] = 'application/json';
     if (!['GET', 'HEAD', 'OPTIONS'].includes(method) && this.csrf) {
       headers['X-CSRF-Token'] = this.csrf;
     }
@@ -37,12 +38,13 @@ export class ApiClient {
     let text;
     try {
       response = await this.fetchImpl(url, {
-        method, headers, body: body === undefined ? undefined : JSON.stringify(body),
+        method, headers, body: multipart ? body : body === undefined ? undefined : JSON.stringify(body),
         redirect: 'manual', signal: AbortSignal.timeout(timeout),
       });
       for (const cookieValue of response.headers.getSetCookie()) {
         await this.jar.setCookie(cookieValue, url.href);
       }
+      if (response.ok && responseType === 'buffer') return Buffer.from(await response.arrayBuffer());
       text = await response.text();
     } catch (error) {
       const code = ['TimeoutError', 'AbortError'].includes(error.name) ? 'REQUEST_TIMEOUT' : 'NETWORK_ERROR';

package/src/cli.js

@@ -56,6 +56,7 @@ function authenticated(command, handler) {
 function contentOptions(command) {
   return command.option('--body <text>', '正文 Markdown')
     .option('--body-file <file>', '从 UTF-8 文件读取正文')
+    .option('--image <file>', '添加图片，支持重复传入，按参数顺序上传', (file, files = []) => [...files, file])
     .option('--notes <text>', '内部备注，可传空字符串')
     .option('--retention-hours <hours>', '留存小时数 24/48/72/168/720')
     .option('--draft', '保存为草稿')

package/src/images.js

@@ -0,0 +1,77 @@
+import { open } from 'node:fs/promises';
+import { basename, resolve } from 'node:path';
+import { createHash } from 'node:crypto';
+import { assert } from './errors.js';
+
+export const MAX_IMAGES = 10;
+export const MAX_IMAGE_BYTES = 5 * 1024 * 1024;
+
+export function imageHash(bytes) {
+  return createHash('sha256').update(bytes).digest('hex');
+}
+
+function imageType(bytes) {
+  if (bytes.length >= 3 && bytes[0] === 0xff && bytes[1] === 0xd8 && bytes[2] === 0xff) return 'image/jpeg';
+  if (bytes.subarray(0, 8).equals(Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]))) {
+    for (let offset = 8; offset + 12 <= bytes.length;) {
+      const length = bytes.readUInt32BE(offset);
+      const type = bytes.toString('ascii', offset + 4, offset + 8);
+      assert(type !== 'acTL', 'INVALID_IMAGE', '请使用静态 PNG 图片。');
+      offset += length + 12;
+    }
+    return 'image/png';
+  }
+  if (bytes.toString('ascii', 0, 4) === 'RIFF' && bytes.toString('ascii', 8, 12) === 'WEBP') {
+    for (let offset = 12; offset + 8 <= bytes.length;) {
+      const type = bytes.toString('ascii', offset, offset + 4);
+      const length = bytes.readUInt32LE(offset + 4);
+      assert(type !== 'ANIM' && type !== 'ANMF' &&
+        !(type === 'VP8X' && length > 0 && (bytes[offset + 8] & 2)),
+      'INVALID_IMAGE', '请使用静态 WebP 图片。');
+      offset += 8 + length + length % 2;
+    }
+    return 'image/webp';
+  }
+  assert(false, 'INVALID_IMAGE', '图片格式须为 JPEG、PNG 或 WebP。');
+}
+
+export async function readImage(file) {
+  const path = resolve(file);
+  const handle = await open(path, 'r');
+  let bytes;
+  try {
+    const stat = await handle.stat();
+    assert(stat.isFile(), 'INVALID_IMAGE', '图片路径须指向文件。', { path });
+    assert(stat.size > 0 && stat.size <= MAX_IMAGE_BYTES, 'INVALID_IMAGE', '单张图片须大于 0 且不超过 5 MiB。', { path });
+    bytes = await handle.readFile();
+  } finally {
+    await handle.close();
+  }
+  assert(bytes.length > 0 && bytes.length <= MAX_IMAGE_BYTES, 'INVALID_IMAGE', '单张图片须大于 0 且不超过 5 MiB。', { path });
+  return { path, name: basename(path), type: imageType(bytes), size: bytes.length, sha256: imageHash(bytes), bytes };
+}
+
+export async function prepareImages(questions, files, existingCount = 0) {
+  let paths = files || [];
+  if (!files && questions.interactive && existingCount < MAX_IMAGES) {
+    const add = await questions.choice('images', '是否添加图片', undefined, [
+      { name: '暂不添加', value: false }, { name: '添加本地图片', value: true },
+    ]);
+    if (add) {
+      paths = [];
+      while (paths.length + existingCount < MAX_IMAGES) {
+        const path = await questions.text('image', paths.length ? '下一张图片路径（留空结束）' : '图片文件路径',
+          undefined, { optional: paths.length > 0 });
+        if (!path.trim()) break;
+        paths.push(path.trim().replace(/^"|"$/g, ''));
+      }
+    }
+  }
+  assert(paths.length + existingCount <= MAX_IMAGES, 'TOO_MANY_IMAGES', '每个任务最多 10 张图片，包含现有图片。');
+  const images = [];
+  for (const path of paths) {
+    const { bytes, ...image } = await readImage(path);
+    images.push(image);
+  }
+  return images;
+}

package/src/prompts.js

@@ -69,10 +69,11 @@ export class Questions {
     }, this.context);
   }
 
-  async body(value, file, defaultValue) {
+  async body(value, file, defaultValue, { optional = false } = {}) {
     assert(!(value !== undefined && file), 'INVALID_INPUT', '--body 与 --body-file 只能选择一项。');
     if (file) value = await readFile(file, 'utf8');
-    if (value !== undefined) return this.text('body', '正文', value, { max: 40000 });
+    if (value !== undefined) return this.text('body', '正文', value, { max: 40000, optional });
+    if (optional && !this.interactive) return defaultValue ?? '';
     this.requireInteractive('body', '正文（--body 或 --body-file）');
     const mode = await this.choice('body-mode', '正文输入方式', undefined, [
       { name: '输入一段文字', value: 'input' },
@@ -81,15 +82,16 @@ export class Questions {
     ]);
     if (mode === 'file') {
       const path = await this.text('body-file', '正文文件路径', undefined);
-      return this.body(undefined, path.trim().replace(/^"|"$/g, ''));
+      return this.body(undefined, path.trim().replace(/^"|"$/g, ''), defaultValue, { optional });
     }
     if (mode === 'editor') {
       return editor({
         message: '编辑正文并保存退出', default: defaultValue ?? '', postfix: '.md',
-        validate: content => content.trim() && content.length <= 40000 ? true : '正文须为 1–40000 个字符。',
+        validate: content => (optional || content.trim()) && content.length <= 40000
+          ? true : '请填写正文，最多 40000 个字符。',
       }, this.context);
     }
-    return this.text('body', '正文', undefined, { max: 40000, defaultValue });
+    return this.text('body', optional ? '正文（图片帖可留空）' : '正文', undefined, { max: 40000, defaultValue, optional });
   }
 }
 

package/src/tasks.js

@@ -6,6 +6,7 @@ import { isDeepStrictEqual } from 'node:util';
 import { allPages, itemsOf } from './api.js';
 import { CliError, assert } from './errors.js';
 import { normalizeSubreddit, positiveInteger } from './prompts.js';
+import { imageHash, MAX_IMAGES, prepareImages, readImage } from './images.js';
 
 const PURPOSES = [
   { name: '外部原创', value: 'external_original' },
@@ -96,7 +97,10 @@ export async function prepareCreate(api, questions, kind, options) {
   const candidate = await chooseCandidate(api, questions, options, client.id, kind, target?.subreddit);
   const title = kind === 'post'
     ? await questions.text('title', '帖子标题', options.title, { max: 300 }) : '';
-  const body = await questions.body(options.body, options.bodyFile);
+  const images = await prepareImages(questions, options.image);
+  const body = await questions.body(options.body, options.bodyFile, undefined, {
+    optional: kind === 'post' && images.length > 0,
+  });
   const notes = await questions.text('notes', '内部备注（可留空）', options.notes, { optional: true, max: 5000 });
   const targetContext = kind === 'comment'
     ? await questions.text('target-context', '目标原文摘录（可留空）', options.targetContext, { optional: true, max: 20000 }) : '';
@@ -104,7 +108,7 @@ export async function prepareCreate(api, questions, kind, options) {
   const mode = await submissionChoice(questions, options);
   const accountMode = kind === 'comment' ? { account_mode: 'owned' } : {};
   return {
-    schema: 1, base_url: api.baseUrl, task_id: null, expected_version: null, mode,
+    schema: 1, base_url: api.baseUrl, task_id: null, expected_version: null, mode, images,
     create: {
       client_id: positiveInteger(client.id, '客户 ID'), kind, parent_task_id: null,
       follow_op: false, post_purpose: purpose, ...accountMode,
@@ -134,11 +138,14 @@ export async function prepareEdit(api, questions, id, options) {
   const task = await getTask(api, id);
   assert(['draft', 'returned'].includes(task.status), 'INVALID_TASK_STATE', '原稿编辑适用于 draft 或 returned 任务。');
   const content = { title: '', body: '', notes: '', target_context: '', assets: [], ...task.source };
+  const images = await prepareImages(questions, options.image, content.assets.length);
   if (task.kind === 'post' && (options.title !== undefined || !content.title)) {
     content.title = await questions.text('title', '帖子标题', options.title, { max: 300 });
   }
-  if (options.body !== undefined || options.bodyFile || !content.body || questions.interactive) {
-    content.body = await questions.body(options.body, options.bodyFile, content.body);
+  if (options.body !== undefined || options.bodyFile || !content.body || questions.interactive && !options.image?.length) {
+    content.body = await questions.body(options.body, options.bodyFile, content.body, {
+      optional: task.kind === 'post' && content.assets.length + images.length > 0,
+    });
   }
   content.notes = await questions.text('notes', '内部备注（可留空）', options.notes, {
     optional: true, max: 5000, defaultValue: content.notes,
@@ -158,7 +165,7 @@ export async function prepareEdit(api, questions, id, options) {
     chosenCandidates = [await chooseCandidate(api, questions, options, task.client_id, task.kind, subreddit)];
   }
   return {
-    schema: 1, base_url: api.baseUrl, task_id: task.id, expected_version: task.version,
+    schema: 1, base_url: api.baseUrl, task_id: task.id, expected_version: task.version, images,
     mode: await submissionChoice(questions, options),
     registration: {
       content,
@@ -196,6 +203,73 @@ function registrationMatches(task, registration) {
     });
 }
 
+function addedImage(task, plan) {
+  const previous = plan.registration.content.assets;
+  const current = task.source?.assets;
+  assert(Array.isArray(current) && current.length === previous.length + 1 &&
+    isDeepStrictEqual(current.slice(0, -1), previous) &&
+    registrationMatches({ ...task, source: { ...task.source, assets: previous } }, plan.registration),
+  'UPLOAD_CONFLICT', '任务素材或原稿发生了其他变化，请查询任务并核对恢复文件。');
+  const id = current.at(-1);
+  assert((typeof id === 'string' && id.length > 0 || typeof id === 'number' && Number.isFinite(id)) &&
+    !previous.includes(id), 'INVALID_RESPONSE', '上传响应缺少新增图片的素材 ID。');
+  return id;
+}
+
+function rememberImage(plan, image, task, assetId) {
+  image.asset_id = assetId;
+  delete image.attempt;
+  plan.registration.content.assets = [...task.source.assets];
+  plan.expected_version = task.version;
+}
+
+async function reconcileUpload(api, plan, task, recoveryPath) {
+  const pending = (plan.images || []).filter(image => image.attempt);
+  assert(pending.length <= 1, 'INVALID_RECOVERY', '恢复文件包含多个未确认的上传请求。');
+  if (!pending.length) return;
+  const image = pending[0];
+  if (task.version === image.attempt.version && registrationMatches(task, plan.registration)) {
+    delete image.attempt;
+  } else {
+    const id = addedImage(task, plan);
+    const bytes = await api.request('GET', `/api/tasks/${task.id}/assets/${encodeURIComponent(String(id))}`, {
+      query: { download: true }, responseType: 'buffer',
+    });
+    assert(imageHash(bytes) === image.sha256, 'UPLOAD_CONFLICT',
+      '新增素材与待恢复图片的内容不一致，请查询任务并核对上传结果。');
+    rememberImage(plan, image, task, id);
+  }
+  await writeRecovery(recoveryPath, plan);
+}
+
+async function checkedImage(image) {
+  const current = await readImage(image.path);
+  assert(current.sha256 === image.sha256, 'IMAGE_CHANGED',
+    '图片文件在录入后发生了变化，请恢复原文件，或通过 tasks edit 使用新文件。', { path: image.path });
+  return current;
+}
+
+async function uploadImages(api, plan, task, recoveryPath) {
+  for (const image of plan.images || []) {
+    if (image.asset_id !== undefined) continue;
+    assert(['draft', 'returned'].includes(task.status), 'INVALID_TASK_STATE', '当前任务状态不支持原稿图片上传。');
+    assert(task.version === plan.expected_version && registrationMatches(task, plan.registration),
+      'VERSION_CONFLICT', '任务已变化，请核对原稿后继续上传。');
+    const file = await checkedImage(image);
+    const form = new FormData();
+    form.set('file', new Blob([file.bytes], { type: file.type }), file.name);
+    form.set('version', String(task.version));
+    image.attempt = { version: task.version };
+    await writeRecovery(recoveryPath, plan);
+    const uploaded = taskOf(await api.request('POST', `/api/tasks/${task.id}/assets`, { body: form }));
+    const id = addedImage(uploaded, plan);
+    rememberImage(plan, image, uploaded, id);
+    await writeRecovery(recoveryPath, plan);
+    task = uploaded;
+  }
+  return task;
+}
+
 export async function submitTask(api, task, dryRun = false) {
   assert(['draft', 'returned'].includes(task.status), 'INVALID_TASK_STATE', '可提交的原稿状态为 draft 或 returned。');
   const body = {
@@ -209,6 +283,12 @@ export async function submitTask(api, task, dryRun = false) {
 
 export async function executePlan(api, plan, { recoveryPath, recoveryDir, resume = false, dryRun = false } = {}) {
   if (dryRun) return { dry_run: true, plan };
+  const pendingImages = (plan.images || []).filter(image => image.asset_id === undefined);
+  assert(plan.registration.content.assets.length + pendingImages.length <= MAX_IMAGES,
+    'TOO_MANY_IMAGES', '每个任务最多 10 张图片，包含现有图片。');
+  for (const image of pendingImages) {
+    if (!image.attempt) await checkedImage(image);
+  }
   const directory = recoveryDir || join(homedir(), '.owned-account-pool', 'recovery');
   await mkdir(directory, { recursive: true, mode: 0o700 });
   const path = recoveryPath || join(directory, `${randomUUID()}.recovery.json`);
@@ -228,6 +308,7 @@ export async function executePlan(api, plan, { recoveryPath, recoveryDir, resume
       assert(task.client_id === plan.create.client_id && task.kind === plan.create.kind,
         'RECOVERY_MISMATCH', '恢复任务的客户或类型与原录入内容不一致。');
     }
+    await reconcileUpload(api, plan, task, path);
     const alreadySaved = registrationMatches(task, plan.registration);
     if (!alreadySaved) {
       assert(['draft', 'returned'].includes(task.status), 'INVALID_TASK_STATE', '任务当前状态不支持保存原稿。');
@@ -238,7 +319,11 @@ export async function executePlan(api, plan, { recoveryPath, recoveryDir, resume
       }));
       plan.expected_version = task.version;
       await writeRecovery(path, plan);
+    } else {
+      plan.expected_version = task.version;
+      await writeRecovery(path, plan);
     }
+    task = await uploadImages(api, plan, task, path);
     if (plan.mode === 'submit' && ['draft', 'returned'].includes(task.status)) {
       task = await submitTask(api, task);
     }
@@ -254,21 +339,25 @@ export async function executePlan(api, plan, { recoveryPath, recoveryDir, resume
     return { task_id: task.id, status: task.status, version: task.version,
       recovery_file: path, warning: '操作成功，恢复文件清理失败，可手动删除。' };
   }
-  return { task_id: task.id, status: task.status, version: task.version };
+  return { task_id: task.id, status: task.status, version: task.version,
+    ...((plan.images || []).length ? { uploaded_assets: plan.images.map(image => image.asset_id) } : {}) };
 }
 
 export async function resumePlan(api, questions, file, options) {
   const path = resolve(file);
   const plan = JSON.parse(await readFile(path, 'utf8'));
   assert(plan.schema === 1 && plan.registration?.content && Array.isArray(plan.registration.candidates) &&
-    Array.isArray(plan.registration.followups) && ['draft', 'submit'].includes(plan.mode),
+    Array.isArray(plan.registration.content.assets) && Array.isArray(plan.registration.followups) &&
+    (plan.images === undefined || Array.isArray(plan.images) && plan.images.every(image =>
+      typeof image.path === 'string' && /^[a-f0-9]{64}$/.test(image.sha256))) &&
+    ['draft', 'submit'].includes(plan.mode),
     'INVALID_RECOVERY', '恢复文件格式无效。');
   assert(plan.base_url === api.baseUrl, 'RECOVERY_MISMATCH', '恢复文件所属服务与当前 --base-url 不一致。');
   if (!plan.task_id) {
     plan.task_id = positiveInteger(await questions.text('task-id',
       '创建结果未知，请查询任务列表并填写对应任务 ID', options.taskId), '任务 ID');
     const task = await getTask(api, plan.task_id);
-    assert(!task.source?.body || registrationMatches(task, plan.registration),
+    assert(!(task.source?.body || task.source?.assets?.length) || registrationMatches(task, plan.registration),
       'RECOVERY_MISMATCH', '指定任务已有其他正文，请核对任务 ID 并通过 tasks edit 合并修改。');
     plan.expected_version = task.version;
   }