@casatwy/deyo 0.1.7 → 0.1.9

package/deyo.mjs

@@ -1,8 +1,9 @@
 #!/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'
 
@@ -14,8 +15,52 @@ const POLL_INTERVAL_MS = 1500
 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,13 +77,16 @@ function fail(message, exitCode = 1) {
 
 function printUsage() {
   process.stderr.write(`用法:
-  deyo [选项] <url>
+  deyo [选项] <url|file>
+  deyo [选项] --file <file>
   deyo auth <login|logout|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
@@ -55,6 +103,10 @@ API key 读取优先级:
   1. --api-key
   2. 环境变量 DEYO_API_KEY
   3. 本地配置文件（先执行 deyo auth login）
+
+本地文件说明:
+  v1 只支持单文件上传；不支持目录、glob、stdin、批量和断点续传。
+  可以用 deyo -- ./audio.mp3 明确把 -- 后的单个参数当作路径或链接。
 `)
 }
 
@@ -76,11 +128,14 @@ function parseTranscriptionArgs(argv) {
     apiKey: '',
     output: '',
     source: '',
+    file: '',
+    mimeType: '',
     language: '',
     format: '',
     progressFormat: 'auto',
     baseUrl: '',
     url: '',
+    positional: [],
   }
 
   for (let index = 0; index < argv.length; index += 1) {
@@ -91,6 +146,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 +175,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
@@ -137,13 +215,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 +299,295 @@ function inferFormat(outputPath, explicitFormat) {
   return 'text'
 }
 
+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,26 +780,33 @@ async function readErrorMessage(response) {
 }
 
 async function requestJson(baseUrl, apiKey, path, options = {}) {
-  const response = await fetch(`${baseUrl}${path}`, {
-    method: options.method || 'GET',
-    headers: {
-      Authorization: `Bearer ${apiKey}`,
-      'Content-Type': 'application/json',
-      ...(options.headers || {}),
-    },
-    body: typeof options.body === 'undefined' ? undefined : JSON.stringify(options.body),
-  })
+  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 Error(await readErrorMessage(response))
-  }
+    if (!response.ok) {
+      throw new HttpCliError(await readErrorMessage(response), response.status)
+    }
 
-  return response.json()
+    return response.json()
+  }, {
+    signal: options.signal,
+    maxAttempts: options.retry ? 4 : 1,
+  })
 }
 
-async function requestResult(baseUrl, apiKey, taskId, format) {
+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}`,
     },
@@ -438,7 +817,7 @@ async function requestResult(baseUrl, apiKey, taskId, format) {
   }
 
   if (format === 'json' || format === 'verbose_json') {
-    return JSON.stringify(await response.json(), null, 2)
+    return JSON.stringify(sanitizeResultPayload(await response.json()), null, 2)
   }
 
   return response.text()
@@ -566,6 +945,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,29 +1046,157 @@ 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}`)
+      writeTextMessage(`任务已创建：${safeTask.taskId}`)
+      writeTextMessage(`标题：${safeTask.title}`)
+      writeTextMessage(`来源：${safeTask.sourceType}`)
+      writeTextMessage(`状态：${formatStatus(safeTask.status)}`)
+      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)}）`
+
+      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), {
@@ -728,9 +1306,10 @@ function parseSseBlock(block) {
   }
 }
 
-async function consumeTaskEvents(baseUrl, apiKey, taskId, initialTask, reporter) {
+async function consumeTaskEvents(baseUrl, apiKey, taskId, initialTask, reporter, signal) {
   const response = await fetch(`${baseUrl}/api/cli/transcriptions/${encodeURIComponent(taskId)}/events`, {
     method: 'GET',
+    signal,
     headers: {
       Authorization: `Bearer ${apiKey}`,
     },
@@ -858,6 +1437,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,9 +1926,113 @@ async function handleAuthCommand(argv) {
   fail(`不支持的 auth 子命令：${args.action}`)
 }
 
+function buildUrlTaskCreatePayload(args, input) {
+  const createPayload = {
+    url: input.url,
+    language: args.language || DEFAULT_LANGUAGE,
+  }
+
+  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
+}
+
+async function waitForTaskAndOutput(baseUrl, apiKey, task, args, format, reporter, runContext) {
+  let currentTask = task
+  let lastStatus = currentTask.status
+
+  if (currentTask.mode === 'transcription' && !TERMINAL_STATUSES.has(currentTask.status)) {
+    try {
+      currentTask = await consumeTaskEvents(
+        baseUrl,
+        apiKey,
+        currentTask.taskId,
+        currentTask,
+        reporter,
+        runContext.signal,
+      )
+      lastStatus = currentTask.status
+    } catch (error) {
+      if (runContext.state.interrupting || isAbortError(error)) {
+        throw new ReportedCliError('已中断', 130)
+      }
+
+      reporter.reportNotice(`事件流中断，回退到轮询状态：${error instanceof Error ? error.message : String(error)}`)
+    }
+  }
+
+  while (!TERMINAL_STATUSES.has(currentTask.status)) {
+    await sleep(POLL_INTERVAL_MS)
+
+    if (runContext.state.interrupting) {
+      throw new ReportedCliError('已中断', 130)
+    }
+
+    currentTask = await requestJson(
+      baseUrl,
+      apiKey,
+      `/api/cli/transcriptions/${encodeURIComponent(currentTask.taskId)}`,
+      {
+        signal: runContext.signal,
+        retry: true,
+      },
+    )
+
+    if (currentTask.status !== lastStatus) {
+      if (TERMINAL_STATUSES.has(currentTask.status)) {
+        reporter.reportTerminal(currentTask.status, currentTask.error || null)
+      } else {
+        reporter.reportStatusChanged(currentTask.status)
+      }
+      lastStatus = currentTask.status
+    }
+  }
+
+  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)
+    reporter.reportResultWritten(outputPath, format)
+    return
+  }
+
+  reporter.close()
+  process.stdout.write(result)
+
+  if (!result.endsWith('\n')) {
+    process.stdout.write('\n')
+  }
+}
+
 async function handleTranscription(argv) {
   const args = parseTranscriptionArgs(argv)
   const reporter = createProgressReporter(args.progressFormat)
+  let runContext = null
+
   try {
     const storedConfig = await readStoredConfig()
     const resolvedApiKey = resolveApiKey(args.apiKey, storedConfig)
@@ -942,75 +2042,62 @@ async function handleTranscription(argv) {
       fail('缺少 API key。请传 --api-key、设置 DEYO_API_KEY，或先执行 deyo auth login')
     }
 
-    if (!args.url) {
+    if (!args.url && !args.file) {
       printUsage()
-      fail('缺少内容链接')
+      fail('缺少内容链接或本地文件')
     }
 
     const { baseUrl } = resolveBaseUrl(args.baseUrl, storedConfig)
-    const format = inferFormat(args.output, args.format)
-    const createPayload = {
-      url: args.url,
-      language: args.language || DEFAULT_LANGUAGE,
-    }
+    const input = await resolveTranscriptionInput(args)
 
-    if (args.source) {
-      createPayload.source = args.source
+    if (!input) {
+      printUsage()
+      fail('缺少内容链接或本地文件')
     }
 
-    const created = await requestJson(baseUrl, resolvedApiKey.apiKey, '/api/cli/transcriptions', {
-      method: 'POST',
-      body: createPayload,
-    })
-    reporter.reportTaskCreated(created)
-
-    let task = created
-    let lastStatus = created.status
+    const format = inferFormat(args.output, args.format)
+    runContext = createRunContext(baseUrl, resolvedApiKey.apiKey, reporter)
+    let createPayload
+    let created
 
-    if (task.mode === 'transcription' && !TERMINAL_STATUSES.has(task.status)) {
-      try {
-        task = await consumeTaskEvents(baseUrl, resolvedApiKey.apiKey, task.taskId, task, reporter)
-        lastStatus = task.status
-      } catch (error) {
-        reporter.reportNotice(`事件流中断，回退到轮询状态：${error instanceof Error ? error.message : String(error)}`)
+    if (input.kind === 'file') {
+      if (args.source && args.source !== 'upload') {
+        fail('本地文件转写不支持 --source；上传来源会固定为 upload')
       }
-    }
 
-    while (!TERMINAL_STATUSES.has(task.status)) {
-      await sleep(POLL_INTERVAL_MS)
-      task = await requestJson(baseUrl, resolvedApiKey.apiKey, `/api/cli/transcriptions/${encodeURIComponent(task.taskId)}`)
-
-      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
+      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)
     }
 
-    reporter.reportTerminal(task.status, task.error || null)
-
-    if (task.status !== 'completed') {
-      throw new ReportedCliError(task.error || `任务未成功完成：${formatStatus(task.status)}`)
+    if (!created) {
+      created = await createCliTask(baseUrl, resolvedApiKey.apiKey, createPayload, reporter, runContext)
     }
 
-    const result = await requestResult(baseUrl, resolvedApiKey.apiKey, task.taskId, format)
-
-    if (args.output) {
-      const outputPath = await writeOutput(args.output, result)
-      reporter.reportResultWritten(outputPath, format)
-      return
+    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)
     }
 
-    reporter.close()
-    process.stdout.write(result)
-
-    if (!result.endsWith('\n')) {
-      process.stdout.write('\n')
-    }
-  } catch (error) {
     if (error instanceof ReportedCliError) {
       throw error
     }
@@ -1021,6 +2108,8 @@ async function handleTranscription(argv) {
     }
 
     throw error
+  } finally {
+    runContext?.dispose()
   }
 }
 
@@ -1048,7 +2137,7 @@ async function main() {
 
 main().catch((error) => {
   if (error instanceof ReportedCliError) {
-    process.exit(1)
+    process.exit(error.exitCode || 1)
   }
 
   const message = error instanceof Error ? error.message : String(error)