@casatwy/deyo 0.2.3 → 0.2.6

package/README.md

@@ -2,9 +2,9 @@
 
 `deyo` 是 [https://deyo.miaobi.fun](https://deyo.miaobi.fun) 的命令行工具。你可以直接在终端里提交音视频链接或本地音视频文件进行转写，并把结果输出到终端或保存到本地文件。
 
-CLI `0.2.2` 保留省略 `--language` 时的自动检测和可选稳定正文事件，并新增由 npm CLI 管理的 OpenClaw 更新登记、离线状态与显式确认流程。默认不会把正文写入进度日志；只有显式使用 `--stream-transcript --progress-format jsonl`，且最终格式为 `text` 时，才会在 stderr JSONL 中输出稳定的 Whisper 正文增量。stdout 或 `-O` 始终只接收最终 Whisper 原稿，CLI 本身不做 AI 整理。
+CLI `0.2.4` 保留省略 `--language` 时的自动检测和可选稳定正文事件，以及由 npm CLI 管理的 OpenClaw 更新登记、离线状态与显式确认流程。本地文件选定后会直接初始化并分片上传，不再预先计算文件 SHA-256。默认不会把正文写入进度日志；只有显式使用 `--stream-transcript --progress-format jsonl`，且最终格式为 `text` 时，才会在 stderr JSONL 中输出稳定的 Whisper 正文增量。stdout 或 `-O` 始终只接收最终 Whisper 原稿，CLI 本身不做 AI 整理。
 
-当前支持 8 类链接来源 + 本地音视频上传。链接来源包括小宇宙单集、喜马拉雅单集（含 `xima.tv` 短链）、B 站单视频、抖音单视频、小红书单视频笔记、YouTube 单视频、Apple Podcasts 单集和 Twitter/X 单条推文。其中 YouTube 如果命中可直接使用的字幕，会直接输出字幕或文本结果，不进入完整转写、不扣分钟；喜马拉雅合集链接会返回 422 并提示选择单集，不会扣分钟或创建转写任务；抖音图文内容、小红书图文笔记、Twitter/X 文本或图片推文会返回不支持转写的提示。B 站支持普通 BV 链接、`b23.tv` 短链、带 `bvid` 的 `player.bilibili.com/player.html` 嵌入播放器链接，以及可由 Whisper 解出 BV 页面的 `bilibili://video/...` App 分享视频链接；CLI 会识别并透传 App 链接，不在本地解码或推导 BV。
+当前支持 11 类平台链接 + 音频/视频文件链接 + 本地音视频上传。可转写链接包括小宇宙单集、喜马拉雅单集（含 `xima.tv` 短链）、B 站具体视频、抖音单视频、小红书单视频笔记、YouTube 单视频、Apple Podcasts 单集、Twitter/X 视频推文、TikTok 单条公开视频、看看新闻单条视频、微信视频号公开单视频，以及未知平台的 HTTPS 音频/视频直链（无需以常见媒体扩展名结尾）。其中 YouTube 如果命中可直接使用的字幕，会直接输出字幕或文本结果，不进入完整转写、不扣分钟；喜马拉雅合集、Apple Podcasts 节目主页、小宇宙播客主页和 B 站 Bangumi / UGC 合集会返回 422 并提示选择具体单集或视频，不会扣分钟或创建转写任务；抖音图文内容、小红书图文笔记、Twitter/X 文本或图片推文以及 TikTok 图集也会返回不支持转写的提示。TikTok 支持标准、移动端和 vm/vt 单条短链；账号页、搜索页、直播、私密或地区受限内容不在支持范围，文字稿来自音轨 ASR。看看新闻支持 hostname 中包含 `kankanews.com` 的 HTTPS 视频页面。B 站的普通 BV、分 P、`b23.tv` 短链、带 `bvid` 的 `player.bilibili.com/player.html`、可由 Whisper 解出 BV 页面的 `bilibili://video/...` App 分享视频链接，以及 Bangumi `ep` 都保持具体视频流程；CLI 会识别并透传 App 链接，不在本地解码或推导 BV。B站专属视频会先进行无任务、无扣费的预检，展示完整与可转写时长；只有交互式终端明确确认后才转写试看部分并按可转写时长扣分钟，拒绝或非 TTY 环境会直接退出。
 
 本地文件转写只支持单个普通音频或视频文件，固定作为 `upload` 来源提交。你可以直接传文件路径，也可以显式使用 `--file`；如果文件扩展名或系统识别不可靠，可以用 `--mime-type` 指定媒体类型。当前不支持目录、glob、stdin、批量队列或断点续传。
 
@@ -162,6 +162,8 @@ deyo --file ./audio.mp3 --mime-type audio/mpeg -O ./audio.txt
 deyo -O ./episode.txt 'https://www.xiaoyuzhoufm.com/episode/xxxx'
 ```
 
+小宇宙 `/podcast/:id` 播客主页不是具体单集。CLI 会在创建任务、复用结果或扣减分钟之前返回 422，并提示打开具体 `/episode/` 链接后重新提交。
+
 处理喜马拉雅单集并保存为文本：
 
 ```bash
@@ -170,6 +172,8 @@ deyo -O ./ximalaya.txt 'https://www.ximalaya.com/sound/963656969'
 
 也可以传入会跳转到单集页的 `xima.tv` 短链；合集链接会直接提示需要选择具体单集链接后再提交。
 
+Apple Podcasts 带有效 `?i=` 的单集链接保持原转写流程；节目 `id<digits>` 主页会返回 422，并提示选择具体单集。
+
 处理 Twitter/X 视频推文并保存为文本：
 
 ```bash
@@ -178,6 +182,16 @@ deyo --source twitter -O ./tweet.txt 'https://x.com/historyinmemes/status/179063
 
 如果传入 Twitter/X 文本或图片推文，CLI 会提示当前不支持转写；这类内容不会进入支付或分钟扣减链路。
 
+处理微信视频号公开单视频并保存为文本：
+
+```bash
+deyo --source wechat_channels -O ./wechat.txt 'https://channels.weixin.qq.com/finder-preview/pages/sph?id=sphxxxx'
+```
+
+共享视频号凭据有效时，CLI 会直接沿用普通任务流程。需要扫码时，CLI 会打印只含公开规范链接的 Deyo HTTPS 页面地址并尝试用系统浏览器打开；无桌面的服务器可把打印出的地址复制到其他设备。CLI 只轮询安全的有效/待授权状态，授权成功后仅重放原任务请求一次，因此继续复用服务端原解析记录、订单和幂等扣费逻辑。
+
+视频号 Cookie、凭据 generation、媒体直链及其签名不得通过 CLI 参数、stdin、环境变量、本地配置或剪贴板提供；CLI 也不会在文本、JSON 或 JSONL 输出中返回这些材料。API Key 只用于把请求映射到 Deyo 用户，不会把共享视频号凭据绑定到该用户。
+
 处理本地音频文件并保存为文本：
 
 ```bash
@@ -217,6 +231,10 @@ deyo -O ./bilibili.txt 'https://player.bilibili.com/player.html?bvid=BVxxxx&page
 deyo -O ./bilibili-app.txt 'bilibili://video/BVxxxx?page=2'
 ```
 
+Bangumi `ep` 仍按具体视频处理。Bangumi `ss` / `md`、受支持的 UGC season / series 合集入口会返回 422，并提示选择具体视频；CLI 不会枚举或输出合集视频清单。
+
+如果 B站具体视频被识别为B站专属视频，CLI 会先显示“这是B站专属视频，Deyo 只能转写试看部分”、完整时长、可转写时长和预计扣除分钟，并询问是否继续。输入 `y` 才会创建转写任务；其他输入、拒绝或非交互式终端都会退出，不创建任务也不扣分钟。完全没有可用试看媒体的付费 / 充电专属视频仍返回 422。
+
 导出为 `srt` 字幕文件：
 
 ```bash
@@ -255,7 +273,7 @@ deyo --api-key 'deyo_sk_other' 'https://www.youtube.com/watch?v=xxxx'
 
 `--language <value>`
 
-显式指定转写语言，例如 `zh` 或 `en`。省略该参数时，CLI 不会在链接任务或本地文件任务的请求体里发送 `language` 字段，由服务端和 Whisper 自动检测；不要根据终端语言或内容标题自行推断。
+显式指定转写语言，例如 `zh` 或 `en`。省略该参数时，CLI 会在链接、预检和本地文件请求体里省略 `language` 字段，由服务端和 Whisper 自动检测；不要根据终端语言或内容标题自行推断。
 
 `-O, --output <path>`
 
@@ -304,7 +322,7 @@ deyo --api-key 'deyo_sk_other' 'https://www.youtube.com/watch?v=xxxx'
 
 如果你希望 AI 或脚本稳定读取进度事件，建议使用 `--progress-format jsonl`。此时 CLI 会继续把最终结果输出到 stdout 或文件，只把进度事件按 JSON Lines 写到 stderr。AI 代跑上传或长转写任务时，应读取 JSONL 后用自然语言转述上传百分比、媒体检查、任务创建、状态变化和关键转写百分比，不要把原始 JSONL 直接贴给用户。
 
-本地文件上传会额外输出这些上传事件：`upload.hashing`、`upload.started`、`upload.progress`、`upload.completed`、`upload.checking`、`upload.ready`、`upload.aborted`、`upload.failed`。事件不会包含签名 URL、文件 hash 或分片 ETag。
+本地文件上传会额外输出这些上传事件：`upload.started`、`upload.progress`、`upload.completed`、`upload.checking`、`upload.ready`、`upload.aborted`、`upload.failed`。文件选定后直接进入 `upload.started`，不计算或发送文件 hash；事件也不会包含签名 URL 或分片 ETag。
 
 任务阶段会输出这些事件：`task.created`、`task.status_changed`、`task.progress`、`task.completed`、`task.failed`、`task.cancelled`、`task.result_written`、`task.notice`。如果 `task.created` 里出现 `mode: "subtitles"` 或 `resultReady: true`，通常表示命中字幕直出，不需要等待长时间完整转写。
 
@@ -340,11 +358,13 @@ deyo --api-key 'deyo_sk_other' 'https://www.youtube.com/watch?v=xxxx'
 
 ## 能力边界
 
-- 支持输入：8 类单条链接来源，或一个本地音频/视频文件。
+- 支持输入：11 类平台链接来源、未知平台 HTTPS 音频/视频文件直链，或一个本地音频/视频文件；转写对象仍是具体单集、视频或单条内容。
 - 不支持输入：目录、glob、stdin、多个文件批量队列、断点续传。
 - 本地文件固定作为 `upload` 来源提交，不需要传 `--source`；如果强行传其他来源，CLI 会直接报错。
 - API key 是 CLI 鉴权入口；没有 API key 时不能创建任务。
-- 完整转写会按账号分钟余额扣减；YouTube 字幕直出、喜马拉雅合集、抖音图文、小红书图文、Twitter/X 文本 / 图片推文等不进入完整转写的分支不会扣分钟或创建转写任务。
+- 微信视频号扫码由 Deyo HTTPS 页面完成；CLI 不接收、保存或输出 Cookie、凭据 generation 和签名媒体直链。扫码完成后原任务最多自动重放一次。
+- 完整转写会按账号分钟余额扣减；B站专属视频只按可转写时长向下取整计算分钟。YouTube 字幕直出、喜马拉雅合集、Apple Podcasts 节目主页、小宇宙播客主页、B 站 Bangumi / UGC 合集、抖音图文、小红书图文、Twitter/X 文本 / 图片推文等不进入完整转写的分支不会扣分钟或创建转写任务。
+- Apple Podcasts 节目主页、小宇宙播客主页和 B 站合集的 422 会发生在任务复用、余额检查和分钟扣减之前；CLI/API 不会把它们当作可付费的整套转写任务。网页解析页可以展示这些入口的摘要，但 CLI 不返回单集或视频清单。
 
 `-v, --version`
 
@@ -355,11 +375,13 @@ deyo --api-key 'deyo_sk_other' 'https://www.youtube.com/watch?v=xxxx'
 - `缺少 API key。请传 --api-key、设置 DEYO_API_KEY，或先执行 deyo auth login`：先在 `https://deyo.miaobi.fun/me/api-keys` 创建 key，再执行 `deyo auth login --api-key '...'`。
 - `API key 无效或不存在`：重新创建新的 API key 后再登录。
 - `剩余分钟不足`：完整转写会扣减分钟余额，需要先补充分钟包；YouTube 字幕直出不会走完整转写扣减。
+- Apple Podcasts 节目主页、小宇宙播客主页或 B 站合集返回 422：请在原平台打开具体单集或视频，再把对应链接提交给 CLI；不要尝试把整套节目或合集作为一个任务重试。
 - 本地文件无法识别 MIME：确认是单个普通音频或视频文件；必要时用 `--mime-type audio/mpeg`、`--mime-type video/mp4` 这类 `audio/*` 或 `video/*` 类型覆盖。
 - 媒体检查失败、没有音频轨、ffprobe 失败：换一个包含可转写音轨的普通音视频文件后重试。
 - 上传分片遇到签名过期或 403：CLI 会重新请求签名并重试；如果持续失败，重新运行命令。
 - 任务创建后中断本地 CLI：这只会停止本地等待，不等于取消服务端转写任务；稍后可通过同一任务或历史记录继续查看结果。
 - `--stream-transcript` 组合错误：确认最终格式是 `text`，并同时传入 `--progress-format jsonl`；SRT、VTT、JSON 和 `verbose_json` 不支持正文事件。
+- 视频号提示扫码：桌面环境会尝试自动打开 Deyo 授权页；headless 环境请复制终端打印的 HTTPS 地址到浏览器完成扫码。如果扫码后仍提示授权状态变化，请重新执行一次原命令。
 
 ## 在 AI 工具中使用
 
@@ -385,3 +407,7 @@ deyo --api-key 'deyo_sk_other' 'https://www.youtube.com/watch?v=xxxx'
 ```bash
 deyo --help
 ```
+
+## 来源与合集
+
+支持范围与网页一致：18 个命名平台（含 Instagram、看看新闻、腾讯视频等）、HTTP/HTTPS 通用媒体及单文件上传。视频号受功能开关控制。摘要合集返回 422 `UNSUPPORTED_CONTENT` 和 `mode`；旧 `COLLECTION_UNSUPPORTED` 兼容读取。红果整剧返回 `HONGGUO_EPISODE_REQUIRED` 与归属受控的 `parseToken`；多媒体候选返回 `MULTIPLE_MEDIA_SELECTION_REQUIRED`。请在网页明确选择单项或提交精确单集链接，不自动选集或批量转写。

package/deyo.mjs

@@ -5,7 +5,9 @@ import { createHash } from 'node:crypto'
 import { createRequire } from 'node:module'
 import { basename, dirname, extname, isAbsolute, resolve } from 'node:path'
 import { homedir } from 'node:os'
+import { spawn } from 'node:child_process'
 import process from 'node:process'
+import { createInterface } from 'node:readline/promises'
 import { handleSkillCommand } from './skill-manager.mjs'
 
 const CLI_VERSION = createRequire(import.meta.url)('./package.json').version
@@ -18,13 +20,17 @@ const PROGRESS_FORMATS = new Set(['auto', 'text', 'jsonl'])
 const RESULT_FORMATS = new Set(['text', 'srt', 'vtt', 'json', 'verbose_json'])
 const TERMINAL_STATUSES = new Set(['completed', 'failed', 'cancelled'])
 const MAX_UPLOAD_CONCURRENCY = 3
-const HASH_CHUNK_SIZE = 4 * 1024 * 1024
 const UPLOAD_REDACTED_SOURCE_LABEL = 'upload:file'
 const RETRYABLE_STATUS_CODES = new Set([429, 500, 502, 503, 504])
 const URL_SCHEME_PATTERN = /^[a-z][a-z\d+\-.]*:\/\//i
 const DOMAIN_LIKE_PATTERN = /^(?:[a-z0-9-]+\.)+[a-z]{2,}(?::\d+)?(?:[/?#].*)?$/i
-const SENSITIVE_UPLOAD_RESULT_KEY_PATTERN = /(?:^|_)(?:objectKey|object_key|audioUrl|audio_url|downloadUrl|download_url|signedUrl|signed_url|uploadUrl|upload_url|sourceUrl|source_url|url)$/i
+const SENSITIVE_UPLOAD_RESULT_KEY_PATTERN = /(?:^|_)(?:uploadId|upload_id|objectKey|object_key|ossKey|oss_key|multipartUploadId|multipart_upload_id|etag|audioUrl|audio_url|downloadUrl|download_url|signedUrl|signed_url|uploadUrl|upload_url|sourceUrl|source_url|url)$/i
 const SIGNED_URL_PARAM_PATTERN = /(?:OSSAccessKeyId|Signature|Expires|x-oss-signature|x-oss-credential|x-oss-expires|x-amz-signature)=/i
+const WECHAT_CHANNELS_SENSITIVE_RESULT_KEY_PATTERN = /(?:cookie|credential|generation|mediaUrl|media_url|audioUrl|audio_url|generalToken|general_token|hy_source|hy_user|hy_token|(?:^|_)eid(?:$|_)|(?:^|_)token(?:$|_))/i
+const WECHAT_CHANNELS_SIGNED_MEDIA_PATTERN = /(?:finder\.video\.qq\.com|encfilekey=|[?&]token=)/i
+const WECHAT_CHANNELS_CREDENTIAL_ERROR_CODE = 'WECHAT_CHANNELS_CREDENTIAL_REQUIRED'
+const MAINTENANCE_ERROR_CODES = new Set(['SERVICE_MAINTENANCE', 'MAINTENANCE_STATE_UNAVAILABLE'])
+const WECHAT_CHANNELS_AUTH_TIMEOUT_MS = 5 * 60 * 1000
 const MIME_TYPES_BY_EXTENSION = new Map([
   ['.aac', 'audio/aac'],
   ['.aif', 'audio/aiff'],
@@ -58,9 +64,12 @@ class ReportedCliError extends Error {
 }
 
 class HttpCliError extends Error {
-  constructor(message, status) {
+  constructor(message, status, details = {}) {
     super(message)
     this.status = status
+    this.errorCode = details.errorCode || null
+    this.presentationUrl = details.presentationUrl || null
+    this.retryAfterMs = details.retryAfterMs || null
   }
 }
 
@@ -87,7 +96,7 @@ function printUsage() {
 转写选项:
   --api-key <key>       可选，Deyo API key
   -O, --output <path>   可选，输出文件路径
-  --source <name>       可选，显式指定来源：xiaoyuzhou | ximalaya | bilibili | douyin | xiaohongshu | youtube | apple-podcasts | twitter
+  --source <name>       可选，显式指定来源：xiaoyuzhou | ximalaya | bilibili | douyin | xiaohongshu | youtube | apple-podcasts | twitter | tiktok | instagram | kankanews | wechat_channels | wechat_official_account | hongguo | yanxiu | chaoxing | kuaishou | tencent_video | direct_media
   --file <path>         可选，显式指定本地单个音视频文件
   --mime-type <type>    可选，上传本地文件时显式指定 MIME，例如 audio/mpeg 或 video/mp4
   --language <value>    可选，显式指定转写语言；省略时自动检测
@@ -114,9 +123,16 @@ API key 读取优先级:
   2. 环境变量 DEYO_API_KEY
   3. 本地配置文件（先执行 deyo auth login）
 
+支持来源:
+  Bilibili、抖音、小红书、小宇宙、喜马拉雅、YouTube、Apple Podcasts、Twitter/X、TikTok、Instagram、微信视频号、微信公众号、红果、研直播、超星、快手、腾讯视频、看看新闻；HTTP/HTTPS 通用媒体链接；本地单文件。
+  合集不批量转写；红果及多媒体候选请在网页选一项或提交精确单集链接。
 本地文件说明:
   v1 只支持单文件上传；不支持目录、glob、stdin、批量和断点续传。
   可以用 deyo -- ./audio.mp3 明确把 -- 后的单个参数当作路径或链接。
+
+B站试看说明:
+  B站专属视频会先显示完整时长、可转写时长和预计扣除分钟。
+  只有交互式终端中明确确认后才会创建任务；拒绝或非交互环境均不会扣分钟。
 `)
 }
 
@@ -345,6 +361,9 @@ function isRetryableRequestError(error) {
   }
 
   if (error instanceof HttpCliError) {
+    if (MAINTENANCE_ERROR_CODES.has(error.errorCode)) {
+      return false
+    }
     return RETRYABLE_STATUS_CODES.has(error.status) || error.status >= 500
   }
 
@@ -471,15 +490,35 @@ function formatBytes(value) {
 }
 
 function redactUploadSourceUrl(sourceType, sourceUrl) {
-  if (sourceType === 'upload' || String(sourceUrl || '').startsWith('upload:sha256:')) {
+  if (sourceType === 'upload' || String(sourceUrl || '').startsWith('upload:')) {
     return UPLOAD_REDACTED_SOURCE_LABEL
   }
 
+  if (sourceType === 'direct_media') {
+    try {
+      const parsed = new URL(String(sourceUrl || ''))
+
+      if (
+        parsed.protocol !== 'https:'
+        || parsed.username
+        || parsed.password
+        || parsed.hash
+      ) {
+        return '音频/视频文件链接已隐藏'
+      }
+
+      return `${parsed.origin}${parsed.pathname}`
+    }
+    catch {
+      return '音频/视频文件链接已隐藏'
+    }
+  }
+
   return sourceUrl || null
 }
 
 function isSensitiveUploadResultString(key, value, sourceType = null) {
-  if (value.startsWith('upload:sha256:')) {
+  if (value.startsWith('upload:')) {
     return true
   }
 
@@ -507,6 +546,12 @@ function sanitizeResultPayload(value, inheritedSourceType = null, inheritedKey =
   }
 
   if (!value || typeof value !== 'object') {
+    if (inheritedSourceType === 'wechat_channels' && typeof value === 'string') {
+      return WECHAT_CHANNELS_SIGNED_MEDIA_PATTERN.test(value)
+        ? '[视频号受保护媒体地址已隐藏]'
+        : value
+    }
+
     if (typeof value === 'string' && isSensitiveUploadResultString(inheritedKey, value, inheritedSourceType)) {
       return UPLOAD_REDACTED_SOURCE_LABEL
     }
@@ -518,6 +563,10 @@ function sanitizeResultPayload(value, inheritedSourceType = null, inheritedKey =
   const next = {}
 
   for (const [key, item] of Object.entries(value)) {
+    if (sourceType === 'wechat_channels' && WECHAT_CHANNELS_SENSITIVE_RESULT_KEY_PATTERN.test(key)) {
+      continue
+    }
+
     if (key === 'sourceUrl') {
       next[key] = redactUploadSourceUrl(sourceType, item)
       continue
@@ -793,20 +842,59 @@ function resolveApiKey(explicitApiKey, storedConfig) {
   return null
 }
 
-async function readErrorMessage(response) {
+function normalizeWechatChannelsPresentationUrl(value) {
+  if (typeof value !== 'string' || value.length > 4096) return null
+
+  try {
+    const presentationUrl = new URL(value)
+    if (presentationUrl.protocol !== 'https:' || presentationUrl.username || presentationUrl.password || presentationUrl.hash) return null
+    if (presentationUrl.pathname !== '/parse') return null
+    if (presentationUrl.searchParams.size !== 2) return null
+    if (presentationUrl.searchParams.getAll('source').length !== 1) return null
+    if (presentationUrl.searchParams.getAll('token').length !== 1) return null
+    if ([...presentationUrl.searchParams.keys()].some(key => key !== 'source' && key !== 'token')) return null
+    if (presentationUrl.searchParams.get('source') !== 'wechat_channels') return null
+
+    const token = presentationUrl.searchParams.get('token') || ''
+    if (!/^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(token)) return null
+
+    return presentationUrl.toString()
+  } catch {
+    return null
+  }
+}
+
+async function readErrorResponse(response) {
   const contentType = response.headers.get('content-type') || ''
 
   if (contentType.includes('application/json')) {
     const data = await response.json().catch(() => null)
     const message = data?.message || data?.statusMessage || data?.error?.message
+    const rawErrorCode = data?.data?.errorCode
+    const errorCode = typeof rawErrorCode === 'string' && /^[A-Z0-9_]{1,128}$/.test(rawErrorCode)
+      ? rawErrorCode
+      : null
+    const presentationUrl = errorCode === WECHAT_CHANNELS_CREDENTIAL_ERROR_CODE
+      ? normalizeWechatChannelsPresentationUrl(data?.data?.presentationUrl)
+      : null
+    const rawRetryAfterMs = Number(data?.data?.retryAfterMs)
 
-    if (message) {
-      return String(message)
+    return {
+      message: message ? String(message) : `${response.status} ${response.statusText}`,
+      errorCode,
+      presentationUrl,
+      retryAfterMs: Number.isSafeInteger(rawRetryAfterMs) && rawRetryAfterMs >= 1000 && rawRetryAfterMs <= 5000
+        ? rawRetryAfterMs
+        : null,
     }
   }
 
   const text = await response.text().catch(() => '')
-  return text || `${response.status} ${response.statusText}`
+  return { message: text || `${response.status} ${response.statusText}` }
+}
+
+async function readErrorMessage(response) {
+  return (await readErrorResponse(response)).message
 }
 
 async function requestJson(baseUrl, apiKey, path, options = {}) {
@@ -823,7 +911,8 @@ async function requestJson(baseUrl, apiKey, path, options = {}) {
     })
 
     if (!response.ok) {
-      throw new HttpCliError(await readErrorMessage(response), response.status)
+      const details = await readErrorResponse(response)
+      throw new HttpCliError(details.message, response.status, details)
     }
 
     return response.json()
@@ -971,6 +1060,27 @@ function buildTerminalMessage(status, errorMessage) {
   return errorMessage ? `任务结束：${errorMessage}` : `任务结束：${formatStatus(status)}`
 }
 
+const SAFE_TRANSCRIPTION_FAILURE_MESSAGES = new Map([
+  ['ASR_CAPABILITY_UNSUPPORTED', '当前转写运行环境暂不支持这项任务，请等待服务升级后再试。'],
+  ['ASR_IDENTITY_CHANGED', '转写运行环境在任务期间发生变化，为保护结果一致性，本次任务已停止。'],
+  ['ASR_TIMELINE_EVIDENCE_MISMATCH', '转写时间轴证据无法安全对齐，可以使用当前订单完整重新转写。'],
+  ['ASR_CONTINUE_EVIDENCE_MISMATCH', '现有进度缺少可安全续传的证据，可以使用当前订单完整重新转写。'],
+  ['ASR_RESPONSE_CONTRACT_MISMATCH', '转写运行环境协议不兼容，可以在服务更新后使用当前订单完整重新转写。'],
+  ['SOURCE_MEDIA_REDIRECT_LIMIT_EXCEEDED', '媒体地址重定向次数过多，暂时无法下载，可以稍后使用当前订单完整重新转写。'],
+  ['SOURCE_MEDIA_TIMEOUT', '媒体下载超时，可以稍后使用当前订单完整重新转写。'],
+  ['SOURCE_MEDIA_DOWNLOAD_FAILED', '媒体下载失败，可以稍后使用当前订单完整重新转写。'],
+  ['SOURCE_MEDIA_ALL_CANDIDATES_FAILED', '所有可用媒体地址均下载失败，可以稍后使用当前订单完整重新转写。'],
+  ['TRANSCRIPTION_FAILED', '转写失败，请稍后再试。'],
+])
+
+function getSafeTranscriptionFailureMessage(data) {
+  if (!data || typeof data !== 'object' || Array.isArray(data)) {
+    return '转写失败'
+  }
+
+  return SAFE_TRANSCRIPTION_FAILURE_MESSAGES.get(data.errorCode) || '转写失败'
+}
+
 function normalizeProgressValue(progress, finishedChunks, totalChunks) {
   if (Number.isFinite(progress) && progress >= 0) {
     return Math.max(0, Math.min(1, progress))
@@ -1024,14 +1134,6 @@ function buildUploadProgressMessage(input = {}) {
   return `上传中 ${formatBytes(uploadedBytes)} / ${formatBytes(totalBytes)} (${percent}%)`
 }
 
-function buildHashingMessage(input = {}) {
-  const hashedBytes = Number(input.hashedBytes) || 0
-  const totalBytes = Number(input.totalBytes) || 0
-  const percent = normalizeUploadPercent(hashedBytes, totalBytes)
-
-  return `正在计算文件哈希 ${percent}%`
-}
-
 function getUploadReadyMessage(input = {}) {
   const title = input.title || input.filename || '上传文件'
   const duration = Number(input.durationSeconds)
@@ -1054,7 +1156,7 @@ function getUploadTaskFromCheckResult(checkResult) {
   return null
 }
 
-function getUploadReadySummary(checkResult, fileInput, uploadId) {
+function getUploadReadySummary(checkResult, fileInput) {
   const task = getUploadTaskFromCheckResult(checkResult)
   const upload = checkResult?.upload || {}
   const durationMs = Number(upload.ffprobeDurationMs || upload.clientDurationMs)
@@ -1067,7 +1169,6 @@ function getUploadReadySummary(checkResult, fileInput, uploadId) {
   const requiredMinutes = Number(checkResult?.requiredMinutes)
 
   return {
-    uploadId,
     filename: upload.filename || fileInput.filename,
     title: task?.title || checkResult?.title || upload.filename || fileInput.filename,
     durationSeconds: normalizedDurationSeconds,
@@ -1136,36 +1237,6 @@ function createProgressReporter(progressFormat) {
       writeTextMessage(`本次消耗分钟：${safeTask.consumedMinutes}`)
       writeTextMessage(`剩余分钟：${safeTask.remainingMinutes}`)
     },
-    reportUploadHashing(input = {}) {
-      const message = buildHashingMessage(input)
-      const hashedBytes = Number(input.hashedBytes) || 0
-      const totalBytes = Number(input.totalBytes) || 0
-      const percent = normalizeUploadPercent(hashedBytes, totalBytes)
-
-      if (resolvedMode === 'interactive') {
-        writeInline(outputState, message)
-        return
-      }
-
-      if (resolvedMode === 'jsonl') {
-        writeJsonEvent({
-          event: 'upload.hashing',
-          message,
-          filename: input.filename || null,
-          hashedBytes,
-          totalBytes,
-          percent,
-        })
-        return
-      }
-
-      if (message === lastTextProgressMessage) {
-        return
-      }
-
-      lastTextProgressMessage = message
-      writeTextMessage(message)
-    },
     reportUploadStarted(input = {}) {
       lastTextProgressMessage = ''
       const message = `上传已开始：${input.filename || '上传文件'}（${formatBytes(input.totalBytes)}）`
@@ -1175,7 +1246,6 @@ function createProgressReporter(progressFormat) {
         filename: input.filename || null,
         mimeType: input.mimeType || null,
         totalBytes: Number(input.totalBytes) || 0,
-        uploadId: input.uploadId || null,
         partSize: Number(input.partSize) || null,
         totalParts: Number(input.totalParts) || null,
       })
@@ -1218,7 +1288,6 @@ function createProgressReporter(progressFormat) {
 
       emitTextOrJson(message, {
         event: 'upload.completed',
-        uploadId: input.uploadId || null,
         filename: input.filename || null,
         totalBytes: Number(input.totalBytes) || 0,
       })
@@ -1228,7 +1297,6 @@ function createProgressReporter(progressFormat) {
 
       emitTextOrJson(message, {
         event: 'upload.checking',
-        uploadId: input.uploadId || null,
       })
     },
     reportUploadReady(input = {}) {
@@ -1236,7 +1304,6 @@ function createProgressReporter(progressFormat) {
 
       emitTextOrJson(message, {
         event: 'upload.ready',
-        uploadId: input.uploadId || null,
         sourceType: 'upload',
         sourceUrl: UPLOAD_REDACTED_SOURCE_LABEL,
         title: input.title || input.filename || null,
@@ -1250,14 +1317,12 @@ function createProgressReporter(progressFormat) {
 
       emitTextOrJson(message, {
         event: 'upload.aborted',
-        uploadId: input.uploadId || null,
       })
     },
     reportUploadFailed(message, input = {}) {
       finishInline(outputState)
       emitTextOrJson(message, {
         event: 'upload.failed',
-        uploadId: input.uploadId || null,
         error: message,
       })
     },
@@ -1381,6 +1446,17 @@ function createProgressReporter(progressFormat) {
         event: 'task.notice',
       })
     },
+    reportWechatChannelsCredentialRequired(presentationUrl, browserOpened) {
+      const message = browserOpened
+        ? `已尝试打开视频号扫码授权页；如浏览器未自动打开，请复制：${presentationUrl}`
+        : `请复制到浏览器完成视频号扫码授权：${presentationUrl}`
+      emitTextOrJson(message, {
+        event: 'wechat_channels.credential_required',
+        errorCode: WECHAT_CHANNELS_CREDENTIAL_ERROR_CODE,
+        presentationUrl,
+        browserOpened,
+      })
+    },
     close() {
       finishInline(outputState)
     },
@@ -1595,7 +1671,12 @@ async function consumeTaskEvents(baseUrl, apiKey, taskId, initialTask, reporter,
       if (data?.status === 'transcribing') {
         renderProgress(data)
       } else if (TERMINAL_STATUSES.has(data?.status)) {
-        applyTerminal(data.status, data?.error || data?.message || null)
+        applyTerminal(
+          data.status,
+          data.status === 'failed'
+            ? getSafeTranscriptionFailureMessage(data)
+            : data?.error || data?.message || null,
+        )
       } else {
         applyStatus(data?.status)
       }
@@ -1623,7 +1704,7 @@ async function consumeTaskEvents(baseUrl, apiKey, taskId, initialTask, reporter,
     }
 
     if (event === 'job.failed') {
-      applyTerminal('failed', data?.error || data?.message || '转写失败')
+      applyTerminal('failed', getSafeTranscriptionFailureMessage(data))
       return true
     }
 
@@ -1707,48 +1788,6 @@ function assertNotAborted(signal) {
   }
 }
 
-async function calculateFileSha256(fileInput, reporter, signal) {
-  const hash = createHash('sha256')
-  const fileHandle = await open(fileInput.path, 'r')
-  let hashedBytes = 0
-
-  reporter.reportUploadHashing({
-    filename: fileInput.filename,
-    hashedBytes,
-    totalBytes: fileInput.sizeBytes,
-  })
-
-  try {
-    while (hashedBytes < fileInput.sizeBytes) {
-      assertNotAborted(signal)
-
-      const length = Math.min(HASH_CHUNK_SIZE, fileInput.sizeBytes - hashedBytes)
-      const buffer = Buffer.allocUnsafe(length)
-      const { bytesRead } = await fileHandle.read(buffer, 0, length, hashedBytes)
-
-      if (bytesRead <= 0) {
-        break
-      }
-
-      hash.update(bytesRead === buffer.length ? buffer : buffer.subarray(0, bytesRead))
-      hashedBytes += bytesRead
-      reporter.reportUploadHashing({
-        filename: fileInput.filename,
-        hashedBytes,
-        totalBytes: fileInput.sizeBytes,
-      })
-    }
-  } finally {
-    await fileHandle.close().catch(() => {})
-  }
-
-  if (hashedBytes !== fileInput.sizeBytes) {
-    throw new Error('读取本地文件计算哈希时大小不一致，请重新选择文件')
-  }
-
-  return hash.digest('hex')
-}
-
 async function readFileChunk(filePath, start, length, signal) {
   assertNotAborted(signal)
 
@@ -1825,8 +1864,7 @@ function createRunContext(baseUrl, apiKey, reporter) {
       }
 
       if (!state.uploadAbortAllowed && state.uploadId) {
-        const taskPart = state.taskId ? `，taskId=${state.taskId}` : ''
-        reporter.reportNotice(`已停止本地等待，服务端正在处理上传：uploadId=${state.uploadId}${taskPart}`)
+        reporter.reportNotice('已停止本地等待，服务端正在处理上传')
         reporter.close()
         return
       }
@@ -2019,7 +2057,6 @@ async function uploadLocalFile(fileInput, args, baseUrl, apiKey, reporter, runCo
   let uploadId = ''
 
   try {
-    const fileHash = await calculateFileSha256(fileInput, reporter, runContext.signal)
     const startResponse = await requestJson(baseUrl, apiKey, '/api/cli/uploads/start', {
       method: 'POST',
       signal: runContext.signal,
@@ -2028,7 +2065,6 @@ async function uploadLocalFile(fileInput, args, baseUrl, apiKey, reporter, runCo
         filename: fileInput.filename,
         mimeType: fileInput.mimeType,
         sizeBytes: fileInput.sizeBytes,
-        fileHash,
       },
     })
 
@@ -2080,14 +2116,15 @@ async function uploadLocalFile(fileInput, args, baseUrl, apiKey, reporter, runCo
     runContext.state.uploadAbortAllowed = false
     reporter.reportUploadChecking({ uploadId })
 
+    const checkBody = { uploadId }
+    if (args.language) {
+      checkBody.language = args.language
+    }
     const checkResult = await requestJson(baseUrl, apiKey, '/api/cli/uploads/check', {
       method: 'POST',
       signal: runContext.signal,
       retry: true,
-      body: {
-        uploadId,
-        ...(args.language ? { language: args.language } : {}),
-      },
+      body: checkBody,
     })
     const checkedTask = getUploadTaskFromCheckResult(checkResult)
 
@@ -2096,7 +2133,7 @@ async function uploadLocalFile(fileInput, args, baseUrl, apiKey, reporter, runCo
       runContext.state.taskCreated = true
     }
 
-    reporter.reportUploadReady(getUploadReadySummary(checkResult, fileInput, uploadId))
+    reporter.reportUploadReady(getUploadReadySummary(checkResult, fileInput))
 
     return {
       ...checkResult,
@@ -2193,9 +2230,11 @@ async function handleAuthCommand(argv) {
 function buildUrlTaskCreatePayload(args, input) {
   const createPayload = {
     url: input.url,
-    ...(args.language ? { language: args.language } : {}),
   }
 
+  if (args.language) {
+    createPayload.language = args.language
+  }
   if (args.source) {
     createPayload.source = args.source
   }
@@ -2203,13 +2242,102 @@ function buildUrlTaskCreatePayload(args, input) {
   return createPayload
 }
 
-async function createCliTask(baseUrl, apiKey, createPayload, reporter, runContext) {
-  const created = await requestJson(baseUrl, apiKey, '/api/cli/transcriptions', {
+function shouldPreflightBilibiliUrl(args, input) {
+  if (args.source === 'bilibili') return true
+  if (typeof input?.url !== 'string') return false
+  if (/^bilibili:\/\/video\//i.test(input.url)) return true
+
+  try {
+    const hostname = new URL(input.url).hostname.toLowerCase()
+    return hostname === 'bilibili.com'
+      || hostname.endsWith('.bilibili.com')
+      || hostname === 'b23.tv'
+  } catch {
+    return false
+  }
+}
+
+async function confirmBilibiliTrial(preflight) {
+  process.stderr.write(`${preflight.message || '这是B站专属视频，Deyo 只能转写试看部分'}\n`)
+  process.stderr.write(`完整时长：${preflight.fullDurationLabel || `${preflight.fullDurationSeconds} 秒`}\n`)
+  process.stderr.write(`可转写时长：${preflight.transcribableDurationLabel || `${preflight.transcribableDurationSeconds} 秒`}\n`)
+  process.stderr.write(`本次预计扣除：${preflight.requiredMinutes} 分钟\n`)
+
+  if (!process.stdin.isTTY) {
+    process.stderr.write('当前不是交互式终端，已取消且不会创建任务或扣除分钟。请在交互终端中重新执行并确认。\n')
+    return false
+  }
+
+  const prompt = createInterface({
+    input: process.stdin,
+    output: process.stderr,
+  })
+
+  try {
+    const answer = (await prompt.question('仍然转写试看部分？请输入 y 确认 [y/N]：')).trim().toLowerCase()
+    return answer === 'y' || answer === 'yes'
+  } finally {
+    prompt.close()
+  }
+}
+
+async function preflightBilibiliTask(baseUrl, apiKey, createPayload, runContext) {
+  const preflight = await requestJson(baseUrl, apiKey, '/api/cli/transcriptions/preflight', {
     method: 'POST',
     signal: runContext.signal,
     body: createPayload,
   })
 
+  if (preflight?.confirmationRequired) {
+    const confirmed = await confirmBilibiliTrial(preflight)
+
+    if (!confirmed) {
+      if (process.stdin.isTTY) {
+        process.stderr.write('已取消，不会创建任务或扣除分钟。\n')
+      }
+      throw new ReportedCliError('已取消')
+    }
+  }
+
+  if (!preflight?.parseToken) {
+    throw new Error('服务端预检未返回有效的 parse token')
+  }
+
+  return createPayload.language
+    ? { parseToken: preflight.parseToken, language: createPayload.language }
+    : { parseToken: preflight.parseToken }
+}
+
+async function createCliTask(baseUrl, apiKey, createPayload, reporter, runContext) {
+  const createRequest = () => requestJson(baseUrl, apiKey, '/api/cli/transcriptions', {
+      method: 'POST',
+      signal: runContext.signal,
+      body: createPayload,
+    })
+  let created
+
+  try {
+    created = await createRequest()
+  } catch (error) {
+    if (!(error instanceof HttpCliError) || error.errorCode !== WECHAT_CHANNELS_CREDENTIAL_ERROR_CODE) throw error
+    if (!error.presentationUrl) throw new Error('服务端返回的视频号授权地址无效，请稍后重试')
+
+    const browserOpened = tryOpenSystemBrowser(error.presentationUrl)
+    reporter.reportWechatChannelsCredentialRequired(error.presentationUrl, browserOpened)
+    const parseToken = new URL(error.presentationUrl).searchParams.get('token')
+    if (!parseToken) throw new Error('服务端返回的视频号解析地址无效，请稍后重试')
+    await waitForParseResume(baseUrl, apiKey, parseToken, runContext, error.retryAfterMs)
+
+    try {
+      created = await createRequest()
+    } catch (replayError) {
+      if (replayError instanceof HttpCliError && replayError.errorCode === WECHAT_CHANNELS_CREDENTIAL_ERROR_CODE) {
+        throw new Error('视频号授权状态已变化，请重新执行原命令')
+      }
+      throw replayError
+    }
+  }
+
   runContext.state.taskId = created.taskId || ''
   runContext.state.taskCreated = true
   reporter.reportTaskCreated(created)
@@ -2217,6 +2345,49 @@ async function createCliTask(baseUrl, apiKey, createPayload, reporter, runContex
   return created
 }
 
+function tryOpenSystemBrowser(url) {
+  const command = process.platform === 'darwin'
+    ? { file: 'open', args: [url] }
+    : process.platform === 'win32'
+      ? { file: 'cmd', args: ['/c', 'start', '', url] }
+      : { file: 'xdg-open', args: [url] }
+
+  try {
+    const child = spawn(command.file, command.args, {
+      detached: true,
+      stdio: 'ignore',
+    })
+    child.once('error', () => {})
+    child.unref()
+    return true
+  } catch {
+    return false
+  }
+}
+
+async function waitForParseResume(baseUrl, apiKey, parseToken, runContext, initialRetryAfterMs) {
+  const startedAt = Date.now()
+  let retryAfterMs = Number.isSafeInteger(initialRetryAfterMs) ? initialRetryAfterMs : POLL_INTERVAL_MS
+
+  while (Date.now() - startedAt < WECHAT_CHANNELS_AUTH_TIMEOUT_MS) {
+    await sleep(retryAfterMs)
+    if (runContext.signal.aborted) throw createAbortError()
+
+    const status = await requestJson(baseUrl, apiKey, `/api/cli/parse-status?token=${encodeURIComponent(parseToken)}`, {
+      signal: runContext.signal,
+      retry: true,
+    })
+
+    if (status?.status === 'ready') return
+    if (status?.status !== 'pending') throw new Error('服务端返回了未知的解析状态')
+    retryAfterMs = Number.isSafeInteger(status.retryAfterMs) && status.retryAfterMs >= 1000 && status.retryAfterMs <= 5000
+      ? status.retryAfterMs
+      : POLL_INTERVAL_MS
+  }
+
+  throw new Error('等待视频号扫码授权超时，请重新执行原命令')
+}
+
 function reportTaskStatusTransition(reporter, previousStatus, task) {
   if (task.status === previousStatus) {
     return task.status
@@ -2482,6 +2653,15 @@ async function handleTranscription(argv) {
       }
     } else {
       createPayload = buildUrlTaskCreatePayload(args, input)
+
+      if (shouldPreflightBilibiliUrl(args, input)) {
+        createPayload = await preflightBilibiliTask(
+          baseUrl,
+          resolvedApiKey.apiKey,
+          createPayload,
+          runContext,
+        )
+      }
     }
 
     if (!created) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@casatwy/deyo",
-  "version": "0.2.3",
+  "version": "0.2.6",
   "description": "Deyo transcription CLI with link/file input, JSONL progress, and opt-in stable transcript streaming",
   "homepage": "https://deyo.miaobi.fun/docs",
   "license": "UNLICENSED",