bingocode 1.0.41 → 1.1.42

package/adapters/common/pairing.ts

@@ -1,149 +0,0 @@
-/**
- * 配对核心逻辑
- *
- * - generatePairingCode(): 生成 6 位安全配对码
- * - isPaired(): 检查用户是否已配对（pairedUsers + allowedUsers 并集）
- * - tryPair(): 验证配对码，成功则写入 pairedUsers 并清除 code
- */
-
-import * as fs from 'node:fs'
-import * as os from 'node:os'
-import * as path from 'node:path'
-import * as crypto from 'node:crypto'
-import type { PairedUser, PairingState } from './config.js'
-
-const SAFE_ALPHABET = 'ABCDEFGHJKMNPQRSTUVWXYZ23456789' // 排除 0/O/1/I/L
-
-// 速率限制：每个 userId 在 RATE_LIMIT_WINDOW_MS 内最多 RATE_LIMIT_MAX_ATTEMPTS 次失败尝试
-const RATE_LIMIT_WINDOW_MS = 5 * 60 * 1000 // 5 minutes
-const RATE_LIMIT_MAX_ATTEMPTS = 5
-const failedAttempts = new Map<string, { count: number; firstAttempt: number }>()
-
-function isRateLimited(userId: string | number): boolean {
-  const key = String(userId)
-  const record = failedAttempts.get(key)
-  if (!record) return false
-  if (Date.now() - record.firstAttempt > RATE_LIMIT_WINDOW_MS) {
-    failedAttempts.delete(key)
-    return false
-  }
-  return record.count >= RATE_LIMIT_MAX_ATTEMPTS
-}
-
-function recordFailedAttempt(userId: string | number): void {
-  const key = String(userId)
-  const record = failedAttempts.get(key)
-  if (!record || Date.now() - record.firstAttempt > RATE_LIMIT_WINDOW_MS) {
-    failedAttempts.set(key, { count: 1, firstAttempt: Date.now() })
-  } else {
-    record.count++
-  }
-}
-const CODE_LENGTH = 6
-const CODE_TTL_MS = 60 * 60 * 1000 // 60 minutes
-
-function getConfigPath(): string {
-  const configDir = process.env.CLAUDE_CONFIG_DIR || path.join(os.homedir(), '.claude')
-  return path.join(configDir, 'adapters.json')
-}
-
-function readConfigFile(): Record<string, any> {
-  try {
-    return JSON.parse(fs.readFileSync(getConfigPath(), 'utf-8'))
-  } catch {
-    return {}
-  }
-}
-
-function writeConfigFile(data: Record<string, any>): void {
-  const filePath = getConfigPath()
-  const dir = path.dirname(filePath)
-  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true })
-  const tmp = `${filePath}.tmp.${Date.now()}`
-  fs.writeFileSync(tmp, JSON.stringify(data, null, 2) + '\n', 'utf-8')
-  fs.renameSync(tmp, filePath)
-}
-
-export function generatePairingCode(): string {
-  let code = ''
-  for (let i = 0; i < CODE_LENGTH; i++) {
-    code += SAFE_ALPHABET[crypto.randomInt(SAFE_ALPHABET.length)]
-  }
-  return code
-}
-
-/** 检查用户是否已配对（pairedUsers + allowedUsers 并集） */
-export function isPaired(
-  platform: 'telegram' | 'feishu',
-  userId: string | number,
-  config: Record<string, any>,
-): boolean {
-  const platformConfig = config[platform] ?? {}
-  const allowedUsers: (string | number)[] = platformConfig.allowedUsers ?? []
-  const pairedUsers: PairedUser[] = platformConfig.pairedUsers ?? []
-
-  // allowedUsers 非空时检查
-  if (allowedUsers.length > 0 && allowedUsers.includes(userId)) return true
-  // 默认关闭：没有配置任何用户时拒绝访问（需要先配对）
-  if (pairedUsers.length === 0 && allowedUsers.length === 0) return false
-
-  return pairedUsers.some((p) => String(p.userId) === String(userId))
-}
-
-/**
- * 尝试配对：验证消息文本是否匹配当前有效配对码。
- * 成功则写入 pairedUsers 并清除 pairing.code，返回 true。
- */
-export function tryPair(
-  messageText: string,
-  senderInfo: { userId: string | number; displayName: string },
-  platform: 'telegram' | 'feishu',
-): boolean {
-  const file = readConfigFile()
-  const pairing: PairingState = file.pairing ?? { code: null, expiresAt: null, createdAt: null }
-
-  // 速率限制检查
-  if (isRateLimited(senderInfo.userId)) return false
-
-  // 检查配对码是否有效
-  if (!pairing.code || !pairing.expiresAt) return false
-  if (Date.now() > pairing.expiresAt) return false
-
-  // 比较（忽略大小写和空格）
-  const input = messageText.trim().toUpperCase()
-  if (input !== pairing.code.toUpperCase()) {
-    recordFailedAttempt(senderInfo.userId)
-    return false
-  }
-
-  // 配对成功：写入 pairedUsers
-  const platformConfig = file[platform] ?? {}
-  const pairedUsers: PairedUser[] = platformConfig.pairedUsers ?? []
-
-  // 避免重复
-  const exists = pairedUsers.some((p) => String(p.userId) === String(senderInfo.userId))
-  if (!exists) {
-    pairedUsers.push({
-      userId: senderInfo.userId,
-      displayName: senderInfo.displayName,
-      pairedAt: Date.now(),
-    })
-  }
-
-  // 更新 config
-  file[platform] = { ...platformConfig, pairedUsers }
-  file.pairing = { code: null, expiresAt: null, createdAt: null } // 一次性使用
-  writeConfigFile(file)
-
-  return true
-}
-
-/** 统一的用户授权检查（供各 adapter 调用） */
-export function isAllowedUser(platform: 'telegram' | 'feishu', userId: string | number): boolean {
-  try {
-    const cfgFile = readConfigFile()
-    return isPaired(platform, userId, cfgFile)
-  } catch {
-    return false
-  }
-}

package/adapters/common/session-store.ts

@@ -1,60 +0,0 @@
-import * as fs from 'node:fs'
-import * as path from 'node:path'
-import * as os from 'node:os'
-
-export type SessionEntry = {
-  sessionId: string
-  workDir: string
-  updatedAt: number
-}
-
-type StoreData = Record<string, SessionEntry>
-
-function getDefaultPath(): string {
-  const configDir = process.env.CLAUDE_CONFIG_DIR || path.join(os.homedir(), '.claude')
-  return path.join(configDir, 'adapter-sessions.json')
-}
-
-export class SessionStore {
-  private data: StoreData
-  private filePath: string
-
-  constructor(filePath?: string) {
-    this.filePath = filePath ?? getDefaultPath()
-    this.data = this.load()
-  }
-
-  get(chatId: string): SessionEntry | null {
-    return this.data[chatId] ?? null
-  }
-
-  set(chatId: string, sessionId: string, workDir: string): void {
-    this.data[chatId] = { sessionId, workDir, updatedAt: Date.now() }
-    this.save()
-  }
-
-  delete(chatId: string): void {
-    delete this.data[chatId]
-    this.save()
-  }
-
-  listAll(): Array<{ chatId: string } & SessionEntry> {
-    return Object.entries(this.data).map(([chatId, entry]) => ({ chatId, ...entry }))
-  }
-
-  private load(): StoreData {
-    try {
-      return JSON.parse(fs.readFileSync(this.filePath, 'utf-8'))
-    } catch {
-      return {}
-    }
-  }
-
-  private save(): void {
-    const dir = path.dirname(this.filePath)
-    fs.mkdirSync(dir, { recursive: true })
-    const tmp = `${this.filePath}.tmp.${Date.now()}`
-    fs.writeFileSync(tmp, JSON.stringify(this.data, null, 2) + '\n')
-    fs.renameSync(tmp, this.filePath)
-  }
-}

package/adapters/common/ws-bridge.ts

@@ -1,282 +0,0 @@
-/**
- * WebSocket Bridge
- *
- * 封装与 Claude Code Desktop 服务端 /ws/:sessionId 的通信。
- * 管理 chatId → sessionId 映射，自动重连，心跳。
- */
-
-import WebSocket from 'ws'
-
-/** Attachment reference — mirrors src/server/ws/events.ts AttachmentRef.
- *  The server will either (a) write base64 `data` to
- *  ~/.claude/uploads/{sessionId}/ and convert to ImageBlockParam, or
- *  (b) read `path` from disk and inject `@"path"` into the prompt. */
-export type AttachmentRef = {
-  type: 'file' | 'image'
-  name?: string
-  path?: string
-  data?: string      // base64 payload (images)
-  mimeType?: string
-}
-
-/** Server → Client message (mirrors src/server/ws/events.ts ServerMessage) */
-export type ServerMessage = {
-  type: string
-  [key: string]: any
-}
-
-/** Callback for server messages */
-export type MessageHandler = (msg: ServerMessage) => void
-
-type Session = {
-  sessionId: string
-  ws: WebSocket
-  reconnectAttempts: number
-  reconnectTimer: ReturnType<typeof setTimeout> | null
-}
-
-const HEARTBEAT_INTERVAL_MS = 30_000
-const RECONNECT_BASE_MS = 1000
-const RECONNECT_MAX_MS = 30_000
-const MAX_RECONNECT_ATTEMPTS = 10
-
-export class WsBridge {
-  private sessions = new Map<string, Session>()
-  /** Single handler per chatId — separate from sessions so reconnect doesn't duplicate */
-  private handlers = new Map<string, MessageHandler>()
-  /** Per-chat FIFO queue of in-flight handler promises.
-   *  Ensures an async handler for message N completes before handler for N+1
-   *  starts, preventing state races at `await` points. */
-  private handlerChains = new Map<string, Promise<void>>()
-  private serverUrl: string
-  private platform: string
-  private heartbeatTimer: ReturnType<typeof setInterval> | null = null
-  private destroyed = false
-
-  constructor(serverUrl: string, platform: string) {
-    this.serverUrl = serverUrl.replace(/\/$/, '')
-    this.platform = platform
-    this.startHeartbeat()
-  }
-
-  /** Connect to a session with a known sessionId. Returns false if already connected. */
-  connectSession(chatId: string, sessionId: string): boolean {
-    const existing = this.sessions.get(chatId)
-    if (existing && existing.ws.readyState === WebSocket.OPEN) {
-      return false
-    }
-    this.connect(chatId, sessionId)
-    return true
-  }
-
-  /** Send a user message to the session bound to chatId. */
-  sendUserMessage(
-    chatId: string,
-    content: string,
-    attachments?: AttachmentRef[],
-  ): boolean {
-    const payload: Record<string, unknown> = { type: 'user_message', content }
-    if (attachments && attachments.length > 0) {
-      payload.attachments = attachments
-    }
-    return this.send(chatId, payload)
-  }
-
-  /** Respond to a permission request.
-   *
-   * @param rule - optional rule name to make the permission persistent.
-   *   Currently the server supports `'always'`, which uses the CLI's
-   *   permission_suggestions to produce updatedPermissions so the same
-   *   tool call won't prompt again in this session. Omit for one-shot allow. */
-  sendPermissionResponse(
-    chatId: string,
-    requestId: string,
-    allowed: boolean,
-    rule?: string,
-  ): boolean {
-    const message: Record<string, unknown> = {
-      type: 'permission_response',
-      requestId,
-      allowed,
-    }
-    if (rule) message.rule = rule
-    return this.send(chatId, message)
-  }
-
-  /** Stop the current generation. */
-  sendStopGeneration(chatId: string): boolean {
-    return this.send(chatId, { type: 'stop_generation' })
-  }
-
-  /** Register (or replace) the handler for server messages on a specific chatId. */
-  onServerMessage(chatId: string, handler: MessageHandler): void {
-    this.handlers.set(chatId, handler)
-  }
-
-  /** Reset session for a chatId (e.g. /new command). */
-  resetSession(chatId: string): void {
-    const session = this.sessions.get(chatId)
-    if (session) {
-      if (session.reconnectTimer) clearTimeout(session.reconnectTimer)
-      session.ws.close(1000, 'session reset')
-      this.sessions.delete(chatId)
-    }
-    this.handlers.delete(chatId)
-    this.handlerChains.delete(chatId)
-  }
-
-  /** Has a session (connected or handler registered) for chatId. */
-  hasSession(chatId: string): boolean {
-    return this.sessions.has(chatId) || this.handlers.has(chatId)
-  }
-
-  /** Destroy all sessions. */
-  destroy(): void {
-    this.destroyed = true
-    if (this.heartbeatTimer) {
-      clearInterval(this.heartbeatTimer)
-      this.heartbeatTimer = null
-    }
-    for (const [, session] of this.sessions) {
-      if (session.reconnectTimer) clearTimeout(session.reconnectTimer)
-      session.ws.close(1000, 'bridge destroyed')
-    }
-    this.sessions.clear()
-    this.handlers.clear()
-    this.handlerChains.clear()
-  }
-
-  // ------- internal -------
-
-  private connect(chatId: string, sessionId: string): void {
-    const url = `${this.serverUrl}/ws/${sessionId}`
-    const ws = new WebSocket(url)
-
-    // Cancel any pending reconnect timer for this chatId
-    const prev = this.sessions.get(chatId)
-    if (prev) {
-      if (prev.reconnectTimer) clearTimeout(prev.reconnectTimer)
-      prev.ws.removeAllListeners()
-    }
-
-    const session: Session = {
-      sessionId,
-      ws,
-      reconnectAttempts: prev?.reconnectAttempts ?? 0,
-      reconnectTimer: null,
-    }
-    this.sessions.set(chatId, session)
-
-    ws.on('open', () => {
-      console.log(`[WsBridge] Connected: ${sessionId}`)
-      session.reconnectAttempts = 0
-    })
-
-    ws.on('message', (raw) => {
-      let msg: ServerMessage
-      try {
-        msg = JSON.parse(raw.toString())
-      } catch (err) {
-        console.error('[WsBridge] Parse error:', err)
-        return
-      }
-      if (msg.type === 'pong') return
-      const handler = this.handlers.get(chatId)
-      if (!handler) return
-
-      // Serialize per-chat handler calls: chain each message onto the previous
-      // one so a slow handler (e.g. one awaiting im.message.create) fully
-      // finishes before the next message's handler runs. This prevents state
-      // races where a later message reads stale map entries set up by an
-      // earlier-but-still-in-flight handler.
-      const prev = this.handlerChains.get(chatId) ?? Promise.resolve()
-      const next = prev
-        .catch(() => {}) // upstream errors must not poison the chain
-        .then(() => Promise.resolve().then(() => handler(msg)))
-        .catch((err) => {
-          console.error(`[WsBridge] Handler error on ${chatId}:`, err)
-        })
-      this.handlerChains.set(chatId, next)
-    })
-
-    ws.on('close', (code, reason) => {
-      console.log(`[WsBridge] Disconnected: ${sessionId} (${code}: ${reason})`)
-      if (code === 1000) return
-      this.scheduleReconnect(chatId, sessionId)
-    })
-
-    ws.on('error', (err) => {
-      console.error(`[WsBridge] Error on ${sessionId}:`, err.message)
-    })
-  }
-
-  /** Wait until the WebSocket for chatId is open. Resolves false on timeout or error. */
-  waitForOpen(chatId: string, timeoutMs = 10_000): Promise<boolean> {
-    const session = this.sessions.get(chatId)
-    if (!session) return Promise.resolve(false)
-    if (session.ws.readyState === WebSocket.OPEN) return Promise.resolve(true)
-    return new Promise((resolve) => {
-      const timer = setTimeout(() => {
-        cleanup()
-        resolve(false)
-      }, timeoutMs)
-      const onOpen = () => { cleanup(); resolve(true) }
-      const onError = () => { cleanup(); resolve(false) }
-      const onClose = () => { cleanup(); resolve(false) }
-      const cleanup = () => {
-        clearTimeout(timer)
-        session.ws.removeListener('open', onOpen)
-        session.ws.removeListener('error', onError)
-        session.ws.removeListener('close', onClose)
-      }
-      session.ws.once('open', onOpen)
-      session.ws.once('error', onError)
-      session.ws.once('close', onClose)
-    })
-  }
-
-  private send(chatId: string, message: Record<string, unknown>): boolean {
-    const session = this.sessions.get(chatId)
-    if (!session || session.ws.readyState !== WebSocket.OPEN) {
-      console.warn(`[WsBridge] Cannot send to ${chatId}: session not ready`)
-      return false
-    }
-    session.ws.send(JSON.stringify(message))
-    return true
-  }
-
-  private scheduleReconnect(chatId: string, sessionId: string): void {
-    if (this.destroyed) return
-    const session = this.sessions.get(chatId)
-    if (!session) return
-    if (session.reconnectAttempts >= MAX_RECONNECT_ATTEMPTS) {
-      console.error(`[WsBridge] Max reconnect attempts reached for ${sessionId}, giving up`)
-      this.sessions.delete(chatId)
-      this.handlers.delete(chatId)
-      return
-    }
-
-    session.reconnectAttempts++
-    const delay = Math.min(
-      RECONNECT_BASE_MS * Math.pow(2, session.reconnectAttempts - 1),
-      RECONNECT_MAX_MS,
-    )
-    console.log(`[WsBridge] Reconnecting ${sessionId} in ${delay}ms (attempt ${session.reconnectAttempts}/${MAX_RECONNECT_ATTEMPTS})`)
-    session.reconnectTimer = setTimeout(() => {
-      if (this.destroyed) return
-      if (this.sessions.get(chatId)?.sessionId === sessionId) {
-        this.connect(chatId, sessionId)
-      }
-    }, delay)
-  }
-
-  private startHeartbeat(): void {
-    this.heartbeatTimer = setInterval(() => {
-      for (const [, session] of this.sessions) {
-        if (session.ws.readyState === WebSocket.OPEN) {
-          session.ws.send(JSON.stringify({ type: 'ping' }))
-        }
-      }
-    }, HEARTBEAT_INTERVAL_MS)
-  }
-}

package/adapters/feishu/__tests__/card-errors.test.ts

@@ -1,194 +0,0 @@
-/**
- * card-errors 单元测试
- */
-
-import { describe, it, expect } from 'bun:test'
-import {
-  CARD_ERROR,
-  CARD_CONTENT_SUB_ERROR,
-  extractLarkApiCode,
-  extractSubCode,
-  parseCardApiError,
-  isCardRateLimitError,
-  isCardTableLimitError,
-} from '../card-errors.js'
-
-describe('extractLarkApiCode', () => {
-  it('从 err.code 直接提取', () => {
-    expect(extractLarkApiCode({ code: 230020 })).toBe(230020)
-  })
-
-  it('从 err.data.code 提取', () => {
-    expect(extractLarkApiCode({ data: { code: 230099 } })).toBe(230099)
-  })
-
-  it('从 err.response.data.code 提取（Axios 风格）', () => {
-    expect(extractLarkApiCode({ response: { data: { code: 99991672 } } })).toBe(99991672)
-  })
-
-  it('数字字符串被强制转成 number', () => {
-    expect(extractLarkApiCode({ code: '230020' })).toBe(230020)
-  })
-
-  it('三层结构优先级: err.code > err.data.code > err.response.data.code', () => {
-    const err = {
-      code: 1,
-      data: { code: 2 },
-      response: { data: { code: 3 } },
-    }
-    expect(extractLarkApiCode(err)).toBe(1)
-  })
-
-  it('none → undefined', () => {
-    expect(extractLarkApiCode({})).toBeUndefined()
-    expect(extractLarkApiCode(null)).toBeUndefined()
-    expect(extractLarkApiCode(undefined)).toBeUndefined()
-    expect(extractLarkApiCode('just a string')).toBeUndefined()
-    expect(extractLarkApiCode(new Error('plain'))).toBeUndefined()
-  })
-
-  it('非有限数字被忽略', () => {
-    expect(extractLarkApiCode({ code: NaN })).toBeUndefined()
-    expect(extractLarkApiCode({ code: 'not-a-number' })).toBeUndefined()
-  })
-})
-
-describe('extractSubCode', () => {
-  it('识别标准的 ErrCode: 11310', () => {
-    const msg = 'Failed to create card content, ext=ErrCode: 11310; ErrMsg: card table number over limit'
-    expect(extractSubCode(msg)).toBe(11310)
-  })
-
-  it('无 ErrCode 时返回 null', () => {
-    expect(extractSubCode('random error message')).toBeNull()
-    expect(extractSubCode('')).toBeNull()
-  })
-
-  it('ErrCode 大小写容错（冒号后多空格）', () => {
-    expect(extractSubCode('ErrCode:  42')).toBe(42)
-  })
-})
-
-describe('parseCardApiError', () => {
-  it('从 SDK 风格错误提取完整结构', () => {
-    const err = { code: 230099, msg: 'ErrCode: 11310; ErrMsg: card table number over limit' }
-    const parsed = parseCardApiError(err)
-    expect(parsed).toEqual({
-      code: 230099,
-      subCode: 11310,
-      errMsg: 'ErrCode: 11310; ErrMsg: card table number over limit',
-    })
-  })
-
-  it('从 Axios 风格错误（response.data.msg）提取', () => {
-    const err = {
-      response: {
-        data: {
-          code: 230020,
-          msg: 'rate limited',
-        },
-      },
-    }
-    const parsed = parseCardApiError(err)
-    expect(parsed?.code).toBe(230020)
-    expect(parsed?.errMsg).toBe('rate limited')
-    expect(parsed?.subCode).toBeNull()
-  })
-
-  it('无 code 时返回 null', () => {
-    expect(parseCardApiError({})).toBeNull()
-    expect(parseCardApiError(null)).toBeNull()
-    expect(parseCardApiError('string')).toBeNull()
-  })
-
-  it('有 code 无 msg 时 errMsg 为空字符串', () => {
-    const parsed = parseCardApiError({ code: 230020 })
-    expect(parsed).toEqual({ code: 230020, subCode: null, errMsg: '' })
-  })
-
-  it('fallback 到 err.message', () => {
-    const err = Object.assign(new Error('fallback text'), { code: 230099 })
-    const parsed = parseCardApiError(err)
-    expect(parsed?.errMsg).toBe('fallback text')
-  })
-})
-
-describe('isCardRateLimitError', () => {
-  it('识别 230020', () => {
-    expect(isCardRateLimitError({ code: 230020 })).toBe(true)
-  })
-
-  it('识别 Axios 风格 230020', () => {
-    expect(isCardRateLimitError({ response: { data: { code: 230020 } } })).toBe(true)
-  })
-
-  it('不匹配其他 code', () => {
-    expect(isCardRateLimitError({ code: 230099 })).toBe(false)
-    expect(isCardRateLimitError({ code: 99991672 })).toBe(false)
-  })
-
-  it('非错误对象返回 false', () => {
-    expect(isCardRateLimitError(null)).toBe(false)
-    expect(isCardRateLimitError({})).toBe(false)
-    expect(isCardRateLimitError(new Error('random'))).toBe(false)
-  })
-})
-
-describe('isCardTableLimitError', () => {
-  const validMsg = 'Failed to create card content, ext=ErrCode: 11310; ErrMsg: card table number over limit; ErrorValue: table; '
-
-  it('严格三条件匹配: code=230099 + subCode=11310 + msg 含 table number over limit', () => {
-    const err = { code: CARD_ERROR.CARD_CONTENT_FAILED, msg: validMsg }
-    expect(isCardTableLimitError(err)).toBe(true)
-  })
-
-  it('从 Axios 风格的 response.data 匹配', () => {
-    const err = {
-      response: {
-        data: {
-          code: 230099,
-          msg: validMsg,
-        },
-      },
-    }
-    expect(isCardTableLimitError(err)).toBe(true)
-  })
-
-  it('230099 + 11310 但没有 "table number over limit" 字样 → false（其它元素超限）', () => {
-    const err = {
-      code: CARD_ERROR.CARD_CONTENT_FAILED,
-      msg: 'ErrCode: 11310; ErrMsg: some other element limit; ',
-    }
-    expect(isCardTableLimitError(err)).toBe(false)
-  })
-
-  it('code 不是 230099 → false', () => {
-    const err = { code: 230020, msg: validMsg }
-    expect(isCardTableLimitError(err)).toBe(false)
-  })
-
-  it('没有 subCode → false', () => {
-    const err = { code: 230099, msg: 'card table number over limit (no ErrCode)' }
-    expect(isCardTableLimitError(err)).toBe(false)
-  })
-
-  it('不区分 "table number" 的大小写', () => {
-    const err = {
-      code: 230099,
-      msg: 'ErrCode: 11310; ErrMsg: CARD TABLE NUMBER OVER LIMIT; ',
-    }
-    expect(isCardTableLimitError(err)).toBe(true)
-  })
-})
-
-describe('常量值', () => {
-  it('CARD_ERROR.RATE_LIMITED === 230020', () => {
-    expect(CARD_ERROR.RATE_LIMITED).toBe(230020)
-  })
-  it('CARD_ERROR.CARD_CONTENT_FAILED === 230099', () => {
-    expect(CARD_ERROR.CARD_CONTENT_FAILED).toBe(230099)
-  })
-  it('CARD_CONTENT_SUB_ERROR.ELEMENT_LIMIT === 11310', () => {
-    expect(CARD_CONTENT_SUB_ERROR.ELEMENT_LIMIT).toBe(11310)
-  })
-})