@uzooai/anime-ai-cli 0.0.0-stage → 0.5.0

package/src/workflows.js

@@ -0,0 +1,214 @@
+import fs from 'node:fs/promises'
+import path from 'node:path'
+import crypto from 'node:crypto'
+import { setTimeout as sleep } from 'node:timers/promises'
+import { atomic, json, root, safeName } from './store.js'
+import { request, requestFile, cancellation } from './api.js'
+import { agreementError, readProtocol } from './agreement.js'
+import { isDeepStrictEqual } from 'node:util'
+import { downloadName } from './download-name.js'
+
+export const segment = value => encodeURIComponent(String(value))
+// Mirrors parameters used by the ordinary web nodes and their request builders.
+// Model catalog capabilities and provider/admin settings are not request controls.
+const generationFields = new Set([
+  'doc_id', 'node_id', 'segment_type', 'model_name', 'prompt',
+  'reference_image_urls', 'reference_video_urls', 'reference_audio_urls',
+  'reference_asset_ids', 'reference_canvas_task_ids', 'duration',
+  'aspect_ratio', 'resolution', 'quality', 'asset_type', 'enable_asset_review',
+  'production_task_id', 'generation_mode', 'protocol_agreed', 'extra'
+])
+const frontendExtraFields = {
+  text: ['context_texts', 'max_tokens', 'temperature'],
+  image: ['aspect_ratio', 'resolution', 'quality', 'generation_mode', 'image_count'],
+  video: ['aspect_ratio', 'resolution', 'generation_mode', 'draft_preview']
+}
+export function generationExtra(kind, extra = {}, { fromNode = false } = {}) {
+  if (!extra || Array.isArray(extra) || typeof extra !== 'object') throw new Error('extra 必须是 JSON 对象')
+  if (Object.hasOwn(extra, 'generate_audio') || Object.hasOwn(extra, 'generateAudio'))
+    throw new Error('前端视频节点没有声音开关，CLI 不支持 generate_audio；未预估或提交生成')
+  if (kind === 'image' && Object.hasOwn(extra, 'image_count') && extra.image_count !== 1)
+    throw new Error('当前前端普通图片流程仅接入单张 image_count=1；未预估或提交多张生成')
+  const allowed = frontendExtraFields[kind] || []
+  const unknown = Object.keys(extra).filter(key => !allowed.includes(key))
+  if (!fromNode && unknown.length) throw new Error(`当前 CLI 未接入这些前端生成参数：extra.${unknown.join(', extra.')}；请先核对实际前端流程`)
+  return Object.fromEntries(Object.entries(extra).filter(([key]) => allowed.includes(key)))
+}
+function validateGenerationShape(body) {
+  if (!body || Array.isArray(body) || typeof body !== 'object') throw new Error('请求必须是 JSON 对象')
+  for (const k of ['doc_id', 'node_id', 'model_name']) if (typeof body[k] !== 'string' || !body[k].trim()) throw new Error(`请求缺少 ${k}`)
+  if (!['text', 'image', 'video'].includes(body.segment_type)) throw new Error('segment_type 必须是 text/image/video')
+  if (typeof body.prompt !== 'string') throw new Error('prompt 必须是字符串')
+}
+export function validateGeneration(body) {
+  validateGenerationShape(body)
+  if (Object.hasOwn(body, 'generate_audio') || Object.hasOwn(body, 'generateAudio'))
+    throw new Error('前端视频节点没有声音开关，CLI 不支持 generate_audio；未预估或提交生成')
+  const unknown = Object.keys(body).filter(key => !generationFields.has(key))
+  if (unknown.length) throw new Error(`当前 CLI 未接入这些前端生成参数：${unknown.join(', ')}；请先核对实际前端流程`)
+  generationExtra(body.segment_type, body.extra)
+}
+export function journalPath(profile, operation) { return path.join(root(), 'operations', safeName(profile), `${safeName(operation)}.json`) }
+export async function generationProtocol(client) {
+  const protocol=await readProtocol(client)
+  return {protocol,status:protocol.required&&!protocol.agreed?'awaiting_agreement':protocol.agreed?'agreed':'not_required',api_code:protocol.required&&!protocol.agreed?4401:0}
+}
+async function agreementContext(client,body) {
+  const doc=await client.raw(`/canvas/docs/${segment(body.doc_id)}`)
+  if(doc.id!==body.doc_id || !['owner','editor'].includes(doc.role) || !Array.isArray(doc.nodes) || !Array.isArray(doc.edges)) throw new Error('协议确认前后无法核验目标画布，未继续生成')
+  const target=doc.nodes.find(n=>n.id===body.node_id)
+  if(!target)throw new Error('协议确认前后目标节点不存在，未继续生成')
+  const sources=[...new Set(doc.edges.filter(e=>e.target===body.node_id).map(e=>e.source))].sort().map(id=>({id,data:doc.nodes.find(n=>n.id===id)?.data}))
+  return {team_uid:doc.team_uid || null,project_id:doc.canvas_project_id || null,target:{id:target.id,type:target.type,data:target.data},sources}
+}
+export async function submit(client, profile, body, operation, confirmed, expectedCost, {onAgreementRequired}={}) {
+  validateGenerationShape(body)
+  const file = journalPath(profile, operation)
+  let record = await json(file, null)
+  const identity = await client.raw('/auth/me')
+  const owner = String(identity.uid ?? identity.id ?? '')
+  if (!owner) throw new Error('账号响应缺少 uid/id，无法绑定任务')
+  const hash = crypto.createHash('sha256').update(JSON.stringify(body)).digest('hex')
+  if (record && (record.hash !== hash || record.baseUrl !== client.baseUrl || record.owner !== owner)) throw new Error('operation 已绑定其他请求、服务或账号，请勿复用')
+  if (record?.taskId) return client.raw(`/canvas/generations/${segment(record.taskId)}`)
+  // Existing remote tasks remain queryable with their original saved request.
+  // Never rewrite an old operation to pass a newer parameter contract.
+  validateGeneration(body)
+  let estimate = await client.raw('/canvas/generations/estimate', { method: 'POST', body })
+  if (estimate.will_intercept) throw new Error('预估接口拦截了请求，请调整输入')
+  if (!Number.isFinite(estimate.estimated_credit_cost) || estimate.estimated_credit_cost < 0)
+    throw new Error('预估费用无效，不能提交；请核验费用接口')
+  const approvedCost=expectedCost ?? record?.approvedCost
+  if (confirmed && approvedCost === undefined)
+    throw new Error('首次生成提交或原记录缺少确认金额时必须传 --expected-cost，先通过交互卡片确认实际钱包、请求参数和预估费用')
+  if (confirmed && (!Number.isFinite(approvedCost) || approvedCost < 0 || estimate.estimated_credit_cost !== approvedCost)) throw new Error('生成费用与当次确认不一致；未提交，请重新展示费用并确认')
+  let protocol
+  if(body.segment_type==='video' && /seedance/i.test(body.model_name)) {
+    protocol=(await generationProtocol(client)).protocol
+    if(confirmed && protocol.required && !protocol.agreed) {
+      if(!record)record={operation,baseUrl:client.baseUrl,owner,body,hash,key:crypto.randomUUID(),createdAt:new Date().toISOString()}
+      record.state='blocked_agreement';record.approvedCost=approvedCost;record.protocolVersion=protocol.version;record.lastFailure={status:200,apiCode:4401,code:'AGREEMENT_REQUIRED'};await atomic(file,record)
+      if(!onAgreementRequired)throw agreementError('AGREEMENT_REQUIRED','当前账号需签署《统一协议》中的《Seedance2.0模型使用承诺书》（code 4401）；生成尚未提交，不是模型执行失败',protocol)
+      const context=await agreementContext(client,body)
+      try{await onAgreementRequired({operation,body,estimate,protocol,owner})}catch(error){record.agreementWaitCode=error.code || 'AGREEMENT_PAGE_UNAVAILABLE';await atomic(file,record);throw error}
+      const currentIdentity=await client.raw('/auth/me')
+      const currentOwner=String(currentIdentity.uid ?? currentIdentity.id ?? '')
+      if(currentOwner!==owner)throw agreementError('AGREEMENT_ACCOUNT_CHANGED','协议确认后账号已变化，未继续原生成',protocol)
+      const state=await readProtocol(client)
+      if(state.version!==protocol.version || state.required&&!state.agreed)throw agreementError('AGREEMENT_CHANGED','协议状态或版本已变化，未继续原生成，请先完成当前版本签署',state)
+      record.state='needs_confirmation';record.agreement={status:'agreed',version:state.version};delete record.lastFailure;await atomic(file,record)
+      if(!isDeepStrictEqual(await agreementContext(client,body),context))throw new Error('协议确认期间画布归属、节点参数或上游已变化，未继续生成；请重新核对请求和费用')
+      estimate=await client.raw('/canvas/generations/estimate',{method:'POST',body})
+      if(estimate.will_intercept || estimate.estimated_credit_cost!==approvedCost)throw new Error('协议确认后费用或校验结果已变化，未提交；请重新展示预估并取得当次确认')
+      protocol=state
+    }
+  }
+  if (!confirmed) return { submitted: false, operation, estimate, ...(protocol?{protocol}:{}), next: '确认参数和费用后使用同一 operation 加 --yes 提交' }
+  if (!record) {
+    record = { operation, baseUrl: client.baseUrl, owner, body, hash, key: crypto.randomUUID(), createdAt: new Date().toISOString(), approvedCost, state: 'prepared' }
+    await atomic(file, record)
+  }
+  if (!record.syncBaseline && ['prepared','needs_confirmation','blocked_agreement'].includes(record.state)) {
+    const doc=await client.raw(`/canvas/docs/${segment(body.doc_id)}`)
+    const node=doc.nodes?.find(n=>n.id===body.node_id)
+    if(doc.id!==body.doc_id || !node || node.type!==body.segment_type)throw new Error('提交前无法核验原节点，未提交生成')
+    record.syncBaseline={doc_id:doc.id,team_uid:doc.team_uid||null,node}
+    await atomic(file,record)
+  }
+  record.approvedCost = approvedCost
+  record.state = 'submitting'; await atomic(file, record)
+  try {
+    const task = await client.raw('/canvas/generations', { method: 'POST', body: record.body, headers: { 'Idempotency-Key': record.key } }, { retry: false })
+    if (!task.task_id && !task.id) throw new Error('提交响应缺少任务 ID')
+    record.taskId = task.task_id ?? task.id; record.state = 'submitted'
+    await atomic(file, record)
+    return { operation, estimate, task }
+  } catch (error) {
+    record.state = error.apiCode===4401 ? 'blocked_agreement' : 'unknown'
+    record.lastFailure = { ...(Number.isInteger(error.status) ? { status:error.status } : {}), ...(Number.isInteger(error.apiCode) ? { apiCode:error.apiCode } : {}), code:error.apiCode===4401?'AGREEMENT_REQUIRED':typeof error.code==='string'?error.code:'REQUEST_FAILED' }
+    await atomic(file, record)
+    if(error.apiCode===4401)throw agreementError('AGREEMENT_REQUIRED','《统一协议》《Seedance2.0模型使用承诺书》需要签署或版本已更新（code 4401）；本次生成提交被前置检查阻止，不是生成任务执行失败；保留原 operation',error.protocol || protocol)
+    const detail=record.lastFailure.apiCode ? `（接口返回 code ${record.lastFailure.apiCode}，HTTP ${record.lastFailure.status}）` : record.lastFailure.status ? `（HTTP ${record.lastFailure.status}）` : ''
+    const failure = new Error(`提交结果未确认${detail}；使用 generation recover ${operation} 以原幂等键恢复，勿创建新 operation`,{cause:error})
+    failure.code = 'SUBMISSION_UNKNOWN'; throw failure
+  }
+}
+export async function recover(client, profile, operation, confirmed, expectedCost, options) {
+  const record = await json(journalPath(profile, operation), null)
+  if (!record) throw new Error('未找到 operation')
+  return submit(client, profile, record.body, operation, confirmed, expectedCost, options)
+}
+export async function wait(client, id, interval, timeout) {
+  const deadline = Date.now() + timeout
+  while (Date.now() < deadline) {
+    let data
+    try { data = await client.raw(`/canvas/generations/${segment(id)}`, { signal: AbortSignal.timeout(Math.max(1, Math.min(client.timeout, deadline - Date.now()))) }) }
+    catch (error) {
+      if (error.name === 'TimeoutError' && Date.now() >= deadline) break
+      throw error
+    }
+    const status = String(data.status || data.state || '').toLowerCase()
+    if (status === 'completed') return data
+    if (['failed', 'cancelled', 'canceled'].includes(status)) { const e = new Error(`任务 ${id} 已${status}；使用 generation get/logs 查看详情`); e.code = 'TASK_FAILED'; throw e }
+    await sleep(Math.min(interval, Math.max(1, deadline - Date.now())), undefined, { signal: cancellation.signal })
+  }
+  const e = new Error(`任务 ${id} 等待超时；可用同一 ID 继续查询`); e.code = 'WAIT_TIMEOUT'; throw e
+}
+export async function upload(client, args) {
+  const { file, doc, node, type, assetType, name, mime } = args
+  if (!['image', 'video', 'audio'].includes(type)) throw new Error('--type 必须是 image/video/audio')
+  if (!node && (type !== 'image' || !['character', 'scene', 'prop'].includes(assetType) || !name)) throw new Error('资产上传需要 --type image --asset-type character|scene|prop --name；音视频请提供 --node')
+  const handle = await fs.open(file, 'r')
+  try {
+    const stat = await handle.stat()
+    if (!stat.isFile() || !stat.size) throw new Error('上传文件必须为非空普通文件')
+    const endpoint = `/canvas/docs/${segment(doc)}/${node ? `nodes/${segment(node)}` : 'assets'}`
+    const body = { filename: path.basename(file), file_size: stat.size, expected_type: type, mime_type: mime, ...(!node ? { asset_type: assetType, name } : {}) }
+    const session = await client.raw(`${endpoint}/upload-session`, { method: 'POST', body })
+    const parts = await uploadParts(client, handle, stat, session, mime)
+    return client.raw(`${endpoint}/upload-complete`, { method: 'POST', body: { upload_id: session.upload_id, object_key: session.object_key, expected_parts: parts.length, parts } }, { retry: false })
+  } finally { await handle.close() }
+}
+export async function uploadParts(client, handle, stat, session, mime) {
+    const count = Math.ceil(stat.size / session.part_size)
+    if (!Number.isSafeInteger(session.part_size) || session.part_size <= 0 || session.part_size > 100 * 1024 * 1024 || count !== session.total_parts || session.presigned_parts?.length !== count) throw new Error('上传会话分片参数无效')
+    const parts = []
+    for (let i = 0; i < count; i++) {
+      const part = session.presigned_parts[i]
+      if (part.part_number !== i + 1) throw new Error('上传会话分片不连续')
+      const length = Math.min(session.part_size, stat.size - i * session.part_size)
+      const buffer = Buffer.alloc(length)
+      let offset = 0
+      while (offset < length) { const { bytesRead } = await handle.read(buffer, offset, length - offset, i * session.part_size + offset); if (!bytesRead) throw new Error('文件在上传时被截断'); offset += bytesRead }
+      const response = await request(part.url, { method: 'PUT', headers: { 'Content-Type': mime }, body: buffer }, client.timeout)
+      const etag = response.headers.get('etag')
+      await response.body?.cancel()
+      if (!response.ok || !etag) throw new Error(`分片 ${i + 1} 上传失败或缺少 ETag；未执行 complete`)
+      parts.push({ part_number: i + 1, etag: etag.replaceAll('"', '') })
+    }
+    const now = await handle.stat()
+    if (now.size !== stat.size || now.mtimeMs !== stat.mtimeMs) throw new Error('上传时文件发生变化，未执行 complete')
+    return parts
+}
+export async function download(client, id, output, expectedHash) {
+  const data = await client.raw(`/canvas/generations/${segment(id)}/download`)
+  if (typeof data?.url !== 'string' || !data.url.trim()) throw new Error('原任务下载接口未返回有效链接')
+  const url = new URL(data.url, client.baseUrl)
+  const response = await requestFile(url, client.timeout)
+  if (!response.ok || /(?:json|text\/html)/i.test(response.headers.get('content-type') || '')) { await response.body?.cancel(); throw new Error('下载返回错误状态或非媒体错误页面') }
+  const filename = downloadName(response.headers, data.filename) || `generation-${segment(id)}`
+  const target = path.resolve(output || filename)
+  const tmp = `${target}.${crypto.randomUUID()}.part`
+  let handle
+  try {
+    handle = await fs.open(tmp, 'wx', 0o600)
+    const hash = crypto.createHash('sha256'); let bytes = 0
+    for await (const chunk of response.body) { await handle.writeFile(chunk); hash.update(chunk); bytes += chunk.length }
+    const digest = hash.digest('hex')
+    const length = response.headers.get('content-length')
+    if (!bytes || (length && !response.headers.get('content-encoding') && bytes !== Number(length)) || (expectedHash && digest !== expectedHash.toLowerCase())) throw new Error('下载文件完整性校验失败')
+    await handle.close(); handle = null
+    await fs.link(tmp, target)
+    return { output: target, bytes, sha256: digest, filename }
+  } finally { await handle?.close(); await fs.rm(tmp, { force: true }) }
+}