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

package/src/repaint-reverse.js

@@ -0,0 +1,614 @@
+import { archiveRepaintResult } from './repaint-archive.js'
+import fs from 'node:fs/promises'
+import path from 'node:path'
+import crypto from 'node:crypto'
+import { isDeepStrictEqual } from 'node:util'
+import { setTimeout as sleep } from 'node:timers/promises'
+import { atomic, json, root, safeName } from './store.js'
+import { repaintGet, recordPath } from './repaint.js'
+import { readCanvas, repaintOf, jobPath } from './repaint-graph.js'
+import { requireServiceReady } from './service.js'
+import { cancellation } from './api.js'
+
+const hash = (value) =>
+  crypto.createHash('sha256').update(JSON.stringify(value)).digest('hex')
+const text = (value) => String(value ?? '')
+const fail = (code, message, cause) =>
+  Object.assign(new Error(message), {
+    code,
+    ...(cause
+      ? {
+          cause,
+          status: cause.status,
+          apiCode: cause.apiCode,
+          requestId: cause.requestId
+        }
+      : {})
+  })
+export const reversePath = (profile, operation) =>
+  path.join(
+    root(),
+    'repaint-reverse',
+    safeName(profile),
+    safeName(operation) + '.json'
+  )
+const persist = (record) =>
+  atomic(reversePath(record.profile, record.operation), record)
+const api = (client, endpoint, options = {}, controls) =>
+  client.raw(
+    endpoint,
+    {
+      ...options,
+      headers: { ...options.headers, 'X-Client-Source': 'canvas' }
+    },
+    controls
+  )
+const fields = (node) =>
+  Object.fromEntries(
+    ['input', 'prompt', 'output'].map((key) => [key, text(node.data?.[key])])
+  )
+const globalText = (node) =>
+  text(node.data?.output || node.data?.prompt || node.data?.input)
+    .replace(/<[^>]*>/g, '')
+    .trim()
+const runState = (output) => ({
+  status:
+    output.reverse_prompt_status ||
+    (output.reverse_prompt ? 'completed' : 'not_started'),
+  prompt: output.reverse_prompt || null,
+  billing: output.reverse_prompt_billing || null
+})
+const link = (doc, a, b, role) =>
+  doc.edges.some(
+    (edge) => edge.source === a && edge.target === b && edge.data?.role === role
+  )
+
+// The parent workflow performs account, service, ownership and original-source checks.
+async function context(
+  client,
+  profile,
+  parentOperation,
+  index,
+  { allowUnsyncedGlobal = false } = {}
+) {
+  if (!Number.isSafeInteger(index) || index < 1)
+    throw new Error('segment-index必须为正整数')
+  const parent = await json(recordPath(profile, parentOperation), null)
+  if (!parent)
+    throw new Error('先查询已有转绘operation，不能自行创建任务或片段')
+  const { job } = await repaintGet(client, profile, parentOperation)
+  const doc = await readCanvas(client, parent.input)
+  const marker = doc.meta.cli_repaint_workflows?.[parentOperation]
+  if (
+    job.status !== 'completed' ||
+    !job.confirmed_at ||
+    job.confirmed_plan_version !== job.plan_version ||
+    marker?.job_id !== job.id ||
+    !marker.materialized ||
+    marker.plan_version !== job.plan_version ||
+    parent.lastPlanVersion !== job.plan_version
+  )
+    throw new Error(
+      '原分段任务/版本/已物化画布绑定不完整；先恢复原流程，不提交反推'
+    )
+  const group = doc.meta.canvas_groups?.find(
+    (item) => item.id === marker.group_id
+  )
+  if (
+    !group ||
+    (group.repaint?.jobId || group.repaintJobId) !== job.id ||
+    group.repaint?.status !== 'completed' ||
+    !Array.isArray(group.nodeIds) ||
+    !Array.isArray(marker.node_ids) ||
+    !isDeepStrictEqual(
+      [...group.nodeIds].sort(),
+      [...marker.node_ids].sort()
+    ) ||
+    !group.nodeIds.every((id) => doc.nodes.some((node) => node.id === id))
+  )
+    throw new Error('派生分组/节点被删除或改变；不自动重建')
+  const choose = (role, segmentIndex) => {
+    const nodes = doc.nodes.filter(
+      (node) =>
+        group.nodeIds.includes(node.id) &&
+        repaintOf(node).jobId === job.id &&
+        repaintOf(node).role === role &&
+        (segmentIndex === undefined ||
+          repaintOf(node).segmentIndex === segmentIndex)
+    )
+    if (nodes.length !== 1) throw new Error('派生节点角色/片段关联不唯一或缺失')
+    return nodes[0]
+  }
+  const node = choose('reverse-prompt', index),
+    source = choose('segment', index),
+    final = choose('final-prompt', index),
+    global = choose('global-prompt')
+  if (
+    node.type !== 'text' ||
+    !doc.nodes.some(
+      (n) => n.id === marker.detail_id && repaintOf(n).jobId === job.id
+    ) ||
+    !link(
+      doc,
+      parent.input.source_node_id,
+      parent.input.entry_node_id,
+      'video-repaint-input'
+    ) ||
+    !link(
+      doc,
+      parent.input.entry_node_id,
+      marker.detail_id,
+      'split-detail-link'
+    ) ||
+    !link(doc, marker.detail_id, source.id, 'source-link') ||
+    !link(doc, source.id, node.id, 'segment-reverse-link') ||
+    !link(doc, node.id, final.id, 'reverse-final-link')
+  )
+    throw new Error('原派生链或系统线缺失，不提交或重建')
+  const segments = job.plan?.segments?.filter((item) => item.index === index)
+  const outputs = job.outputs?.filter(
+    (item) => item.index === index && !item.type
+  )
+  if (segments?.length !== 1 || outputs?.length !== 1 || !outputs[0].object_key)
+    throw new Error('原任务缺少唯一真实切片产物')
+  if (
+    !allowUnsyncedGlobal &&
+    globalText(global) !== text(job.delivery_prompt_custom_prompt).trim()
+  )
+    throw new Error(
+      '画布全局规则与后端不同步；先明确并同步规则，不隐式覆盖后提交'
+    )
+  const segment = segments[0],
+    output = outputs[0]
+  let previousSegment
+  if (index > 1) {
+    const previousOutputs = job.outputs.filter(item => item.index === index - 1 && !item.type)
+    const previousPlans = job.plan.segments.filter(item => item.index === index - 1)
+    if (previousOutputs.length !== 1 || !previousOutputs[0].object_key || previousPlans.length !== 1)
+      throw new Error('非首段缺少唯一真实上一段视频上下文，停止反推')
+    previousSegment = { index: index - 1, object_key: previousOutputs[0].object_key,
+      start_ms: previousPlans[0].start_ms, end_ms: previousPlans[0].end_ms }
+  }
+  const binding = {
+    job_id: job.id,
+    plan_version: job.plan_version,
+    node_id: node.id,
+    source_id: source.id,
+    group_id: group.id,
+    index,
+    start_ms: segment.start_ms,
+    end_ms: segment.end_ms,
+    object_key: output.object_key,
+    ...(previousSegment ? { previous_segment: previousSegment } : {}),
+    rules: text(job.delivery_prompt_custom_prompt).trim()
+  }
+  return { parent, job, doc, node, output, binding, final, global }
+}
+async function quote(client, ctx) {
+  const pricing = await api(client, '/video-segmentation/pricing')
+  const unit = pricing.reverse_prompt_credits_per_segment,
+    benefit = ctx.job.billing?.has_base_benefit
+  if (
+    pricing.currency !== 'OO' ||
+    !Number.isSafeInteger(unit) ||
+    unit < 0 ||
+    typeof benefit !== 'boolean'
+  )
+    throw new Error('实时反推价格或首轮权益未知，停止')
+  const firstFree = benefit && !ctx.output.reverse_prompt
+  const me = await client.raw('/auth/me')
+  const team =
+    ctx.parent.input.space === 'team'
+      ? me.teams?.find(
+          (item) =>
+            text(item.uid) === ctx.parent.input.team_uid &&
+            item.status === 'active'
+        )
+      : null
+  if (
+    text(me.uid) !== ctx.parent.owner ||
+    (ctx.parent.input.space === 'team' && !team)
+  )
+    throw new Error('账号/团队成员身份已变化')
+  return {
+    currency: 'OO',
+    credits: firstFree ? 0 : unit,
+    unit_price: unit,
+    first_run_included: firstFree,
+    wallet: {
+      space: ctx.parent.input.space,
+      team_uid: ctx.parent.input.team_uid || null,
+      team_name: team?.name || null,
+      shared: Boolean(team),
+      balance_snapshot: (team || me).oo_balance ?? null
+    }
+  }
+}
+const costKey = (estimate) =>
+  hash({
+    credits: estimate.credits,
+    unit_price: estimate.unit_price,
+    first_run_included: estimate.first_run_included,
+    space: estimate.wallet.space,
+    team_uid: estimate.wallet.team_uid
+  })
+async function bound(client, profile, operation) {
+  const record = await json(reversePath(profile, operation), null)
+  if (
+    !record ||
+    record.schema !== 1 ||
+    record.profile !== profile ||
+    record.baseUrl !== client.baseUrl
+  )
+    throw new Error('反推operation不存在或服务不匹配')
+  const ctx = await context(
+    client,
+    profile,
+    record.parentOperation,
+    record.index
+  )
+  if (
+    record.owner !== ctx.parent.owner ||
+    !isDeepStrictEqual(ctx.binding, record.binding)
+  )
+    throw new Error('反推原任务、片段、规则或版本已变化，停止恢复')
+  return { record, ctx }
+}
+async function preventDuplicate(profile, operation, ctx) {
+  const directory = path.dirname(reversePath(profile, operation))
+  const files = await fs.readdir(directory).catch((error) => {
+    if (error.code === 'ENOENT') return []
+    throw error
+  })
+  for (const file of files.filter((file) => file.endsWith('.json'))) {
+    const other = await json(path.join(directory, file))
+    if (
+      other.operation !== operation &&
+      other.owner === ctx.parent.owner &&
+      other.baseUrl === ctx.parent.baseUrl &&
+      other.binding?.job_id === ctx.job.id &&
+      other.index === ctx.binding.index &&
+      other.attempted &&
+      !['completed', 'failed'].includes(other.state)
+    )
+      throw new Error(
+        '该片段已有未结束/未知反推operation；先查询原操作，不换名重提'
+      )
+  }
+}
+function summary(record, ctx) {
+  const state = runState(ctx.output)
+  return {
+    operation: record.operation,
+    repaint_operation: record.parentOperation,
+    state: record.state,
+    job_id: ctx.job.id,
+    plan_version: ctx.job.plan_version,
+    segment_index: record.index,
+    node_id: ctx.node.id,
+    processing_submitted: record.accepted
+      ? true
+      : record.attempted
+        ? null
+        : false,
+    remote_status: state.status,
+    canvas_synced:
+      record.canvasSynced === true &&
+      Boolean(state.prompt?.prompt) &&
+      isDeepStrictEqual(fields(ctx.node), {
+        input: state.prompt.prompt,
+        prompt: state.prompt.prompt,
+        output: state.prompt.prompt
+      }),
+    billing: state.billing,
+    reverse_prompt: state.prompt,
+    library_saved: false,
+    ...(ctx.output.reverse_prompt_error
+      ? { remote_error: text(ctx.output.reverse_prompt_error).slice(0, 1000) }
+      : {})
+  }
+}
+function validateRun(record, ctx) {
+  if (!record.accepted)
+    throw fail(
+      'REVERSE_SUBMISSION_UNKNOWN',
+      '反推响应未知；仅查询原job/segment，不自动归属结果或重发POST'
+    )
+  const state = runState(ctx.output),
+    billing = state.billing
+  if (
+    !billing ||
+    billing.plan_version !== record.binding.plan_version ||
+    billing.amount !== record.approvedCost ||
+    (record.reservationKey && billing.reservation_key !== record.reservationKey)
+  )
+    throw new Error('原反推计费/运行标记变化，停止，不认领另一轮结果')
+  if (
+    state.status === 'completed' &&
+    (!text(state.prompt?.prompt).trim() ||
+      state.prompt.generation_number !== record.generationBefore + 1)
+  )
+    throw new Error('反推完成内容/生成轮次不匹配；不覆盖或重新反推')
+  if (
+    record.resultHash &&
+    (state.status !== 'completed' || hash(state.prompt) !== record.resultHash)
+  )
+    throw new Error('原反推结果已被替换，不覆盖后续结果')
+  return state
+}
+export async function startReverse(
+  client,
+  profile,
+  parentOperation,
+  index,
+  operation,
+  confirmed = false,
+  expectedCost
+) {
+  safeName(operation)
+  safeName(parentOperation)
+  const ctx = await context(client, profile, parentOperation, index)
+  let record = await json(reversePath(profile, operation), null)
+  if (
+    record &&
+    (record.parentOperation !== parentOperation ||
+      record.index !== index ||
+      record.baseUrl !== client.baseUrl ||
+      record.owner !== ctx.parent.owner ||
+      !isDeepStrictEqual(record.binding, ctx.binding))
+  )
+    throw new Error('原反推operation不能修改参数、账号或服务')
+  if (record?.attempted) return recoverReverse(client, profile, operation)
+  await preventDuplicate(profile, operation, ctx)
+  if (runState(ctx.output).status === 'running')
+    throw new Error('该片段已经在反推，先查询现有状态，不提交另一轮')
+  if (runState(ctx.output).status === 'failed')
+    throw new Error('该片段已有失败反推；先核对原操作，不自动重做')
+  if (!['not_started', 'completed'].includes(runState(ctx.output).status))
+    throw new Error('原片段反推状态未知，停止，不提交另一轮')
+  const estimate = await quote(client, ctx)
+  const baseline = runState(ctx.output)
+  if (!confirmed) {
+    record = {
+      schema: 1,
+      profile,
+      operation,
+      parentOperation,
+      index,
+      owner: ctx.parent.owner,
+      baseUrl: client.baseUrl,
+      binding: ctx.binding,
+      baseline,
+      nodeBefore: fields(ctx.node),
+      estimate,
+      estimateKey: costKey(estimate),
+      generationBefore: ctx.output.reverse_prompt?.generation_number || 0,
+      state: 'prepared',
+      createdAt: new Date().toISOString(),
+      ...(record?.confirmationAttempted ? { confirmationAttempted: true } : {})
+    }
+    await persist(record)
+    return {
+      ...summary(record, ctx),
+      submitted: false,
+      estimate,
+      parameters: {
+        segment_index: index,
+        start_ms: ctx.binding.start_ms,
+        end_ms: ctx.binding.end_ms,
+        phase: 'reverse_prompt',
+        model: 'service_managed',
+        global_rules: ctx.binding.rules
+      },
+      next: '展示原片段、全局规则、付款钱包及本次费用，取得当次确认后同operation加--yes --expected-cost；不会自动处理最终提示词或生成视频'
+    }
+  }
+  if (
+    !record ||
+    expectedCost === undefined ||
+    Number(expectedCost) !== estimate.credits ||
+    record.estimateKey !== costKey(estimate) ||
+    !isDeepStrictEqual(record.baseline, baseline) ||
+    !isDeepStrictEqual(record.nodeBefore, fields(ctx.node))
+  )
+    throw new Error(
+      '先预估并当次确认；费用、节点内容或原反推状态变化需重新核对'
+    )
+  await requireServiceReady(client)
+  if (!ctx.output.reverse_prompt_confirmed_at) {
+    if (record.confirmationAttempted)
+      throw fail(
+        'REVERSE_SUBMISSION_UNKNOWN',
+        '原片段确认响应未知且尚未查明；先reverse-recover，不重发确认'
+      )
+    record.confirmationAttempted = true
+    record.state = 'confirming_segment'
+    await persist(record)
+    try {
+      await api(
+        client,
+        jobPath(ctx.job.id) + '/segments/' + index + '/confirm-reverse-prompt',
+        { method: 'POST', body: {} },
+        { retry: false }
+      )
+    } catch (error) {
+      record.state = 'confirmation_unknown'
+      await persist(record)
+      throw fail(
+        'REVERSE_SUBMISSION_UNKNOWN',
+        '片段确认结果未确认，未发送反推；先检查后端并查询原operation',
+        error
+      )
+    }
+  }
+  const fresh = await context(client, profile, parentOperation, index)
+  if (
+    !fresh.output.reverse_prompt_confirmed_at ||
+    !isDeepStrictEqual(fresh.binding, record.binding) ||
+    !isDeepStrictEqual(runState(fresh.output), record.baseline) ||
+    !isDeepStrictEqual(fields(fresh.node), record.nodeBefore) ||
+    costKey(await quote(client, fresh)) !== record.estimateKey
+  )
+    throw new Error('确认片段后参数/状态/费用变化，未提交反推，重新预估确认')
+  record.attempted = true
+  record.approvedCost = estimate.credits
+  record.state = 'submitting'
+  await persist(record)
+  try {
+    const response = await api(
+      client,
+      jobPath(ctx.job.id) + '/segments/' + index + '/reverse-prompt',
+      { method: 'POST', body: {} },
+      { retry: false }
+    )
+    const output = response?.outputs?.find(
+      (item) => item.index === index && !item.type
+    )
+    if (
+      response?.id === ctx.job.id &&
+      response.canvas_doc_id === ctx.doc.id &&
+      text(response.team_uid || '') === text(ctx.doc.team_uid || '') &&
+      response.plan_version === record.binding.plan_version &&
+      output?.reverse_prompt_billing?.plan_version ===
+        record.binding.plan_version
+    ) {
+      record.accepted = true
+      record.reservationKey =
+        output.reverse_prompt_billing.reservation_key || null
+      await persist(record)
+    }
+    if (!record.accepted) throw new Error('反推响应缺少可核验原任务标记')
+    record.state = 'running'
+    await persist(record)
+  } catch (error) {
+    record.state = 'submission_unknown'
+    await persist(record)
+    throw fail(
+      'REVERSE_SUBMISSION_UNKNOWN',
+      '反推提交结果未确认；只查询原job/segment，不能重发或换operation',
+      error
+    )
+  }
+  return recoverReverse(client, profile, operation)
+}
+export async function getReverse(client, profile, operation) {
+  const { record, ctx } = await bound(client, profile, operation)
+  if (record.accepted) validateRun(record, ctx)
+  return summary(record, ctx)
+}
+export async function recoverReverse(client, profile, operation) {
+  const { record, ctx } = await bound(client, profile, operation)
+  if (!record.attempted) {
+    if (
+      record.confirmationAttempted &&
+      ctx.output.reverse_prompt_confirmed_at
+    ) {
+      record.state = 'segment_confirmed'
+      await persist(record)
+    }
+    return summary(record, ctx)
+  }
+  const state = validateRun(record, ctx)
+  if (state.status === 'failed') {
+    record.state = 'failed'
+    await persist(record)
+    return summary(record, ctx)
+  }
+  if (state.status !== 'completed') {
+    record.state = 'running'
+    await persist(record)
+    return summary(record, ctx)
+  }
+  await archiveRepaintResult(record, 'reverse', state.prompt, state.billing)
+  const prompt = state.prompt.prompt,
+    expected = { input: prompt, prompt, output: prompt },
+    current = fields(ctx.node)
+  if (
+    !isDeepStrictEqual(current, expected) &&
+    !isDeepStrictEqual(current, record.nodeBefore)
+  )
+    throw fail(
+      'REVERSE_SYNC_PENDING',
+      '反推节点内容已由用户编辑，不覆盖；原结果仍可查询'
+    )
+  record.resultHash = hash(state.prompt)
+  record.state = 'completed'
+  await persist(record)
+  if (!isDeepStrictEqual(current, expected)) {
+    ctx.node.data = { ...ctx.node.data, ...expected }
+    try {
+      const saved = await api(
+        client,
+        '/canvas/docs/' + encodeURIComponent(ctx.doc.id),
+        {
+          method: 'PUT',
+          body: {
+            version: ctx.doc.version,
+            name: ctx.doc.name,
+            viewport: ctx.doc.viewport,
+            nodes: ctx.doc.nodes,
+            edges: ctx.doc.edges,
+            meta: ctx.doc.meta
+          }
+        },
+        { retry: false }
+      )
+      if (
+        saved.version !== ctx.doc.version + 1 ||
+        !isDeepStrictEqual(
+          fields(saved.nodes?.find((n) => n.id === ctx.node.id) || {}),
+          expected
+        )
+      )
+        throw new Error('反推保存响应不完整')
+    } catch (error) {
+      record.state = 'sync_pending'
+      await persist(record)
+      throw fail(
+        'REVERSE_SYNC_PENDING',
+        '原反推已完成，画布保存未确认；reverse-recover只读回核对并恢复，不重做反推',
+        error
+      )
+    }
+  }
+  record.canvasSynced = true
+  await persist(record)
+  return { ...summary(record, ctx), canvas_synced: true }
+}
+export async function waitReverse(
+  client,
+  profile,
+  operation,
+  interval = 2000,
+  timeout = 180000
+) {
+  if (
+    ![interval, timeout].every(
+      (value) => Number.isSafeInteger(value) && value > 0
+    )
+  )
+    throw new Error('等待参数必须为正整数')
+  const deadline = Date.now() + timeout
+  while (Date.now() < deadline) {
+    const result = await recoverReverse(client, profile, operation)
+    if (result.state === 'completed') return result
+    if (result.state === 'failed')
+      throw fail('TASK_FAILED', '原片段反推失败；查询原operation，不自动重做')
+    if (!result.processing_submitted) return result
+    await sleep(
+      Math.min(interval, Math.max(1, deadline - Date.now())),
+      undefined,
+      {
+        signal: cancellation.signal
+      }
+    )
+  }
+  throw fail(
+    'WAIT_TIMEOUT',
+    '等待反推超时，使用原operation的reverse-wait/reverse-recover继续，不重新提交'
+  )
+}
+
+// Shared read-only validation for the next prompt phase; reverse behavior is unchanged.
+export { context as repaintPromptContext, fields as repaintPromptFields }
+export { validateRun as validateReverseRun }