@casatwy/deyo 0.1.7 → 0.2.0

package/deyo.mjs

@@ -1,21 +1,69 @@
 #!/usr/bin/env node
 
-import { chmod, mkdir, readFile, rm, writeFile } from 'node:fs/promises'
+import { chmod, mkdir, open, readFile, rm, stat, writeFile } from 'node:fs/promises'
+import { createHash } from 'node:crypto'
 import { createRequire } from 'node:module'
-import { dirname, extname, resolve } from 'node:path'
+import { basename, dirname, extname, isAbsolute, resolve } from 'node:path'
 import { homedir } from 'node:os'
 import process from 'node:process'
+import { handleSkillCommand } from './skill-manager.mjs'
 
 const CLI_VERSION = createRequire(import.meta.url)('./package.json').version
 
 const DEFAULT_BASE_URL = 'https://deyo.miaobi.fun'
 const DEFAULT_LANGUAGE = 'zh'
 const POLL_INTERVAL_MS = 1500
+const SSE_RECONNECT_DELAYS_MS = [1000, 2000, 4000]
+const SSE_RECOVERY_INTERVAL_MS = 15000
 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 SIGNED_URL_PARAM_PATTERN = /(?:OSSAccessKeyId|Signature|Expires|x-oss-signature|x-oss-credential|x-oss-expires|x-amz-signature)=/i
+const MIME_TYPES_BY_EXTENSION = new Map([
+  ['.aac', 'audio/aac'],
+  ['.aif', 'audio/aiff'],
+  ['.aiff', 'audio/aiff'],
+  ['.amr', 'audio/amr'],
+  ['.flac', 'audio/flac'],
+  ['.m4a', 'audio/mp4'],
+  ['.mp3', 'audio/mpeg'],
+  ['.oga', 'audio/ogg'],
+  ['.ogg', 'audio/ogg'],
+  ['.opus', 'audio/opus'],
+  ['.wav', 'audio/wav'],
+  ['.weba', 'audio/webm'],
+  ['.wma', 'audio/x-ms-wma'],
+  ['.3gp', 'video/3gpp'],
+  ['.avi', 'video/x-msvideo'],
+  ['.m4v', 'video/x-m4v'],
+  ['.mkv', 'video/x-matroska'],
+  ['.mov', 'video/quicktime'],
+  ['.mp4', 'video/mp4'],
+  ['.mpeg', 'video/mpeg'],
+  ['.mpg', 'video/mpeg'],
+  ['.webm', 'video/webm'],
+])
+
+class ReportedCliError extends Error {
+  constructor(message = '', exitCode = 1) {
+    super(message)
+    this.exitCode = exitCode
+  }
+}
 
-class ReportedCliError extends Error {}
+class HttpCliError extends Error {
+  constructor(message, status) {
+    super(message)
+    this.status = status
+  }
+}
 
 function safeJsonParse(value) {
   try {
@@ -32,16 +80,21 @@ function fail(message, exitCode = 1) {
 
 function printUsage() {
   process.stderr.write(`用法:
-  deyo [选项] <url>
+  deyo [选项] <url|file>
+  deyo [选项] --file <file>
   deyo auth <login|logout|status> [选项]
+  deyo skill <install|status> [选项]
 
 转写选项:
   --api-key <key>       可选，Deyo API key
   -O, --output <path>   可选，输出文件路径
   --source <name>       可选，显式指定来源：xiaoyuzhou | ximalaya | bilibili | douyin | xiaohongshu | youtube | apple-podcasts | twitter
+  --file <path>         可选，显式指定本地单个音视频文件
+  --mime-type <type>    可选，上传本地文件时显式指定 MIME，例如 audio/mpeg 或 video/mp4
   --language <value>    可选，转写语言，默认 ${DEFAULT_LANGUAGE}
   --format <value>      可选，text | srt | vtt | json | verbose_json
   --progress-format <v> 可选，auto | text | jsonl，默认 auto
+  --stream-transcript   可选，通过 stderr JSONL 输出稳定正文；仅支持 text 且必须搭配 --progress-format jsonl
   --base-url <url>      可选，默认 ${DEFAULT_BASE_URL}
   -h, --help            显示帮助
   -v, --version         显示 CLI 版本
@@ -51,10 +104,18 @@ auth 子命令:
   deyo auth logout
   deyo auth status
 
+Skill 管理:
+  deyo skill install --platform codex|claude|gemini|openclaw [--scope user|workspace|global]
+  deyo skill status [--platform codex|claude|gemini|openclaw] [--json]
+
 API key 读取优先级:
   1. --api-key
   2. 环境变量 DEYO_API_KEY
   3. 本地配置文件（先执行 deyo auth login）
+
+本地文件说明:
+  v1 只支持单文件上传；不支持目录、glob、stdin、批量和断点续传。
+  可以用 deyo -- ./audio.mp3 明确把 -- 后的单个参数当作路径或链接。
 `)
 }
 
@@ -76,11 +137,15 @@ function parseTranscriptionArgs(argv) {
     apiKey: '',
     output: '',
     source: '',
+    file: '',
+    mimeType: '',
     language: '',
     format: '',
     progressFormat: 'auto',
+    streamTranscript: false,
     baseUrl: '',
     url: '',
+    positional: [],
   }
 
   for (let index = 0; index < argv.length; index += 1) {
@@ -91,6 +156,17 @@ function parseTranscriptionArgs(argv) {
       process.exit(0)
     }
 
+    if (current === '--') {
+      const rest = argv.slice(index + 1)
+
+      if (rest.length !== 1) {
+        fail('-- 后只能提供一个本地文件路径或内容链接')
+      }
+
+      args.positional.push(rest[0])
+      break
+    }
+
     if (current === '-O' || current === '--output') {
       args.output = argv[index + 1] || ''
       index += 1
@@ -109,6 +185,18 @@ function parseTranscriptionArgs(argv) {
       continue
     }
 
+    if (current === '--file') {
+      args.file = argv[index + 1] || ''
+      index += 1
+      continue
+    }
+
+    if (current === '--mime-type') {
+      args.mimeType = argv[index + 1] || ''
+      index += 1
+      continue
+    }
+
     if (current === '--language') {
       args.language = argv[index + 1] || ''
       index += 1
@@ -127,6 +215,11 @@ function parseTranscriptionArgs(argv) {
       continue
     }
 
+    if (current === '--stream-transcript') {
+      args.streamTranscript = true
+      continue
+    }
+
     if (current === '--base-url') {
       args.baseUrl = argv[index + 1] || ''
       index += 1
@@ -137,13 +230,18 @@ function parseTranscriptionArgs(argv) {
       fail(`未知参数：${current}`)
     }
 
-    if (args.url) {
-      fail('只能提供一个内容链接')
-    }
+    args.positional.push(current)
+  }
+
+  if (args.positional.length > 1) {
+    fail('v1 只支持提交一个链接或一个本地文件，不支持批量转写')
+  }
 
-    args.url = current
+  if (args.file && args.positional.length) {
+    fail('--file 不能和额外的路径或 URL 同时使用')
   }
 
+  args.url = args.positional[0] || ''
   return args
 }
 
@@ -216,6 +314,309 @@ function inferFormat(outputPath, explicitFormat) {
   return 'text'
 }
 
+function validateTranscriptStreaming(args, format) {
+  if (!args.streamTranscript) {
+    return
+  }
+
+  if (format !== 'text') {
+    fail('--stream-transcript 仅支持 text 结果格式')
+  }
+
+  if (args.progressFormat !== 'jsonl') {
+    fail('--stream-transcript 必须搭配 --progress-format jsonl')
+  }
+}
+
+function isAbortError(error) {
+  return error?.name === 'AbortError' || error?.code === 'ABORT_ERR'
+}
+
+function createAbortError() {
+  const error = new Error('操作已中断')
+  error.name = 'AbortError'
+  return error
+}
+
+function isRetryableRequestError(error) {
+  if (isAbortError(error)) {
+    return false
+  }
+
+  if (error instanceof HttpCliError) {
+    return RETRYABLE_STATUS_CODES.has(error.status) || error.status >= 500
+  }
+
+  return true
+}
+
+function getRetryDelayMs(attempt) {
+  return Math.min(4000, 350 * (2 ** Math.max(0, attempt - 1)))
+}
+
+async function withRetry(operation, options = {}) {
+  const maxAttempts = options.maxAttempts || 4
+  let lastError = null
+
+  for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+    try {
+      return await operation(attempt)
+    } catch (error) {
+      lastError = error
+
+      if (options.signal?.aborted || isAbortError(error)) {
+        throw error
+      }
+
+      const shouldRetry = options.shouldRetry
+        ? options.shouldRetry(error)
+        : isRetryableRequestError(error)
+
+      if (!shouldRetry || attempt >= maxAttempts) {
+        throw error
+      }
+
+      await sleep(getRetryDelayMs(attempt))
+    }
+  }
+
+  throw lastError || new Error('请求失败')
+}
+
+function isLikelyUrlInput(value) {
+  const normalized = String(value || '').trim()
+
+  return URL_SCHEME_PATTERN.test(normalized) || DOMAIN_LIKE_PATTERN.test(normalized)
+}
+
+function isStdinInput(value) {
+  return String(value || '').trim() === '-'
+}
+
+function hasGlobPattern(value) {
+  const normalized = String(value || '')
+  return /[*[\]{}]/.test(normalized) || (!isLikelyUrlInput(normalized) && normalized.includes('?'))
+}
+
+function expandHomePath(value) {
+  const normalized = String(value || '').trim()
+
+  if (normalized === '~') {
+    return homedir() || normalized
+  }
+
+  if (normalized.startsWith('~/')) {
+    const home = homedir()
+    return home ? resolve(home, normalized.slice(2)) : normalized
+  }
+
+  return normalized
+}
+
+function resolveLocalPath(value) {
+  const expanded = expandHomePath(value)
+  return isAbsolute(expanded) ? expanded : resolve(process.cwd(), expanded)
+}
+
+function isAllowedLocalMimeType(value) {
+  const normalized = String(value || '').trim().toLowerCase()
+  return normalized.startsWith('audio/') || normalized.startsWith('video/')
+}
+
+function normalizeExplicitMimeType(value) {
+  const normalized = String(value || '').trim().toLowerCase()
+
+  if (!normalized) {
+    return ''
+  }
+
+  if (!/^[a-z0-9][a-z0-9!#$&^_.+-]*\/[a-z0-9][a-z0-9!#$&^_.+-]*(?:\s*;.*)?$/i.test(normalized)) {
+    fail(`--mime-type 不是合法 MIME：${value}`)
+  }
+
+  if (!isAllowedLocalMimeType(normalized)) {
+    fail('--mime-type 只支持 audio/* 或 video/*')
+  }
+
+  return normalized.split(';')[0].trim()
+}
+
+function inferMimeTypeFromPath(filePath) {
+  return MIME_TYPES_BY_EXTENSION.get(extname(filePath).toLowerCase()) || ''
+}
+
+function normalizeEtag(value) {
+  return String(value || '').trim().replace(/^"+|"+$/g, '')
+}
+
+function formatBytes(value) {
+  const bytes = Number(value)
+
+  if (!Number.isFinite(bytes) || bytes <= 0) {
+    return '0 B'
+  }
+
+  const units = ['B', 'KB', 'MB', 'GB', 'TB']
+  let size = bytes
+  let unitIndex = 0
+
+  while (size >= 1024 && unitIndex < units.length - 1) {
+    size /= 1024
+    unitIndex += 1
+  }
+
+  const precision = size >= 10 || unitIndex === 0 ? 0 : 1
+  return `${size.toFixed(precision)} ${units[unitIndex]}`
+}
+
+function redactUploadSourceUrl(sourceType, sourceUrl) {
+  if (sourceType === 'upload' || String(sourceUrl || '').startsWith('upload:sha256:')) {
+    return UPLOAD_REDACTED_SOURCE_LABEL
+  }
+
+  return sourceUrl || null
+}
+
+function isSensitiveUploadResultString(key, value, sourceType = null) {
+  if (value.startsWith('upload:sha256:')) {
+    return true
+  }
+
+  if (SIGNED_URL_PARAM_PATTERN.test(value)) {
+    return true
+  }
+
+  return sourceType === 'upload' && !!key && SENSITIVE_UPLOAD_RESULT_KEY_PATTERN.test(key)
+}
+
+function sanitizeTaskForReporting(task) {
+  if (!task || typeof task !== 'object') {
+    return task
+  }
+
+  return {
+    ...task,
+    sourceUrl: redactUploadSourceUrl(task.sourceType, task.sourceUrl),
+  }
+}
+
+function sanitizeResultPayload(value, inheritedSourceType = null, inheritedKey = null) {
+  if (Array.isArray(value)) {
+    return value.map(item => sanitizeResultPayload(item, inheritedSourceType, inheritedKey))
+  }
+
+  if (!value || typeof value !== 'object') {
+    if (typeof value === 'string' && isSensitiveUploadResultString(inheritedKey, value, inheritedSourceType)) {
+      return UPLOAD_REDACTED_SOURCE_LABEL
+    }
+
+    return value
+  }
+
+  const sourceType = typeof value.sourceType === 'string' ? value.sourceType : inheritedSourceType
+  const next = {}
+
+  for (const [key, item] of Object.entries(value)) {
+    if (key === 'sourceUrl') {
+      next[key] = redactUploadSourceUrl(sourceType, item)
+      continue
+    }
+
+    next[key] = sanitizeResultPayload(item, sourceType, key)
+  }
+
+  return next
+}
+
+async function inspectLocalFile(filePath, explicitMimeType) {
+  const trimmedPath = String(filePath || '').trim()
+
+  if (!trimmedPath) {
+    fail('缺少本地文件路径')
+  }
+
+  if (isStdinInput(trimmedPath)) {
+    fail('v1 不支持从 stdin 读取，请提供本地单个音视频文件路径')
+  }
+
+  if (hasGlobPattern(trimmedPath)) {
+    fail('v1 不支持 glob，请提供一个明确的本地文件路径')
+  }
+
+  const resolvedPath = resolveLocalPath(trimmedPath)
+  let fileStat
+
+  try {
+    fileStat = await stat(resolvedPath)
+  } catch (error) {
+    if (error && typeof error === 'object' && 'code' in error && error.code === 'ENOENT') {
+      fail(`本地文件不存在：${trimmedPath}`)
+    }
+
+    throw error
+  }
+
+  if (fileStat.isDirectory()) {
+    fail('v1 不支持目录，请提供一个本地音视频文件')
+  }
+
+  if (!fileStat.isFile()) {
+    fail('v1 只支持普通本地文件，不支持管道、设备或其他特殊文件')
+  }
+
+  if (fileStat.size <= 0) {
+    fail('本地文件为空，无法转写')
+  }
+
+  const explicit = normalizeExplicitMimeType(explicitMimeType)
+  const mimeType = explicit || inferMimeTypeFromPath(resolvedPath)
+
+  if (!mimeType || !isAllowedLocalMimeType(mimeType)) {
+    fail('无法识别本地文件 MIME，请使用 --mime-type 指定 audio/* 或 video/*')
+  }
+
+  return {
+    kind: 'file',
+    path: resolvedPath,
+    filename: basename(resolvedPath),
+    sizeBytes: fileStat.size,
+    mimeType,
+  }
+}
+
+async function resolveTranscriptionInput(args) {
+  if (args.file) {
+    return await inspectLocalFile(args.file, args.mimeType)
+  }
+
+  const rawInput = String(args.url || '').trim()
+
+  if (!rawInput) {
+    return null
+  }
+
+  if (isStdinInput(rawInput)) {
+    fail('v1 不支持从 stdin 读取，请提供内容链接或本地单个音视频文件')
+  }
+
+  if (!isLikelyUrlInput(rawInput) && hasGlobPattern(rawInput)) {
+    fail('v1 不支持 glob，请提供一个明确的本地文件路径或内容链接')
+  }
+
+  if (!isLikelyUrlInput(rawInput)) {
+    return await inspectLocalFile(rawInput, args.mimeType)
+  }
+
+  if (args.mimeType) {
+    fail('--mime-type 只能用于本地文件上传')
+  }
+
+  return {
+    kind: 'url',
+    url: rawInput,
+  }
+}
+
 function getConfigFileCandidates() {
   const home = homedir()
   const xdgConfigHome = String(process.env.XDG_CONFIG_HOME || '').trim()
@@ -408,40 +809,80 @@ async function readErrorMessage(response) {
 }
 
 async function requestJson(baseUrl, apiKey, path, options = {}) {
-  const response = await fetch(`${baseUrl}${path}`, {
-    method: options.method || 'GET',
+  return await withRetry(async () => {
+    const response = await fetch(`${baseUrl}${path}`, {
+      method: options.method || 'GET',
+      signal: options.signal,
+      headers: {
+        Authorization: `Bearer ${apiKey}`,
+        'Content-Type': 'application/json',
+        ...(options.headers || {}),
+      },
+      body: typeof options.body === 'undefined' ? undefined : JSON.stringify(options.body),
+    })
+
+    if (!response.ok) {
+      throw new HttpCliError(await readErrorMessage(response), response.status)
+    }
+
+    return response.json()
+  }, {
+    signal: options.signal,
+    maxAttempts: options.retry ? 4 : 1,
+  })
+}
+
+async function requestResult(baseUrl, apiKey, taskId, format, options = {}) {
+  const response = await fetch(`${baseUrl}/api/cli/transcriptions/${encodeURIComponent(taskId)}/result?format=${encodeURIComponent(format)}`, {
+    method: 'GET',
+    signal: options.signal,
     headers: {
       Authorization: `Bearer ${apiKey}`,
-      'Content-Type': 'application/json',
-      ...(options.headers || {}),
     },
-    body: typeof options.body === 'undefined' ? undefined : JSON.stringify(options.body),
   })
 
   if (!response.ok) {
     throw new Error(await readErrorMessage(response))
   }
 
-  return response.json()
+  if (format === 'json' || format === 'verbose_json') {
+    return JSON.stringify(sanitizeResultPayload(await response.json()), null, 2)
+  }
+
+  return response.text()
 }
 
-async function requestResult(baseUrl, apiKey, taskId, format) {
-  const response = await fetch(`${baseUrl}/api/cli/transcriptions/${encodeURIComponent(taskId)}/result?format=${encodeURIComponent(format)}`, {
+async function requestTranscriptPreview(baseUrl, apiKey, taskId, options = {}) {
+  const response = await fetch(`${baseUrl}/api/cli/transcriptions/${encodeURIComponent(taskId)}/preview`, {
     method: 'GET',
+    signal: options.signal,
     headers: {
       Authorization: `Bearer ${apiKey}`,
     },
   })
 
-  if (!response.ok) {
-    throw new Error(await readErrorMessage(response))
+  if (response.status === 204) {
+    return {
+      available: true,
+      text: null,
+    }
   }
 
-  if (format === 'json' || format === 'verbose_json') {
-    return JSON.stringify(await response.json(), null, 2)
+  if (response.status === 404 || response.status === 405 || response.status === 501) {
+    return {
+      available: false,
+      text: null,
+    }
   }
 
-  return response.text()
+  if (!response.ok) {
+    throw new HttpCliError(await readErrorMessage(response), response.status)
+  }
+
+  return {
+    available: true,
+    text: await response.text(),
+  }
 }
 
 function sleep(ms) {
@@ -566,6 +1007,77 @@ function buildTranscribingProgressMessage(input = {}) {
   return `转写中 ${percent}%${chunksPart}`
 }
 
+function normalizeUploadPercent(uploadedBytes, totalBytes) {
+  if (!Number.isFinite(uploadedBytes) || !Number.isFinite(totalBytes) || totalBytes <= 0) {
+    return 0
+  }
+
+  return Math.max(0, Math.min(100, Math.round((uploadedBytes / totalBytes) * 100)))
+}
+
+function buildUploadProgressMessage(input = {}) {
+  const uploadedBytes = Number(input.uploadedBytes) || 0
+  const totalBytes = Number(input.totalBytes) || 0
+  const percent = normalizeUploadPercent(uploadedBytes, totalBytes)
+
+  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)
+  const durationPart = Number.isFinite(duration) && duration > 0
+    ? `，时长约 ${Math.ceil(duration / 60)} 分钟`
+    : ''
+
+  return `媒体检查通过：${title}${durationPart}`
+}
+
+function getUploadTaskFromCheckResult(checkResult) {
+  if (checkResult?.task?.taskId) {
+    return checkResult.task
+  }
+
+  if (checkResult?.upload?.task?.taskId) {
+    return checkResult.upload.task
+  }
+
+  return null
+}
+
+function getUploadReadySummary(checkResult, fileInput, uploadId) {
+  const task = getUploadTaskFromCheckResult(checkResult)
+  const upload = checkResult?.upload || {}
+  const durationMs = Number(upload.ffprobeDurationMs || upload.clientDurationMs)
+  const durationSeconds = Number(checkResult?.durationSeconds)
+  const normalizedDurationSeconds = Number.isFinite(durationSeconds) && durationSeconds > 0
+    ? durationSeconds
+    : Number.isFinite(durationMs) && durationMs > 0
+      ? Math.round(durationMs / 1000)
+      : null
+  const requiredMinutes = Number(checkResult?.requiredMinutes)
+
+  return {
+    uploadId,
+    filename: upload.filename || fileInput.filename,
+    title: task?.title || checkResult?.title || upload.filename || fileInput.filename,
+    durationSeconds: normalizedDurationSeconds,
+    requiredMinutes: Number.isFinite(requiredMinutes) && requiredMinutes > 0
+      ? requiredMinutes
+      : normalizedDurationSeconds
+        ? Math.max(1, Math.floor(normalizedDurationSeconds / 60))
+        : null,
+  }
+}
+
 function createProgressReporter(progressFormat) {
   const resolvedMode = resolveProgressFormat(progressFormat)
   const outputState = createOutputState()
@@ -596,48 +1108,38 @@ function createProgressReporter(progressFormat) {
   return {
     mode: resolvedMode,
     reportTaskCreated(task) {
+      const safeTask = sanitizeTaskForReporting(task)
+
       if (resolvedMode === 'jsonl') {
         writeJsonEvent({
           event: 'task.created',
-          message: `任务已创建：${task.taskId}`,
-          taskId: task.taskId,
-          title: task.title,
-          sourceType: task.sourceType,
-          status: task.status,
-          statusLabel: formatStatus(task.status),
-          consumedMinutes: task.consumedMinutes,
-          remainingMinutes: task.remainingMinutes,
-          mode: task.mode,
-          resultReady: task.resultReady,
+          message: `任务已创建：${safeTask.taskId}`,
+          taskId: safeTask.taskId,
+          title: safeTask.title,
+          sourceType: safeTask.sourceType,
+          sourceUrl: safeTask.sourceUrl || null,
+          status: safeTask.status,
+          statusLabel: formatStatus(safeTask.status),
+          consumedMinutes: safeTask.consumedMinutes,
+          remainingMinutes: safeTask.remainingMinutes,
+          mode: safeTask.mode,
+          resultReady: safeTask.resultReady,
         })
         return
       }
 
-      writeTextMessage(`任务已创建：${task.taskId}`)
-      writeTextMessage(`标题：${task.title}`)
-      writeTextMessage(`来源：${task.sourceType}`)
-      writeTextMessage(`状态：${formatStatus(task.status)}`)
-      writeTextMessage(`本次消耗分钟：${task.consumedMinutes}`)
-      writeTextMessage(`剩余分钟：${task.remainingMinutes}`)
-    },
-    reportStatusChanged(status) {
-      emitTextOrJson(buildStatusChangedMessage(status), {
-        event: 'task.status_changed',
-        status,
-        statusLabel: formatStatus(status),
-      })
+      writeTextMessage(`任务已创建：${safeTask.taskId}`)
+      writeTextMessage(`标题：${safeTask.title}`)
+      writeTextMessage(`来源：${safeTask.sourceType}`)
+      writeTextMessage(`状态：${formatStatus(safeTask.status)}`)
+      writeTextMessage(`本次消耗分钟：${safeTask.consumedMinutes}`)
+      writeTextMessage(`剩余分钟：${safeTask.remainingMinutes}`)
     },
-    reportProgress(input = {}) {
-      const finishedChunks = Number(input.finishedChunks)
-      const totalChunks = Number(input.totalChunks)
-      const normalizedProgress = normalizeProgressValue(
-        Number(input.progress),
-        finishedChunks,
-        totalChunks,
-      )
-      const message = buildTranscribingProgressMessage(input)
-
-      lastTerminalSignature = ''
+    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)
@@ -646,10 +1148,148 @@ function createProgressReporter(progressFormat) {
 
       if (resolvedMode === 'jsonl') {
         writeJsonEvent({
-          event: 'task.progress',
+          event: 'upload.hashing',
           message,
-          status: 'transcribing',
-          progress: normalizedProgress,
+          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)}）`
+
+      emitTextOrJson(message, {
+        event: 'upload.started',
+        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,
+      })
+    },
+    reportUploadProgress(input = {}) {
+      const uploadedBytes = Number(input.uploadedBytes) || 0
+      const totalBytes = Number(input.totalBytes) || 0
+      const percent = normalizeUploadPercent(uploadedBytes, totalBytes)
+      const message = buildUploadProgressMessage({ uploadedBytes, totalBytes })
+
+      if (resolvedMode === 'interactive') {
+        writeInline(outputState, message)
+        return
+      }
+
+      if (resolvedMode === 'jsonl') {
+        writeJsonEvent({
+          event: 'upload.progress',
+          message,
+          uploadedBytes,
+          totalBytes,
+          percent,
+          completedParts: Number(input.completedParts) || null,
+          totalParts: Number(input.totalParts) || null,
+        })
+        return
+      }
+
+      if (message === lastTextProgressMessage) {
+        return
+      }
+
+      lastTextProgressMessage = message
+      writeTextMessage(message)
+    },
+    reportUploadCompleted(input = {}) {
+      finishInline(outputState)
+      lastTextProgressMessage = ''
+      const message = '上传完成，正在合并并准备媒体检查'
+
+      emitTextOrJson(message, {
+        event: 'upload.completed',
+        uploadId: input.uploadId || null,
+        filename: input.filename || null,
+        totalBytes: Number(input.totalBytes) || 0,
+      })
+    },
+    reportUploadChecking(input = {}) {
+      const message = '正在检查媒体信息'
+
+      emitTextOrJson(message, {
+        event: 'upload.checking',
+        uploadId: input.uploadId || null,
+      })
+    },
+    reportUploadReady(input = {}) {
+      const message = getUploadReadyMessage(input)
+
+      emitTextOrJson(message, {
+        event: 'upload.ready',
+        uploadId: input.uploadId || null,
+        sourceType: 'upload',
+        sourceUrl: UPLOAD_REDACTED_SOURCE_LABEL,
+        title: input.title || input.filename || null,
+        durationSeconds: Number(input.durationSeconds) || null,
+        requiredMinutes: Number(input.requiredMinutes) || null,
+      })
+    },
+    reportUploadAborted(input = {}) {
+      finishInline(outputState)
+      const message = '上传已取消'
+
+      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,
+      })
+    },
+    reportStatusChanged(status) {
+      emitTextOrJson(buildStatusChangedMessage(status), {
+        event: 'task.status_changed',
+        status,
+        statusLabel: formatStatus(status),
+      })
+    },
+    reportProgress(input = {}) {
+      const finishedChunks = Number(input.finishedChunks)
+      const totalChunks = Number(input.totalChunks)
+      const normalizedProgress = normalizeProgressValue(
+        Number(input.progress),
+        finishedChunks,
+        totalChunks,
+      )
+      const message = buildTranscribingProgressMessage(input)
+
+      lastTerminalSignature = ''
+
+      if (resolvedMode === 'interactive') {
+        writeInline(outputState, message)
+        return
+      }
+
+      if (resolvedMode === 'jsonl') {
+        writeJsonEvent({
+          event: 'task.progress',
+          message,
+          status: 'transcribing',
+          progress: normalizedProgress,
           percent: normalizedProgress === null ? null : Math.round(normalizedProgress * 100),
           finishedChunks: Number.isFinite(finishedChunks) ? Math.max(0, finishedChunks) : null,
           totalChunks: Number.isFinite(totalChunks) && totalChunks > 0 ? totalChunks : null,
@@ -684,6 +1324,50 @@ function createProgressReporter(progressFormat) {
         error: errorMessage || null,
       })
     },
+    reportTranscriptDelta(input) {
+      if (resolvedMode !== 'jsonl') {
+        return
+      }
+
+      writeJsonEvent({
+        event: 'task.transcript.delta',
+        taskId: input.taskId,
+        sequence: input.sequence,
+        source: input.source,
+        startOffset: input.startOffset,
+        endOffset: input.endOffset,
+        text: input.text,
+      })
+    },
+    reportTranscriptReset(input) {
+      if (resolvedMode !== 'jsonl') {
+        return
+      }
+
+      writeJsonEvent({
+        event: 'task.transcript.reset',
+        taskId: input.taskId,
+        sequence: input.sequence,
+        source: input.source,
+        reason: input.reason,
+        text: input.text,
+        characterCount: input.characterCount,
+      })
+    },
+    reportTranscriptCompleted(input) {
+      if (resolvedMode !== 'jsonl') {
+        return
+      }
+
+      writeJsonEvent({
+        event: 'task.transcript.completed',
+        taskId: input.taskId,
+        sequence: input.sequence,
+        source: input.source,
+        characterCount: input.characterCount,
+        sha256: input.sha256,
+      })
+    },
     reportResultWritten(outputPath, format) {
       emitTextOrJson(`结果已写入：${outputPath}`, {
         event: 'task.result_written',
@@ -728,21 +1412,130 @@ function parseSseBlock(block) {
   }
 }
 
-async function consumeTaskEvents(baseUrl, apiKey, taskId, initialTask, reporter) {
+function countCodePoints(value) {
+  return Array.from(String(value || '')).length
+}
+
+function longestCommonCodePointPrefix(first, second) {
+  const firstCodePoints = Array.from(String(first || ''))
+  const secondCodePoints = Array.from(String(second || ''))
+  const length = Math.min(firstCodePoints.length, secondCodePoints.length)
+  let index = 0
+
+  while (index < length && firstCodePoints[index] === secondCodePoints[index]) {
+    index += 1
+  }
+
+  return firstCodePoints.slice(0, index).join('')
+}
+
+function createTranscriptStreamState(taskId, reporter) {
+  let stableText = ''
+  let stableCharacterCount = 0
+  let previousPreviewSnapshot = null
+  let sequence = 0
+
+  function nextSequence() {
+    sequence += 1
+    return sequence
+  }
+
+  function applyStableSnapshot(snapshot, source, resetReason = 'non_prefix_snapshot') {
+    if (typeof snapshot !== 'string' || snapshot === stableText) {
+      return
+    }
+
+    if (snapshot.startsWith(stableText)) {
+      const appendedText = snapshot.slice(stableText.length)
+      const startOffset = stableCharacterCount
+
+      stableText = snapshot
+      stableCharacterCount += countCodePoints(appendedText)
+
+      if (appendedText) {
+        reporter.reportTranscriptDelta({
+          taskId,
+          sequence: nextSequence(),
+          source,
+          startOffset,
+          endOffset: stableCharacterCount,
+          text: appendedText,
+        })
+      }
+      return
+    }
+
+    stableText = snapshot
+    stableCharacterCount = countCodePoints(stableText)
+    reporter.reportTranscriptReset({
+      taskId,
+      sequence: nextSequence(),
+      source,
+      reason: resetReason,
+      text: stableText,
+      characterCount: stableCharacterCount,
+    })
+  }
+
+  return {
+    applySseSnapshot(snapshot) {
+      if (typeof snapshot === 'string') {
+        previousPreviewSnapshot = null
+      }
+      applyStableSnapshot(snapshot, 'sse')
+    },
+    applyPreviewSnapshot(snapshot) {
+      if (typeof snapshot !== 'string') {
+        return
+      }
+
+      if (previousPreviewSnapshot === null) {
+        previousPreviewSnapshot = snapshot
+        return
+      }
+
+      const stablePreviewText = longestCommonCodePointPrefix(previousPreviewSnapshot, snapshot)
+      previousPreviewSnapshot = snapshot
+
+      if (
+        stablePreviewText.length < stableText.length
+        && stableText.startsWith(stablePreviewText)
+      ) {
+        return
+      }
+
+      applyStableSnapshot(stablePreviewText, 'preview')
+    },
+    complete(authoritativeText) {
+      applyStableSnapshot(authoritativeText, 'result', 'final_result_mismatch')
+      reporter.reportTranscriptCompleted({
+        taskId,
+        sequence: nextSequence(),
+        source: 'result',
+        characterCount: stableCharacterCount,
+        sha256: createHash('sha256').update(authoritativeText, 'utf8').digest('hex'),
+      })
+    },
+  }
+}
+
+async function consumeTaskEvents(baseUrl, apiKey, taskId, initialTask, reporter, signal, transcriptState = null) {
   const response = await fetch(`${baseUrl}/api/cli/transcriptions/${encodeURIComponent(taskId)}/events`, {
     method: 'GET',
+    signal,
     headers: {
       Authorization: `Bearer ${apiKey}`,
     },
   })
 
   if (!response.ok || !response.body) {
-    throw new Error(await readErrorMessage(response))
+    throw new HttpCliError(await readErrorMessage(response), response.status)
   }
 
   const reader = response.body.getReader()
   const decoder = new TextDecoder()
   let buffer = ''
+  let streamDone = false
   let task = {
     ...initialTask,
   }
@@ -786,68 +1579,117 @@ async function consumeTaskEvents(baseUrl, apiKey, taskId, initialTask, reporter)
     reporter.reportProgress(data)
   }
 
-  while (true) {
-    const { value, done } = await reader.read()
+  function processSseBlock(block) {
+    const normalizedBlock = block.replace(/\r\n?/g, '\n').trim()
 
-    if (done) {
-      break
+    if (!normalizedBlock) {
+      return false
     }
 
-    buffer += decoder.decode(value, { stream: true })
-    buffer = buffer.replace(/\r\n/g, '\n')
-
-    let separatorIndex = buffer.indexOf('\n\n')
+    const { event, data } = parseSseBlock(normalizedBlock)
 
-    while (separatorIndex >= 0) {
-      const block = buffer.slice(0, separatorIndex).trim()
-      buffer = buffer.slice(separatorIndex + 2)
-      separatorIndex = buffer.indexOf('\n\n')
+    if (event === 'job.snapshot') {
+      transcriptState?.applySseSnapshot(data?.committedText)
 
-      if (!block) {
-        continue
+      if (data?.status === 'transcribing') {
+        renderProgress(data)
+      } else if (TERMINAL_STATUSES.has(data?.status)) {
+        applyTerminal(data.status, data?.error || data?.message || null)
+      } else {
+        applyStatus(data?.status)
       }
+      return TERMINAL_STATUSES.has(data?.status)
+    }
 
-      const { event, data } = parseSseBlock(block)
+    if (event === 'job.status_changed') {
+      applyStatus(data?.status)
+      return TERMINAL_STATUSES.has(data?.status)
+    }
 
-      if (event === 'job.snapshot') {
-        if (data?.status === 'transcribing') {
-          renderProgress(data)
-        } else if (TERMINAL_STATUSES.has(data?.status)) {
-          applyTerminal(data.status, data?.error || data?.message || null)
-        } else {
-          applyStatus(data?.status)
-        }
-        continue
-      }
+    if (event === 'job.progress') {
+      renderProgress(data)
+      return false
+    }
 
-      if (event === 'job.status_changed') {
-        applyStatus(data?.status)
-        continue
-      }
+    if (event === 'transcript.delta') {
+      transcriptState?.applySseSnapshot(data?.committedText)
+      return false
+    }
 
-      if (event === 'job.progress') {
-        renderProgress(data)
-        continue
+    if (event === 'job.completed') {
+      applyTerminal('completed', null)
+      return true
+    }
+
+    if (event === 'job.failed') {
+      applyTerminal('failed', data?.error || data?.message || '转写失败')
+      return true
+    }
+
+    if (event === 'job.cancelled') {
+      applyTerminal('cancelled', '转写任务已取消')
+      return true
+    }
+
+    return false
+  }
+
+  function drainSseBuffer(flush = false) {
+    while (true) {
+      const separator = /\r\n\r\n|\n\n|\r\r/.exec(buffer)
+
+      if (!separator || typeof separator.index !== 'number') {
+        break
       }
 
-      if (event === 'job.completed') {
-        applyTerminal('completed', null)
-        return task
+      const block = buffer.slice(0, separator.index)
+      buffer = buffer.slice(separator.index + separator[0].length)
+
+      if (processSseBlock(block)) {
+        return true
       }
+    }
 
-      if (event === 'job.failed') {
-        applyTerminal('failed', data?.error || data?.message || '转写失败')
-        return task
+    if (flush && buffer.trim()) {
+      const tail = buffer
+      buffer = ''
+      return processSseBlock(tail)
+    }
+
+    return false
+  }
+
+  try {
+    while (true) {
+      const { value, done } = await reader.read()
+
+      if (done) {
+        streamDone = true
+        buffer += decoder.decode()
+        if (drainSseBuffer(true)) {
+          return task
+        }
+        break
       }
 
-      if (event === 'job.cancelled') {
-        applyTerminal('cancelled', '转写任务已取消')
+      buffer += decoder.decode(value, { stream: true })
+
+      if (drainSseBuffer()) {
         return task
       }
     }
+  } finally {
+    if (!streamDone) {
+      await reader.cancel().catch(() => {})
+    }
+
+    try {
+      reader.releaseLock()
+    } catch {
+      // The stream may already have released its lock while aborting.
+    }
   }
 
-  reporter.close()
   return task
 }
 
@@ -858,6 +1700,423 @@ async function writeOutput(outputPath, content) {
   return resolvedPath
 }
 
+function assertNotAborted(signal) {
+  if (signal?.aborted) {
+    throw createAbortError()
+  }
+}
+
+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)
+
+  const fileHandle = await open(filePath, 'r')
+  const buffer = Buffer.allocUnsafe(length)
+  let offset = 0
+
+  try {
+    while (offset < length) {
+      assertNotAborted(signal)
+
+      const { bytesRead } = await fileHandle.read(
+        buffer,
+        offset,
+        length - offset,
+        start + offset,
+      )
+
+      if (bytesRead <= 0) {
+        break
+      }
+
+      offset += bytesRead
+    }
+  } finally {
+    await fileHandle.close().catch(() => {})
+  }
+
+  if (offset !== length) {
+    throw new Error('读取本地文件分片时大小不一致，请重新选择文件')
+  }
+
+  return buffer
+}
+
+async function abortUploadOnServer(baseUrl, apiKey, uploadId) {
+  if (!uploadId) {
+    return null
+  }
+
+  return await requestJson(baseUrl, apiKey, '/api/cli/uploads/abort', {
+    method: 'POST',
+    retry: true,
+    body: {
+      uploadId,
+    },
+  })
+}
+
+function createRunContext(baseUrl, apiKey, reporter) {
+  const abortController = new AbortController()
+  const state = {
+    uploadId: '',
+    taskId: '',
+    taskCreated: false,
+    uploadAbortAllowed: true,
+    interrupting: false,
+    interruptPromise: null,
+  }
+
+  const handleSigint = () => {
+    if (state.interrupting) {
+      return
+    }
+
+    state.interrupting = true
+    abortController.abort()
+
+    state.interruptPromise = (async () => {
+      if (state.taskCreated && state.taskId) {
+        reporter.reportNotice(`已停止本地等待，服务端转写仍在继续：${state.taskId}`)
+        reporter.close()
+        return
+      }
+
+      if (!state.uploadAbortAllowed && state.uploadId) {
+        const taskPart = state.taskId ? `，taskId=${state.taskId}` : ''
+        reporter.reportNotice(`已停止本地等待，服务端正在处理上传：uploadId=${state.uploadId}${taskPart}`)
+        reporter.close()
+        return
+      }
+
+      if (state.uploadId) {
+        try {
+          await abortUploadOnServer(baseUrl, apiKey, state.uploadId)
+          reporter.reportUploadAborted({ uploadId: state.uploadId })
+        } catch (error) {
+          reporter.reportUploadFailed(
+            `已中断本地上传，但服务端上传清理失败：${error instanceof Error ? error.message : String(error)}`,
+            { uploadId: state.uploadId },
+          )
+        }
+      }
+
+      reporter.close()
+    })()
+
+    void state.interruptPromise.finally(() => {
+      process.exit(130)
+    })
+  }
+
+  process.once('SIGINT', handleSigint)
+
+  return {
+    signal: abortController.signal,
+    state,
+    dispose() {
+      process.off('SIGINT', handleSigint)
+    },
+  }
+}
+
+async function signUploadPart(baseUrl, apiKey, uploadId, partNumber, signal) {
+  const response = await requestJson(baseUrl, apiKey, '/api/cli/uploads/parts', {
+    method: 'POST',
+    signal,
+    retry: true,
+    body: {
+      uploadId,
+      partNumbers: [partNumber],
+    },
+  })
+  const signedPart = Array.isArray(response?.parts)
+    ? response.parts.find(part => Number(part?.partNumber) === partNumber)
+    : null
+
+  if (!signedPart?.url) {
+    throw new Error(`第 ${partNumber} 个分片上传地址生成失败`)
+  }
+
+  return signedPart
+}
+
+async function putSignedPartBuffer(signedUrl, buffer, signal) {
+  const response = await fetch(signedUrl, {
+    method: 'PUT',
+    signal,
+    body: buffer,
+  })
+
+  if (!response.ok) {
+    const message = response.status === 403
+      ? '分片上传签名已过期'
+      : `分片上传失败：${response.status} ${response.statusText}`
+    throw new HttpCliError(message, response.status)
+  }
+
+  const etag = normalizeEtag(response.headers.get('ETag') || response.headers.get('etag'))
+
+  if (!etag) {
+    throw new Error('OSS 未返回分片 ETag，请检查服务端签名与跨域响应头配置')
+  }
+
+  return etag
+}
+
+async function uploadSinglePart(input) {
+  const {
+    baseUrl,
+    apiKey,
+    uploadId,
+    fileInput,
+    partNumber,
+    partSize,
+    totalParts,
+    signal,
+  } = input
+  const start = (partNumber - 1) * partSize
+  const length = Math.min(fileInput.sizeBytes - start, partSize)
+  const buffer = await readFileChunk(fileInput.path, start, length, signal)
+  let signedPart = await signUploadPart(baseUrl, apiKey, uploadId, partNumber, signal)
+
+  for (let attempt = 1; attempt <= 4; attempt += 1) {
+    assertNotAborted(signal)
+
+    try {
+      const etag = await putSignedPartBuffer(signedPart.url, buffer, signal)
+
+      return {
+        partNumber,
+        etag,
+        bytes: length,
+      }
+    } catch (error) {
+      if (signal?.aborted || isAbortError(error)) {
+        throw error
+      }
+
+      if (error instanceof HttpCliError && error.status === 403 && attempt < 4) {
+        signedPart = await signUploadPart(baseUrl, apiKey, uploadId, partNumber, signal)
+        await sleep(getRetryDelayMs(attempt))
+        continue
+      }
+
+      if (isRetryableRequestError(error) && attempt < 4) {
+        await sleep(getRetryDelayMs(attempt))
+        continue
+      }
+
+      const message = error instanceof Error ? error.message : String(error)
+      throw new Error(`第 ${partNumber}/${totalParts} 个分片上传失败：${message}`)
+    }
+  }
+
+  throw new Error(`第 ${partNumber}/${totalParts} 个分片上传失败`)
+}
+
+async function uploadFileParts(input) {
+  const totalParts = Math.ceil(input.fileInput.sizeBytes / input.partSize)
+  const workerCount = Math.min(MAX_UPLOAD_CONCURRENCY, totalParts)
+  const completedParts = []
+  let nextPartNumber = 1
+  let completedPartCount = 0
+  let uploadedBytes = 0
+  let firstError = null
+
+  input.reporter.reportUploadProgress({
+    uploadedBytes,
+    totalBytes: input.fileInput.sizeBytes,
+    completedParts: completedPartCount,
+    totalParts,
+  })
+
+  async function uploadNextPart() {
+    while (nextPartNumber <= totalParts) {
+      assertNotAborted(input.signal)
+
+      if (firstError) {
+        throw firstError
+      }
+
+      const partNumber = nextPartNumber
+      nextPartNumber += 1
+
+      try {
+        const completed = await uploadSinglePart({
+          ...input,
+          partNumber,
+          totalParts,
+        })
+
+        completedParts.push({
+          partNumber: completed.partNumber,
+          etag: completed.etag,
+        })
+        uploadedBytes += completed.bytes
+        completedPartCount += 1
+        input.reporter.reportUploadProgress({
+          uploadedBytes,
+          totalBytes: input.fileInput.sizeBytes,
+          completedParts: completedPartCount,
+          totalParts,
+        })
+      } catch (error) {
+        firstError = error
+        throw error
+      }
+    }
+  }
+
+  await Promise.all(Array.from({ length: workerCount }, () => uploadNextPart()))
+
+  return completedParts.sort((a, b) => a.partNumber - b.partNumber)
+}
+
+async function uploadLocalFile(fileInput, args, baseUrl, apiKey, reporter, runContext) {
+  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,
+      retry: true,
+      body: {
+        filename: fileInput.filename,
+        mimeType: fileInput.mimeType,
+        sizeBytes: fileInput.sizeBytes,
+        fileHash,
+      },
+    })
+
+    uploadId = String(startResponse?.uploadId || '')
+    runContext.state.uploadId = uploadId
+
+    const partSize = Number(startResponse?.partSize)
+
+    if (!uploadId || !Number.isFinite(partSize) || partSize <= 0) {
+      throw new Error('上传初始化失败，请稍后重试')
+    }
+
+    const totalParts = Math.ceil(fileInput.sizeBytes / partSize)
+
+    reporter.reportUploadStarted({
+      uploadId,
+      filename: fileInput.filename,
+      mimeType: fileInput.mimeType,
+      totalBytes: fileInput.sizeBytes,
+      partSize,
+      totalParts,
+    })
+
+    const parts = await uploadFileParts({
+      baseUrl,
+      apiKey,
+      uploadId,
+      fileInput,
+      partSize,
+      signal: runContext.signal,
+      reporter,
+    })
+
+    await requestJson(baseUrl, apiKey, '/api/cli/uploads/complete', {
+      method: 'POST',
+      signal: runContext.signal,
+      retry: true,
+      body: {
+        uploadId,
+        parts,
+      },
+    })
+
+    reporter.reportUploadCompleted({
+      uploadId,
+      filename: fileInput.filename,
+      totalBytes: fileInput.sizeBytes,
+    })
+    runContext.state.uploadAbortAllowed = false
+    reporter.reportUploadChecking({ uploadId })
+
+    const checkResult = await requestJson(baseUrl, apiKey, '/api/cli/uploads/check', {
+      method: 'POST',
+      signal: runContext.signal,
+      retry: true,
+      body: {
+        uploadId,
+        language: args.language || DEFAULT_LANGUAGE,
+      },
+    })
+    const checkedTask = getUploadTaskFromCheckResult(checkResult)
+
+    if (checkedTask) {
+      runContext.state.taskId = checkedTask.taskId || ''
+      runContext.state.taskCreated = true
+    }
+
+    reporter.reportUploadReady(getUploadReadySummary(checkResult, fileInput, uploadId))
+
+    return {
+      ...checkResult,
+      uploadId,
+    }
+  } catch (error) {
+    if (runContext.state.interrupting || isAbortError(error)) {
+      throw new ReportedCliError('已中断', 130)
+    }
+
+    const message = error instanceof Error ? error.message : String(error)
+    reporter.reportUploadFailed(`上传失败：${message}`, { uploadId })
+
+    if (uploadId && runContext.state.uploadAbortAllowed) {
+      await abortUploadOnServer(baseUrl, apiKey, uploadId).catch(() => null)
+    }
+
+    throw error
+  }
+}
+
 async function handleAuthLogin(args) {
   if (!args.apiKey) {
     printAuthUsage()
@@ -930,87 +2189,311 @@ async function handleAuthCommand(argv) {
   fail(`不支持的 auth 子命令：${args.action}`)
 }
 
-async function handleTranscription(argv) {
-  const args = parseTranscriptionArgs(argv)
-  const reporter = createProgressReporter(args.progressFormat)
-  try {
-    const storedConfig = await readStoredConfig()
-    const resolvedApiKey = resolveApiKey(args.apiKey, storedConfig)
+function buildUrlTaskCreatePayload(args, input) {
+  const createPayload = {
+    url: input.url,
+    language: args.language || DEFAULT_LANGUAGE,
+  }
 
-    if (!resolvedApiKey) {
-      printUsage()
-      fail('缺少 API key。请传 --api-key、设置 DEYO_API_KEY，或先执行 deyo auth login')
+  if (args.source) {
+    createPayload.source = args.source
+  }
+
+  return createPayload
+}
+
+async function createCliTask(baseUrl, apiKey, createPayload, reporter, runContext) {
+  const created = await requestJson(baseUrl, apiKey, '/api/cli/transcriptions', {
+    method: 'POST',
+    signal: runContext.signal,
+    body: createPayload,
+  })
+
+  runContext.state.taskId = created.taskId || ''
+  runContext.state.taskCreated = true
+  reporter.reportTaskCreated(created)
+
+  return created
+}
+
+function reportTaskStatusTransition(reporter, previousStatus, task) {
+  if (task.status === previousStatus) {
+    return task.status
+  }
+
+  if (TERMINAL_STATUSES.has(task.status)) {
+    reporter.reportTerminal(task.status, task.error || null)
+  } else {
+    reporter.reportStatusChanged(task.status)
+  }
+
+  return task.status
+}
+
+async function waitForTranscriptionTask(baseUrl, apiKey, initialTask, reporter, runContext, transcriptState) {
+  let currentTask = initialTask
+  let lastStatus = currentTask.status
+  let lastSseError = null
+
+  for (let attempt = 0; attempt <= SSE_RECONNECT_DELAYS_MS.length; attempt += 1) {
+    if (attempt > 0) {
+      const delayMs = SSE_RECONNECT_DELAYS_MS[attempt - 1]
+      reporter.reportNotice(`事件流中断，${delayMs / 1000} 秒后重连${lastSseError ? `：${lastSseError}` : ''}`)
+      await sleep(delayMs)
     }
 
-    if (!args.url) {
-      printUsage()
-      fail('缺少内容链接')
+    if (runContext.state.interrupting) {
+      throw new ReportedCliError('已中断', 130)
     }
 
-    const { baseUrl } = resolveBaseUrl(args.baseUrl, storedConfig)
-    const format = inferFormat(args.output, args.format)
-    const createPayload = {
-      url: args.url,
-      language: args.language || DEFAULT_LANGUAGE,
+    try {
+      currentTask = await consumeTaskEvents(
+        baseUrl,
+        apiKey,
+        currentTask.taskId,
+        currentTask,
+        reporter,
+        runContext.signal,
+        transcriptState,
+      )
+      lastStatus = currentTask.status
+
+      if (TERMINAL_STATUSES.has(currentTask.status)) {
+        return currentTask
+      }
+
+      lastSseError = '服务端在任务结束前关闭了事件流'
+    } catch (error) {
+      if (runContext.state.interrupting || isAbortError(error)) {
+        throw new ReportedCliError('已中断', 130)
+      }
+
+      if (!isRetryableRequestError(error)) {
+        throw error
+      }
+
+      lastSseError = error instanceof Error ? error.message : String(error)
     }
+  }
+
+  reporter.reportNotice(`事件流连续中断，回退到状态轮询${transcriptState ? '和正文预览' : ''}`)
+
+  let previewAvailable = !!transcriptState
+  let lastSseRecoveryAt = Date.now()
 
-    if (args.source) {
-      createPayload.source = args.source
+  while (!TERMINAL_STATUSES.has(currentTask.status)) {
+    await sleep(POLL_INTERVAL_MS)
+
+    if (runContext.state.interrupting) {
+      throw new ReportedCliError('已中断', 130)
     }
 
-    const created = await requestJson(baseUrl, resolvedApiKey.apiKey, '/api/cli/transcriptions', {
-      method: 'POST',
-      body: createPayload,
-    })
-    reporter.reportTaskCreated(created)
+    try {
+      currentTask = await requestJson(
+        baseUrl,
+        apiKey,
+        `/api/cli/transcriptions/${encodeURIComponent(currentTask.taskId)}`,
+        {
+          signal: runContext.signal,
+          retry: true,
+        },
+      )
+      lastStatus = reportTaskStatusTransition(reporter, lastStatus, currentTask)
+    } catch (error) {
+      if (runContext.state.interrupting || isAbortError(error)) {
+        throw new ReportedCliError('已中断', 130)
+      }
 
-    let task = created
-    let lastStatus = created.status
+      if (!isRetryableRequestError(error)) {
+        throw error
+      }
 
-    if (task.mode === 'transcription' && !TERMINAL_STATUSES.has(task.status)) {
+      reporter.reportNotice(`状态轮询失败，将继续重试：${error instanceof Error ? error.message : String(error)}`)
+    }
+
+    if (TERMINAL_STATUSES.has(currentTask.status)) {
+      break
+    }
+
+    if (previewAvailable && transcriptState) {
       try {
-        task = await consumeTaskEvents(baseUrl, resolvedApiKey.apiKey, task.taskId, task, reporter)
-        lastStatus = task.status
+        const preview = await requestTranscriptPreview(baseUrl, apiKey, currentTask.taskId, {
+          signal: runContext.signal,
+        })
+
+        if (!preview.available) {
+          previewAvailable = false
+          reporter.reportNotice('当前服务端不支持 CLI 正文预览，将继续等待最终结果')
+        } else if (preview.text !== null) {
+          transcriptState.applyPreviewSnapshot(preview.text)
+        }
       } catch (error) {
-        reporter.reportNotice(`事件流中断，回退到轮询状态：${error instanceof Error ? error.message : String(error)}`)
+        if (runContext.state.interrupting || isAbortError(error)) {
+          throw new ReportedCliError('已中断', 130)
+        }
+
+        if (!isRetryableRequestError(error)) {
+          throw error
+        }
+
+        reporter.reportNotice(`正文预览读取失败，将继续重试：${error instanceof Error ? error.message : String(error)}`)
       }
     }
 
-    while (!TERMINAL_STATUSES.has(task.status)) {
-      await sleep(POLL_INTERVAL_MS)
-      task = await requestJson(baseUrl, resolvedApiKey.apiKey, `/api/cli/transcriptions/${encodeURIComponent(task.taskId)}`)
+    if (Date.now() - lastSseRecoveryAt < SSE_RECOVERY_INTERVAL_MS) {
+      continue
+    }
 
-      if (task.status !== lastStatus) {
-        if (TERMINAL_STATUSES.has(task.status)) {
-          reporter.reportTerminal(task.status, task.error || null)
-        } else {
-          reporter.reportStatusChanged(task.status)
-        }
-        lastStatus = task.status
+    lastSseRecoveryAt = Date.now()
+
+    try {
+      reporter.reportNotice('正在尝试恢复事件流')
+      currentTask = await consumeTaskEvents(
+        baseUrl,
+        apiKey,
+        currentTask.taskId,
+        currentTask,
+        reporter,
+        runContext.signal,
+        transcriptState,
+      )
+      lastStatus = currentTask.status
+
+      if (TERMINAL_STATUSES.has(currentTask.status)) {
+        return currentTask
+      }
+
+      reporter.reportNotice('事件流再次提前结束，将继续轮询')
+    } catch (error) {
+      if (runContext.state.interrupting || isAbortError(error)) {
+        throw new ReportedCliError('已中断', 130)
+      }
+
+      if (!isRetryableRequestError(error)) {
+        throw error
       }
+
+      reporter.reportNotice(`事件流恢复失败，将继续轮询：${error instanceof Error ? error.message : String(error)}`)
     }
+  }
 
-    reporter.reportTerminal(task.status, task.error || null)
+  return currentTask
+}
+
+async function waitForTaskAndOutput(baseUrl, apiKey, task, args, format, reporter, runContext) {
+  let currentTask = task
+  const transcriptState = args.streamTranscript
+    ? createTranscriptStreamState(currentTask.taskId, reporter)
+    : null
+
+  if (currentTask.mode === 'transcription' && !TERMINAL_STATUSES.has(currentTask.status)) {
+    currentTask = await waitForTranscriptionTask(
+      baseUrl,
+      apiKey,
+      currentTask,
+      reporter,
+      runContext,
+      transcriptState,
+    )
+  }
+
+  reporter.reportTerminal(currentTask.status, currentTask.error || null)
+
+  if (currentTask.status !== 'completed') {
+    throw new ReportedCliError(currentTask.error || `任务未成功完成：${formatStatus(currentTask.status)}`)
+  }
+
+  const result = await requestResult(baseUrl, apiKey, currentTask.taskId, format, {
+    signal: runContext.signal,
+  })
+
+  if (args.output) {
+    const outputPath = await writeOutput(args.output, result)
+    transcriptState?.complete(result)
+    reporter.reportResultWritten(outputPath, format)
+    return
+  }
+
+  transcriptState?.complete(result)
+  reporter.close()
+  process.stdout.write(result)
+
+  if (!result.endsWith('\n')) {
+    process.stdout.write('\n')
+  }
+}
+
+async function handleTranscription(argv) {
+  const args = parseTranscriptionArgs(argv)
+  const format = inferFormat(args.output, args.format)
+  validateTranscriptStreaming(args, format)
+  const reporter = createProgressReporter(args.progressFormat)
+  let runContext = null
+
+  try {
+    const storedConfig = await readStoredConfig()
+    const resolvedApiKey = resolveApiKey(args.apiKey, storedConfig)
 
-    if (task.status !== 'completed') {
-      throw new ReportedCliError(task.error || `任务未成功完成：${formatStatus(task.status)}`)
+    if (!resolvedApiKey) {
+      printUsage()
+      fail('缺少 API key。请传 --api-key、设置 DEYO_API_KEY，或先执行 deyo auth login')
     }
 
-    const result = await requestResult(baseUrl, resolvedApiKey.apiKey, task.taskId, format)
+    if (!args.url && !args.file) {
+      printUsage()
+      fail('缺少内容链接或本地文件')
+    }
 
-    if (args.output) {
-      const outputPath = await writeOutput(args.output, result)
-      reporter.reportResultWritten(outputPath, format)
-      return
+    const { baseUrl } = resolveBaseUrl(args.baseUrl, storedConfig)
+    const input = await resolveTranscriptionInput(args)
+
+    if (!input) {
+      printUsage()
+      fail('缺少内容链接或本地文件')
     }
 
-    reporter.close()
-    process.stdout.write(result)
+    runContext = createRunContext(baseUrl, resolvedApiKey.apiKey, reporter)
+    let createPayload
+    let created
 
-    if (!result.endsWith('\n')) {
-      process.stdout.write('\n')
+    if (input.kind === 'file') {
+      if (args.source && args.source !== 'upload') {
+        fail('本地文件转写不支持 --source；上传来源会固定为 upload')
+      }
+
+      const checkResult = await uploadLocalFile(
+        input,
+        args,
+        baseUrl,
+        resolvedApiKey.apiKey,
+        reporter,
+        runContext,
+      )
+      const checkedTask = getUploadTaskFromCheckResult(checkResult)
+
+      if (checkedTask) {
+        runContext.state.taskId = checkedTask.taskId || ''
+        runContext.state.taskCreated = true
+        reporter.reportTaskCreated(checkedTask)
+        created = checkedTask
+      } else {
+        throw new Error('媒体检查通过但服务端没有返回上传转写任务')
+      }
+    } else {
+      createPayload = buildUrlTaskCreatePayload(args, input)
     }
+
+    if (!created) {
+      created = await createCliTask(baseUrl, resolvedApiKey.apiKey, createPayload, reporter, runContext)
+    }
+
+    await waitForTaskAndOutput(baseUrl, resolvedApiKey.apiKey, created, args, format, reporter, runContext)
   } catch (error) {
+    if (runContext?.state.interrupting || isAbortError(error)) {
+      await runContext?.state.interruptPromise?.catch(() => {})
+      throw new ReportedCliError('已中断', 130)
+    }
+
     if (error instanceof ReportedCliError) {
       throw error
     }
@@ -1021,6 +2504,8 @@ async function handleTranscription(argv) {
     }
 
     throw error
+  } finally {
+    runContext?.dispose()
   }
 }
 
@@ -1043,12 +2528,21 @@ async function main() {
     return
   }
 
+  if (primaryCommand === 'skill') {
+    await handleSkillCommand(argv, CLI_VERSION)
+    return
+  }
+
   await handleTranscription(argv)
 }
 
 main().catch((error) => {
+  if (error?.name === 'SkillCommandReportedError') {
+    process.exit(error.exitCode || 1)
+  }
+
   if (error instanceof ReportedCliError) {
-    process.exit(1)
+    process.exit(error.exitCode || 1)
   }
 
   const message = error instanceof Error ? error.message : String(error)