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

package/src/agreement.js

@@ -0,0 +1,419 @@
+import crypto from 'node:crypto'
+import http from 'node:http'
+import { request, cancellation } from './api.js'
+import { unwrap } from './protocol.js'
+import { openLoginBrowser } from './normal-login.js'
+import { agreementPage } from './agreement-page.js'
+
+export const AGREEMENT_LABEL = '《统一协议》'
+export const AGREEMENT_TITLE = '《Seedance2.0模型使用承诺书》'
+export function agreementError(code, message, protocol) {
+  const error = new Error(message)
+  Object.assign(error, { code, apiCode: 4401, status: 'awaiting_agreement', protocol })
+  return error
+}
+export function validateProtocol(value) {
+  if (
+    !value ||
+    typeof value.required !== 'boolean' ||
+    typeof value.agreed !== 'boolean' ||
+    typeof value.version !== 'string'
+  )
+    throw new Error('协议状态响应不完整，停止继续生成')
+  return {
+    required: value.required,
+    agreed: value.agreed,
+    version: value.version,
+    label: AGREEMENT_LABEL,
+    document_title: AGREEMENT_TITLE,
+    message: String(value.message || '请阅读并确认协议后继续').slice(0, 2000)
+  }
+}
+export async function readProtocol(client) {
+  return validateProtocol((await client.raw('/video/protocol-agreement')).protocol)
+}
+async function publicText(url, timeout) {
+  const response = await request(
+    url,
+    { headers: { Accept: 'text/html, application/json' } },
+    timeout
+  )
+  if (!response.ok) {
+    await response.body?.cancel()
+    throw new Error('协议正文读取失败')
+  }
+  const chunks = []
+  let size = 0
+  for await (const chunk of response.body) {
+    size += chunk.length
+    if (size > 2 * 1024 * 1024) {
+      await response.body.cancel().catch(() => {})
+      throw new Error('协议正文超过读取限制')
+    }
+    chunks.push(chunk)
+  }
+  return {
+    text: Buffer.concat(chunks).toString('utf8'),
+    mime: response.headers.get('content-type') || ''
+  }
+}
+export async function readAgreementDocument(client) {
+  const base = new URL(client.baseUrl)
+  const list = await publicText(client.baseUrl + '/content', client.timeout)
+  const items = unwrap(JSON.parse(list.text)).items
+  if (!Array.isArray(items)) throw new Error('已发布协议目录无效')
+  const matches = items.filter(
+    (i) => i.type === 'terms_of_service' && /seedance/i.test(i.title || '')
+  )
+  const exact = matches.filter(
+    (i) => String(i.title).replace(/\s/g, '') === 'Seedance2.0模型使用承诺书'
+  )
+  const candidates = exact.length ? exact : matches
+  if (candidates.length !== 1) throw new Error('未找到唯一的 Seedance 模型使用承诺书，停止签署')
+  const item = candidates[0]
+  let html = typeof item.content === 'string' ? item.content : ''
+  let source = client.baseUrl + '/content'
+  if (!html.trim()) {
+    const url = new URL(item.content_url, client.baseUrl + '/')
+    const prefix = base.pathname.replace(/\/$/, '')
+    if (
+      url.origin !== base.origin ||
+      url.username ||
+      url.password ||
+      url.hash ||
+      !new RegExp(
+        '^' + prefix.replace(/[.*+?^${}()|[\]\\]/g, '\\$&') + '/content/[0-9]+/body$'
+      ).test(url.pathname) ||
+      url.searchParams.get('kind') !== 'doc' ||
+      [...url.searchParams.keys()].some((k) => k !== 'kind')
+    )
+      throw new Error('协议正文地址不属于当前服务的公开内容接口')
+    source = url.href
+    const content = await publicText(source, client.timeout)
+    if (!/text\/html/i.test(content.mime)) throw new Error('协议正文不是 HTML')
+    html = content.text
+  }
+  if (!html.trim() || html.length > 2 * 1024 * 1024) throw new Error('协议正文为空或过大，不能确认')
+  return {
+    id: item.id,
+    title: String(item.title),
+    version: item.version,
+    source,
+    html,
+    digest: crypto
+      .createHash('sha256')
+      .update(JSON.stringify([item.id, item.title, item.version, html]))
+      .digest('hex')
+  }
+}
+const identity = (value) => {
+  const uid = String(value.uid ?? value.id ?? '')
+  if (!uid) throw new Error('无法核对协议签署账号')
+  return { uid, name: String(value.name || value.username || uid) }
+}
+
+export async function startAgreementBridge({
+  client,
+  protocol,
+  document,
+  account,
+  continuation,
+  timeout = 300000,
+  signal = cancellation.signal
+}) {
+  const token = crypto.randomBytes(32).toString('base64url'),
+    csrf = crypto.randomBytes(32).toString('base64url'),
+    nonce = crypto.randomBytes(24).toString('base64url')
+  const pathname = '/agreement/' + token
+  let origin,
+    closed = false,
+    settled = false,
+    processing = false,
+    decisionSent = false,
+    timer,
+    resolveWait,
+    rejectWait
+  const wait = new Promise((resolve, reject) => {
+    resolveWait = resolve
+    rejectWait = reject
+  })
+  void wait.catch(() => {})
+  function fail(code, message, diagnostic) {
+    if (!settled) {
+      settled = true
+      const error=agreementError(code, message, protocol)
+      if(diagnostic){error.diagnostic=diagnostic;error.apiCode=diagnostic.api_code;error.requestId=diagnostic.request_id}
+      rejectWait(error)
+    }
+  }
+  function agreed(state) {
+    if (!settled) {
+      settled = true
+      resolveWait({
+        status: state.agreed ? 'agreed' : 'not_required',
+        protocol: state,
+        account: { uid: account.uid, name: account.name }
+      })
+    }
+  }
+  async function checkAccount() {
+    if (identity(await client.raw('/auth/me')).uid !== account.uid)
+      throw agreementError(
+        'AGREEMENT_ACCOUNT_CHANGED',
+        'CLI 账号已变化，未继续签署或生成',
+        protocol
+      )
+  }
+  async function freshState() {
+    await checkAccount()
+    const state = await readProtocol(client)
+    if (state.version !== protocol.version)
+      throw agreementError(
+        'AGREEMENT_CHANGED',
+        '协议版本已更新，请重新打开并阅读当前版本后确认',
+        state
+      )
+    return state
+  }
+  async function freshDocument() {
+    const latest = await readAgreementDocument(client)
+    if (latest.digest !== document.digest)
+      throw agreementError('AGREEMENT_CHANGED', '协议正文已变化，请重新打开并阅读后确认', protocol)
+  }
+  const server = http.createServer(async (req, res) => {
+    res.setHeader('Cache-Control', 'no-store')
+    res.setHeader('Referrer-Policy', 'no-referrer')
+    res.setHeader('X-Content-Type-Options', 'nosniff')
+    const send = (status, data) => {
+      if (!res.writableEnded) {
+        res.writeHead(status, { 'Content-Type': 'application/json; charset=utf-8' })
+        res.end(JSON.stringify(data))
+      }
+    }
+    if (closed || req.headers.host !== new URL(origin).host) {
+      send(403, { status: 'rejected', message: '本机确认地址不匹配' })
+      return
+    }
+    if (req.method === 'GET' && req.url === pathname) {
+      res.setHeader(
+        'Content-Security-Policy',
+        `default-src 'none'; script-src 'nonce-${nonce}'; style-src 'unsafe-inline'; frame-src 'self'; connect-src 'self'; form-action 'none'; frame-ancestors 'none'; base-uri 'none'`
+      )
+      res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' })
+      res.end(
+        agreementPage({
+          protocol,
+          document,
+          account: { ...account, origin: new URL(client.baseUrl).origin },
+          continuation,
+          actionPath: pathname + '/decision',
+          csrf,
+          nonce
+        })
+      )
+      return
+    }
+    if (req.method === 'GET' && req.url === pathname + '/status') {
+      if (settled) {
+        send(200, { status: 'cancelled', message: '本次页面已结束，请查看 CLI 状态' })
+        return
+      }
+      if (processing) {
+        send(200, { status: 'waiting', message: '正在确认' })
+        return
+      }
+      try {
+        const state = await freshState()
+        if (state.agreed || !state.required) {
+          if (state.required) await freshDocument()
+          res.once('finish', () => agreed(state))
+          send(200, {
+            status: state.agreed ? 'agreed' : 'not_required',
+            message: state.agreed
+              ? '当前账号已确认当前版本协议，CLI 将核验后继续'
+              : '当前服务不要求协议确认，未记录同意，CLI 将重新核验后继续'
+          })
+        } else send(200, { status: 'waiting', protocol: state })
+      } catch (error) {
+        if (error.code?.startsWith('AGREEMENT_')) {
+          send(409, { status: 'changed', message: error.message })
+          fail(error.code, error.message)
+        } else send(503, { status: 'waiting', message: '协议状态查询暂不可用，尚未继续生成' })
+      }
+      return
+    }
+    if (req.method !== 'POST' || req.url !== pathname + '/decision') {
+      send(404, { status: 'rejected', message: '页面不存在' })
+      return
+    }
+    if (
+      req.headers.origin !== origin ||
+      req.headers['x-uzoo-agreement'] !== csrf ||
+      !/^application\/json(?:;|$)/i.test(req.headers['content-type'] || '')
+    ) {
+      send(403, { status: 'rejected', message: '需要从本页明确确认' })
+      return
+    }
+    if (settled || processing || decisionSent) {
+      send(409, { status: 'waiting', message: '本次确认已处理或结果待核实，请勿重复点击' })
+      return
+    }
+    processing = true
+    try {
+      const chunks = []
+      let size = 0
+      for await (const chunk of req) {
+        size += chunk.length
+        if (size > 1024) {
+          send(413, { status: 'rejected', message: '确认请求过大' })
+          return
+        }
+        chunks.push(chunk)
+      }
+      let body
+      try {
+        body = JSON.parse(Buffer.concat(chunks).toString('utf8'))
+      } catch {
+        send(400, { status: 'rejected', message: '确认请求无效' })
+        return
+      }
+      if (!body || typeof body.agreed !== 'boolean' || Object.keys(body).length !== 1) {
+        send(400, { status: 'rejected', message: '缺少明确选择' })
+        return
+      }
+      if (!body.agreed) {
+        res.once('finish', () =>
+          fail(
+            'AGREEMENT_DECLINED',
+            '用户未同意《统一协议》《Seedance2.0模型使用承诺书》，本次生成未继续'
+          )
+        )
+        send(200, { status: 'declined', message: '你选择了不同意，本次生成未继续' })
+        return
+      }
+      const state = await freshState()
+      if (state.required) await freshDocument()
+      if (!state.agreed && state.required) {
+        decisionSent = true
+        // This authenticated POST only occurs after the human's checkbox + click.
+        await client.raw(
+          '/video/protocol-agreement',
+          { method: 'POST', body: { agreed: true } },
+          { retry: false }
+        )
+      }
+      const verified = await freshState()
+      if (verified.required) await freshDocument()
+      if (verified.required && !verified.agreed) throw new Error('签署记录尚未确认')
+      res.once('finish', () => agreed(verified))
+      send(200, {
+        status: verified.agreed ? 'agreed' : 'not_required',
+        message: verified.agreed
+          ? '协议状态已核验，CLI 将检查原任务参数与费用后继续'
+          : '当前服务不要求协议确认，未记录同意，CLI 将重新核验后继续'
+      })
+    } catch (error) {
+      if (error.code === 'API_ERROR' && (error.apiCode === 2001 || [401,403].includes(error.status))) {
+        const requestId=/^[a-zA-Z0-9_-]{1,120}$/.test(error.requestId||'')?error.requestId:undefined
+        const message='协议确认被服务端拒绝（HTTP '+error.status+(error.apiCode?'，code '+error.apiCode:'')+(requestId?'，request_id '+requestId:'')+'）；尚未核验签署成功，未继续生成。请核对账号和接口权限。'
+        res.once('finish',()=>fail('AGREEMENT_REJECTED',message,{http_status:error.status,...(error.apiCode?{api_code:error.apiCode}:{}),...(requestId?{request_id:requestId}:{})}))
+        send(403,{status:'rejected',message})
+      } else
+      if (error.code?.startsWith('AGREEMENT_')) {
+        send(409, { status: 'changed', message: error.message })
+        fail(error.code, error.message)
+      } else
+        send(503, {
+          status: 'waiting',
+          message: '协议签署结果尚未确认，CLI 会只读查询；不会重复提交同意或继续生成'
+        })
+    } finally {
+      processing = false
+    }
+  })
+  server.requestTimeout = 10000
+  server.headersTimeout = 10000
+  await new Promise((resolve, reject) => {
+    server.once('error', reject)
+    server.listen(0, '127.0.0.1', resolve)
+  })
+  origin = `http://127.0.0.1:${server.address().port}`
+  const abort = () => fail('AGREEMENT_CANCELLED', '协议确认已取消，原任务未继续')
+  signal.addEventListener('abort', abort, { once: true })
+  if (signal.aborted) abort()
+  timer = setTimeout(
+    () =>
+      fail(
+        'AGREEMENT_WAIT_TIMEOUT',
+        '等待用户确认协议超时，原任务保持等待签署，可恢复原 operation'
+      ),
+    timeout
+  )
+  return {
+    url: origin + pathname,
+    wait,
+    close: async () => {
+      if (closed) return
+      closed = true
+      clearTimeout(timer)
+      signal.removeEventListener('abort', abort)
+      server.closeAllConnections()
+      await new Promise((resolve) => server.close(resolve))
+    }
+  }
+}
+
+export async function browserAgreement(
+  client,
+  {
+    browser = 'default',
+    timeout = 300000,
+    openUrl = openLoginBrowser,
+    onReady = () => {},
+    onOpenError = () => {},
+    continuation,
+    signal = cancellation.signal
+  } = {}
+) {
+  if (
+    !['default', 'msedge', 'chrome'].includes(browser) ||
+    !Number.isSafeInteger(timeout) ||
+    timeout < 1 ||
+    timeout > 1800000
+  )
+    throw new Error('协议浏览器或等待时间无效')
+  const account = identity(await client.raw('/auth/me'))
+  const protocol = await readProtocol(client)
+  if (!protocol.required || protocol.agreed)
+    return { status: protocol.agreed ? 'already_agreed' : 'not_required', protocol, account }
+  let document
+  try {
+    document = await readAgreementDocument(client)
+  } catch {
+    throw agreementError(
+      'AGREEMENT_DOCUMENT_UNAVAILABLE',
+      '《统一协议》《Seedance2.0模型使用承诺书》正文暂不可用，未签署也未继续生成',
+      protocol
+    )
+  }
+  const bridge = await startAgreementBridge({
+    client,
+    protocol,
+    document,
+    account,
+    continuation,
+    timeout,
+    signal
+  })
+  try {
+    onReady(bridge.url, { protocol, account, document: { title: document.title, id: document.id } })
+    try {
+      await openUrl(bridge.url, browser)
+    } catch (error) {
+      onOpenError(error.message)
+    }
+    return await bridge.wait
+  } finally {
+    await bridge.close()
+  }
+}