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

package/src/image-output.js

@@ -0,0 +1,385 @@
+import fs from 'node:fs/promises'
+import path from 'node:path'
+import crypto from 'node:crypto'
+import { atomic } from './store.js'
+import { scopedCanvas } from './materials.js'
+import { segment, uploadParts } from './workflows.js'
+import { bindUpload } from './resource.js'
+import { hashFile } from './media.js'
+const text = (value) => String(value ?? '').trim()
+const digest = (value) => crypto.createHash('sha256').update(JSON.stringify(value)).digest('hex')
+const fail = (code, message, error) =>
+  Object.assign(new Error(message), {
+    code,
+    ...(error
+      ? {
+          cause: error,
+          diagnostic: {
+            ...(error.status ? { http_status: error.status } : {}),
+            ...(error.apiCode ? { api_code: error.apiCode } : {}),
+            ...(error.requestId ? { request_id: error.requestId } : {})
+          }
+        }
+      : {})
+  })
+
+// Shared persistence/upload contract for locally processed image outputs.
+// Callers own source validation, geometry, decoding and operation journals.
+export function imageOutputWorkflow({
+  recordPath,
+  readContext,
+  nodeTitle,
+  nodePosition,
+  edgeRole,
+  edgePrefix,
+  codePrefix,
+  mime,
+  summarize,
+  nodeType = () => 'image_upload'
+}) {
+  async function persistNodes(client, profile, record, current) {
+    const doc = current.doc
+    const existing = record.items.map((item) => doc.nodes.find((node) => node.id === item.nodeId))
+    if (existing.every(Boolean)) {
+      for (let i = 0; i < existing.length; i++) {
+        const node = existing[i],
+          item = record.items[i]
+        if (
+          node.type !== nodeType(record, item) ||
+          (node.data?.extra?.node_kind &&
+            node.data.extra.node_kind !==
+              (nodeType(record, item) === 'image' ? 'generation' : 'asset')) ||
+          (node.data?.file_name && node.data.file_name !== item.fileName) ||
+          !doc.edges.some(
+            (e) =>
+              e.source === record.input.node_id && e.target === node.id && e.data?.role === edgeRole
+          )
+        )
+          throw new Error('图片处理结果节点或来源连线已变化，停止保存')
+      }
+      record.nodesSaved = true
+      await atomic(recordPath(profile, record.operation), record)
+      return
+    }
+    if (record.nodesSaved || record.saveAttempted || existing.some(Boolean))
+      throw fail(
+        codePrefix + '_SYNC_PENDING',
+        '图片处理节点/连线缺失或保存结果不明；先核对用户删除/画布内容，不自动重建'
+      )
+    if (
+      !Number.isSafeInteger(doc.version) ||
+      !doc.viewport ||
+      !doc.meta ||
+      !Array.isArray(doc.edges)
+    )
+      throw new Error('图片处理画布快照不完整')
+    const nodes = structuredClone(doc.nodes),
+      edges = structuredClone(doc.edges)
+    for (const item of record.items) {
+      const node = {
+        id: item.nodeId,
+        type: nodeType(record, item),
+        position: nodePosition(nodes, current.node),
+        data: {
+          title: nodeTitle(item),
+          mediaType: 'image',
+          url: '',
+          file_name: item.fileName,
+          file_size: item.local.bytes,
+          width: item.local.width,
+          height: item.local.height,
+          uploading: true,
+          ...(nodeType(record, item) === 'image'
+            ? {
+                status: 'processing',
+                runtime: { status: 'processing', operation: 'upload', progress: 0, error: '' }
+              }
+            : {}),
+          extra: {
+            node_kind: nodeType(record, item) === 'image_upload' ? 'asset' : 'generation',
+            aspect_ratio: item.local.width + ':' + item.local.height
+          }
+        }
+      }
+      nodes.push(node)
+      edges.push({
+        id: edgePrefix + item.nodeId,
+        source: record.input.node_id,
+        target: item.nodeId,
+        sourceHandle: '',
+        targetHandle: '',
+        type: 'default',
+        data: { role: edgeRole }
+      })
+    }
+    record.saveAttempted = true
+    await atomic(recordPath(profile, record.operation), record)
+    try {
+      const saved = await client.raw(
+        '/canvas/docs/' + segment(doc.id),
+        {
+          method: 'PUT',
+          body: {
+            version: doc.version,
+            name: doc.name,
+            viewport: doc.viewport,
+            nodes,
+            edges,
+            meta: doc.meta
+          }
+        },
+        { retry: false }
+      )
+      if (
+        saved.id !== doc.id ||
+        saved.version <= doc.version ||
+        record.items.some(
+          (item) =>
+            !saved.nodes?.some((n) => n.id === item.nodeId) ||
+            !saved.edges?.some((e) => e.id === edgePrefix + item.nodeId)
+        )
+      )
+        throw new Error('节点保存响应不完整')
+      record.nodesSaved = true
+      await atomic(recordPath(profile, record.operation), record)
+    } catch (error) {
+      record.state = 'sync_pending'
+      if (error.status === 409 || error.apiCode === 3002) {
+        record.saveAttempted = false
+      }
+      await atomic(recordPath(profile, record.operation), record)
+      throw fail(
+        codePrefix + '_SYNC_PENDING',
+        '图片处理已在本地导出，节点保存未确认；查询原画布后恢复，不重复处理',
+        error
+      )
+    }
+  }
+  function validateUpload(response, record, item) {
+    if (
+      response?.source_doc_id !== record.input.doc_id ||
+      response.source_node_id !== item.nodeId ||
+      response.segment_type !== 'image' ||
+      !response.result?.file_ref ||
+      !response.result.url ||
+      !/^image\//.test(response.result.mime_type || '') ||
+      response.result.width !== item.local.width ||
+      response.result.height !== item.local.height ||
+      !/^[1-9]\d*$/.test(text(response.task_id))
+    )
+      throw fail(
+        codePrefix + '_UPLOAD_UNKNOWN',
+        '上传响应缺少真实图片/任务关联；查询原节点和任务，不重复上传'
+      )
+    return response
+  }
+  async function reconcile(client, record, item) {
+    const list = await client.raw(
+      '/canvas/generations?' +
+        new URLSearchParams({
+          doc_id: record.input.doc_id,
+          node_id: item.nodeId,
+          status: 'completed',
+          limit: '100'
+        })
+    )
+    const current = await readContext(client, record.input)
+    if (digest(current.binding) !== digest(record.binding))
+      throw new Error('恢复上传前源素材已变化，停止')
+    const node = current.doc.nodes.find((n) => n.id === item.nodeId)
+    const uploadTask = String(node?.data?.task_id || '')
+    const uploadRef = node?.data?.file_ref
+    const candidates = list.items?.filter(
+      (task) =>
+        task.doc_id === record.input.doc_id &&
+        task.node_id === item.nodeId &&
+        task.segment_type === 'image' &&
+        (task.model_name === 'local-upload' ||
+          (uploadTask &&
+            String(task.task_id ?? task.id) === uploadTask &&
+            uploadRef &&
+            task.result?.file_ref === uploadRef &&
+            task.credit_cost === 0 &&
+            task.billing_status === 'charged')) &&
+        task.status === 'completed' &&
+        task.result?.filename === item.fileName &&
+        task.result?.file_ref &&
+        task.result?.url
+    )
+    if (candidates?.length !== 1)
+      throw fail(
+        codePrefix + '_UPLOAD_UNKNOWN',
+        '原上传 complete 结果未知；原节点未查到唯一真实任务，不重新 complete 或重传'
+      )
+    const task = candidates[0]
+    item.response = validateUpload(
+      {
+        source_doc_id: task.doc_id,
+        source_node_id: task.node_id,
+        segment_type: 'image',
+        task_id: task.task_id ?? task.id,
+        result: task.result
+      },
+      record,
+      item
+    )
+    item.state = 'uploaded'
+  }
+  async function runUploads(client, profile, record) {
+    record.state = 'uploading'
+    await atomic(recordPath(profile, record.operation), record)
+    for (const item of record.items) {
+      const current = await readContext(client, record.input)
+      if (digest(record.binding) !== digest(current.binding))
+        throw new Error('上传前源素材已变化，停止')
+      const node = current.doc.nodes.find((node) => node.id === item.nodeId)
+      if (
+        !node ||
+        node.type !== nodeType(record, item) ||
+        !current.doc.edges.some(
+          (e) =>
+            e.source === record.input.node_id &&
+            e.target === item.nodeId &&
+            e.data?.role === edgeRole
+        )
+      )
+        throw new Error('图片处理节点或连线已被删除，不自动重建')
+      const currentRef =
+        node.data?.file_ref || node.data?.extra?.file_ref || node.data?.result?.file_ref
+      if (
+        currentRef &&
+        currentRef !== item.response?.result?.file_ref &&
+        !['completing', 'unknown'].includes(item.state)
+      )
+        throw new Error('图片处理节点已换成其他素材；保留用户编辑')
+      if (['completing', 'unknown'].includes(item.state)) {
+        record.state = 'upload_unknown'
+        await atomic(recordPath(profile, record.operation), record)
+        await reconcile(client, record, item)
+        record.state = 'uploading'
+        await atomic(recordPath(profile, record.operation), record)
+      }
+      if (item.state === 'session_unknown') {
+        record.state = 'upload_unknown'
+        await atomic(recordPath(profile, record.operation), record)
+        throw fail(
+          codePrefix + '_UPLOAD_UNKNOWN',
+          '上传会话创建结果未知，停止；不自动创建第二个会话'
+        )
+      }
+      if (!item.response) {
+        const image = path.join(record.directory, item.fileName)
+        const local = await hashFile(image)
+        if (local.sha256 !== item.local.sha256 || local.bytes !== item.local.bytes)
+          throw new Error('本地图片处理产物发生变化，不上传')
+        const endpoint =
+          '/canvas/docs/' + segment(record.input.doc_id) + '/nodes/' + segment(item.nodeId)
+        if (!item.session) {
+          item.state = 'session_unknown'
+          record.state = 'upload_unknown'
+          await atomic(recordPath(profile, record.operation), record)
+          try {
+            item.session = await client.raw(
+              endpoint + '/upload-session',
+              {
+                method: 'POST',
+                body: {
+                  filename: item.fileName,
+                  file_size: local.bytes,
+                  expected_type: 'image',
+                  mime_type: mime
+                }
+              },
+              { retry: false }
+            )
+          } catch (error) {
+            throw fail(
+              codePrefix + '_UPLOAD_UNKNOWN',
+              '创建图片处理上传会话未确认；停止并保留原操作',
+              error
+            )
+          }
+          item.state = 'uploading'
+          record.state = 'uploading'
+          await atomic(recordPath(profile, record.operation), record)
+        }
+        if (!item.parts) {
+          const handle = await fs.open(image, 'r')
+          try {
+            item.parts = await uploadParts(client, handle, await handle.stat(), item.session, mime)
+          } finally {
+            await handle.close()
+          }
+          await atomic(recordPath(profile, record.operation), record)
+        }
+        item.state = 'completing'
+        await atomic(recordPath(profile, record.operation), record)
+        try {
+          item.response = validateUpload(
+            await client.raw(
+              endpoint + '/upload-complete',
+              {
+                method: 'POST',
+                body: {
+                  upload_id: item.session.upload_id,
+                  object_key: item.session.object_key,
+                  expected_parts: item.parts.length,
+                  parts: item.parts
+                }
+              },
+              { retry: false }
+            ),
+            record,
+            item
+          )
+        } catch (error) {
+          item.state = 'unknown'
+          record.state = 'upload_unknown'
+          await atomic(recordPath(profile, record.operation), record)
+          throw fail(
+            codePrefix + '_UPLOAD_UNKNOWN',
+            '图片处理上传完成结果未确认；只查询原节点/任务恢复，不再次 complete',
+            error
+          )
+        }
+        item.state = 'uploaded'
+        await atomic(recordPath(profile, record.operation), record)
+      }
+      if (!item.bound) {
+        try {
+          await bindUpload(client, {
+            docId: record.input.doc_id,
+            nodeId: item.nodeId,
+            result: item.response,
+            imageNode: nodeType(record, item) === 'image'
+          })
+          // Clear the preparation flag only after real upload binding succeeds.
+          const doc = await scopedCanvas(
+            client,
+            record.input.doc_id,
+            record.input.space,
+            record.input.team_uid
+          )
+          const node = doc.nodes.find((n) => n.id === item.nodeId)
+          if (node?.data?.extra?.file_ref !== item.response.result.file_ref)
+            throw new Error('图片处理引用读回不一致')
+          item.bound = true
+          item.state = 'completed'
+          await atomic(recordPath(profile, record.operation), record)
+        } catch (error) {
+          record.state = 'sync_pending'
+          await atomic(recordPath(profile, record.operation), record)
+          throw fail(
+            codePrefix + '_SYNC_PENDING',
+            '图片已上传，画布绑定未确认；恢复原响应，不重传图片',
+            error
+          )
+        }
+      }
+    }
+    record.state = 'completed'
+    await atomic(recordPath(profile, record.operation), record)
+    return summarize(record)
+  }
+  return { persistNodes, runUploads }
+}

package/src/local-output.js

@@ -0,0 +1,23 @@
+import fs from 'node:fs/promises'
+import path from 'node:path'
+import crypto from 'node:crypto'
+
+// A failed download/write never occupies the requested filename. Linking in the
+// same directory publishes a complete file without replacing an existing file.
+export async function exclusiveOutput(output, write) {
+  const target = path.resolve(output)
+  const temporary = path.join(path.dirname(target), '.' + crypto.randomUUID() + '.part')
+  try {
+    try {
+      await fs.lstat(target)
+      throw Object.assign(new Error('目标文件已存在；请指定新文件，不覆盖'), { code: 'EEXIST' })
+    } catch (error) {
+      if (error.code !== 'ENOENT') throw error
+    }
+    const result = await write(temporary)
+    await fs.link(temporary, target)
+    return { output: target, ...result }
+  } finally {
+    await fs.rm(temporary, { force: true })
+  }
+}

package/src/material-download.js

@@ -0,0 +1,55 @@
+import path from 'node:path'
+import fs from 'node:fs/promises'
+import crypto from 'node:crypto'
+import { materialGet } from './materials.js'
+import { requestFile } from './api.js'
+import { exclusiveOutput } from './local-output.js'
+import { downloadName } from './download-name.js'
+
+// Material download is a separate permission gate. A URL returned by list/get
+// never substitutes for a rejected download, even if that URL is still valid.
+export async function downloadMaterial(client, { space, teamUid, assetId, output, expectedHash }) {
+  if (typeof output !== 'string' || !output.trim()) throw new Error('素材下载必须提供--output FILE')
+  if (expectedHash !== undefined && (typeof expectedHash !== 'string' || !/^[a-fA-F0-9]{64}$/.test(expectedHash)))
+    throw new Error('--sha256 必须是64位十六进制')
+  // Resolve scope through the actual folder list and asset detail before asking
+  // the server for a new original-file link. No filename or format override.
+  const asset = await materialGet(client, { space, teamUid, assetId })
+  if (String(asset.id) !== String(assetId) || !/^(image|video|audio)\//.test(asset.mime_type || '') || !asset.file_ref)
+    throw new Error('素材身份、媒体类型或原文件引用不完整，停止下载')
+  const major = asset.mime_type.split('/')[0]
+  const link = await client.raw('/material-space/assets/' + encodeURIComponent(String(assetId)) + '/download',
+    {}, { retry: false })
+  if (!link?.file_ref || typeof link.url !== 'string' || !link.url.trim() ||
+      (link.format !== undefined && link.format !== 'original'))
+    throw new Error('素材原文件下载接口未返回有效原格式链接；不改用列表地址或转换格式')
+  const url = new URL(link.url, new URL(client.baseUrl).origin)
+  if (url.searchParams.has('format') && url.searchParams.get('format') !== 'original')
+    throw new Error('原文件下载链接包含转换参数；停止，不更改服务端URL或偷偷转换')
+  const saved = await exclusiveOutput(output, async temporary => {
+    const response = await requestFile(url, client.timeout)
+    const mime = (response.headers.get('content-type') || '').split(';')[0].trim().toLowerCase()
+    if (mime !== 'application/octet-stream' && !mime.startsWith(major + '/')) {
+      await response.body?.cancel()
+      throw new Error('素材下载内容类型与原素材不一致；未保存文件')
+    }
+    const handle = await fs.open(temporary, 'wx', 0o600)
+    const hash = crypto.createHash('sha256')
+    let bytes = 0
+    try {
+      for await (const chunk of response.body) {
+        await handle.writeFile(chunk)
+        hash.update(chunk)
+        bytes += chunk.length
+      }
+      const sha256 = hash.digest('hex'), length = response.headers.get('content-length')
+      if (!bytes || (length !== null && !response.headers.get('content-encoding') && bytes !== Number(length)) ||
+          (expectedHash && sha256 !== expectedHash.toLowerCase()))
+        throw new Error('素材下载文件完整性校验失败；未保存文件')
+      return { bytes, sha256, server_filename: downloadName(response.headers, link.filename) }
+    } finally { await handle.close() }
+  })
+  return { ...saved, output: path.resolve(output), asset_id: asset.id, format: 'original',
+    ...(typeof link.filename === 'string' ? { filename: link.filename } : {}),
+    canvas_written: false, generation_submitted: false, processing_submitted: false, library_saved: false }
+}