bingocode 1.0.40 → 1.1.42

package/adapters/common/message-buffer.ts

@@ -1,91 +0,0 @@
-/**
- * 流式消息缓冲
- *
- * 将 content_delta 累积后按时间窗口或字符数批量 flush。
- * 用于 Telegram editMessage / 飞书流式卡片更新。
- */
-
-export type FlushCallback = (text: string, isComplete: boolean) => void | Promise<void>
-
-const DEFAULT_INTERVAL_MS = 500
-const DEFAULT_CHAR_THRESHOLD = 200
-
-export class MessageBuffer {
-  private buffer = ''
-  private timer: ReturnType<typeof setTimeout> | null = null
-  private flushing = false
-  private pendingComplete = false
-
-  constructor(
-    private onFlush: FlushCallback,
-    private intervalMs = DEFAULT_INTERVAL_MS,
-    private charThreshold = DEFAULT_CHAR_THRESHOLD,
-  ) {}
-
-  /** Append text delta. Triggers flush if threshold reached. */
-  append(text: string): void {
-    this.buffer += text
-    if (this.buffer.length >= this.charThreshold) {
-      this.scheduleFlush()
-    } else if (!this.timer) {
-      this.timer = setTimeout(() => this.flush(false), this.intervalMs)
-    }
-  }
-
-  /** Immediately flush all remaining content (called on message_complete). */
-  async complete(): Promise<void> {
-    if (this.timer) {
-      clearTimeout(this.timer)
-      this.timer = null
-    }
-    if (this.flushing) {
-      // A flush is in-flight; mark pending so it fires after current flush finishes
-      this.pendingComplete = true
-      return
-    }
-    await this.flush(true)
-  }
-
-  /** Reset the buffer for a new message. */
-  reset(): void {
-    this.buffer = ''
-    this.pendingComplete = false
-    if (this.timer) {
-      clearTimeout(this.timer)
-      this.timer = null
-    }
-  }
-
-  private scheduleFlush(): void {
-    if (this.timer) {
-      clearTimeout(this.timer)
-      this.timer = null
-    }
-    queueMicrotask(() => this.flush(false))
-  }
-
-  private async flush(isComplete: boolean): Promise<void> {
-    if (this.timer) {
-      clearTimeout(this.timer)
-      this.timer = null
-    }
-    if (this.flushing) return
-    if (this.buffer.length === 0) return
-
-    this.flushing = true
-    const text = this.buffer
-    this.buffer = ''
-    try {
-      await this.onFlush(text, isComplete)
-    } catch (err) {
-      console.error('[MessageBuffer] Flush error:', err)
-    } finally {
-      this.flushing = false
-      // If complete() was called while we were flushing, do the final flush now
-      if (this.pendingComplete) {
-        this.pendingComplete = false
-        await this.flush(true)
-      }
-    }
-  }
-}

package/adapters/common/message-dedup.ts

@@ -1,57 +0,0 @@
-/**
- * 消息去重
- *
- * 防止 WebSocket 重连等场景下消息重复处理。
- * 参考 openclaw-lark dedup.ts 的 Map + TTL + 容量 设计。
- */
-
-const DEFAULT_TTL_MS = 10 * 60_000  // 10 minutes
-const DEFAULT_MAX_ENTRIES = 5000
-const SWEEP_INTERVAL_MS = 60_000    // 1 minute
-
-export class MessageDedup {
-  private store = new Map<string, number>()
-  private sweepTimer: ReturnType<typeof setInterval>
-
-  constructor(
-    private ttlMs = DEFAULT_TTL_MS,
-    private maxEntries = DEFAULT_MAX_ENTRIES,
-  ) {
-    this.sweepTimer = setInterval(() => this.sweep(), SWEEP_INTERVAL_MS)
-  }
-
-  /** Returns true if this is a NEW message, false if duplicate. */
-  tryRecord(id: string): boolean {
-    const now = Date.now()
-    const existing = this.store.get(id)
-
-    if (existing !== undefined && now - existing < this.ttlMs) {
-      return false // duplicate
-    }
-
-    // Evict oldest if at capacity
-    if (this.store.size >= this.maxEntries) {
-      const oldest = this.store.keys().next().value
-      if (oldest !== undefined) this.store.delete(oldest)
-    }
-
-    this.store.set(id, now)
-    return true
-  }
-
-  private sweep(): void {
-    const now = Date.now()
-    for (const [key, ts] of this.store) {
-      if (now - ts >= this.ttlMs) {
-        this.store.delete(key)
-      } else {
-        break // Map preserves insertion order; once fresh, rest is fresh
-      }
-    }
-  }
-
-  destroy(): void {
-    clearInterval(this.sweepTimer)
-    this.store.clear()
-  }
-}

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)
-  }
-}