bingocode 1.0.41 → 1.1.42

package/adapters/common/attachment/image-block-watcher.ts

@@ -1,94 +0,0 @@
-/**
- * Pure, stateful extractor that watches a stream of assistant text for
- * markdown image references (`![alt](source)`) and emits PendingUpload
- * records. Used by IM adapters to know which images to upload to IM.
- *
- * - Buffers input so an image marker split across multiple feed() calls
- *   still gets detected.
- * - Dedups by fingerprint of the source so the same image is only emitted
- *   once per watcher lifetime.
- */
-
-import type { PendingUpload } from './attachment-types.js'
-
-// Matches a complete markdown image: ![alt](target)
-// `alt` may be empty; `target` stops at the first closing paren.
-const IMAGE_RE = /!\[([^\]]*)\]\(([^)\s]+)\)/g
-
-function fingerprint(raw: string): string {
-  let h = 5381
-  for (let i = 0; i < raw.length; i++) {
-    h = ((h << 5) + h) ^ raw.charCodeAt(i)
-  }
-  return (h >>> 0).toString(16)
-}
-
-function classify(target: string): PendingUpload['source'] | null {
-  if (target.startsWith('data:')) {
-    const m = /^data:([^;,]+);base64,(.+)$/.exec(target)
-    if (!m) return null
-    return { kind: 'base64', mime: m[1]!, data: m[2]! }
-  }
-  if (target.startsWith('file://')) {
-    return { kind: 'path', path: target.slice('file://'.length) }
-  }
-  if (target.startsWith('http://') || target.startsWith('https://')) {
-    return { kind: 'url', url: target }
-  }
-  if (target.startsWith('/')) {
-    return { kind: 'path', path: target }
-  }
-  return null // relative paths — skip, we can't resolve them safely
-}
-
-export class ImageBlockWatcher {
-  private buffer = ''
-  private seen = new Set<string>()
-  private accumulated: PendingUpload[] = []
-
-  /** Feed a new chunk of streaming text; returns any NEW PendingUploads. */
-  feed(chunk: string): PendingUpload[] {
-    this.buffer += chunk
-    const out: PendingUpload[] = []
-
-    IMAGE_RE.lastIndex = 0
-    let lastConsumedEnd = 0
-    let m: RegExpExecArray | null
-    while ((m = IMAGE_RE.exec(this.buffer)) !== null) {
-      const [, alt, target] = m
-      const source = classify(target!)
-      if (source) {
-        const id = fingerprint(`${source.kind}:${target}`)
-        if (!this.seen.has(id)) {
-          this.seen.add(id)
-          const pending: PendingUpload = { id, source, alt: alt || undefined }
-          out.push(pending)
-          this.accumulated.push(pending)
-        }
-      }
-      lastConsumedEnd = m.index + m[0].length
-    }
-
-    // Preserve tail that might contain a partially-received marker.
-    if (lastConsumedEnd > 0) {
-      this.buffer = this.buffer.slice(lastConsumedEnd)
-    }
-    if (this.buffer.length > 4096) {
-      this.buffer = this.buffer.slice(-2048)
-    }
-
-    return out
-  }
-
-  /** Return everything seen so far (for end-of-stream reconciliation). */
-  drain(): PendingUpload[] {
-    return [...this.accumulated]
-  }
-
-  /** Reset watcher state (use at /clear or new session). */
-  reset(): void {
-    this.buffer = ''
-    this.seen.clear()
-    this.accumulated = []
-  }
-}

package/adapters/common/chat-queue.ts

@@ -1,24 +0,0 @@
-/**
- * 会话串行队列
- *
- * 同一 chatId 的消息串行处理，防并发冲突。
- * 不同 chatId 之间互不影响。
- * 参考 openclaw-lark chat-queue.ts 的 Promise 链设计。
- */
-
-const queues = new Map<string, Promise<void>>()
-
-export async function enqueue(chatId: string, fn: () => Promise<void>): Promise<void> {
-  const prev = queues.get(chatId) ?? Promise.resolve()
-  const next = prev.then(fn, () => fn()).catch((err) => {
-    console.error(`[ChatQueue] Error in task for chat ${chatId}:`, err)
-  })
-  queues.set(chatId, next)
-  // Clean up after completion to avoid memory leak for one-off chats
-  next.finally(() => {
-    if (queues.get(chatId) === next) {
-      queues.delete(chatId)
-    }
-  })
-  return next
-}

package/adapters/common/config.ts

@@ -1,96 +0,0 @@
-/**
- * Adapter 配置加载
- *
- * 优先级：环境变量 > ~/.claude/adapters.json > 默认值
- */
-
-import * as fs from 'node:fs'
-import * as os from 'node:os'
-import * as path from 'node:path'
-
-export type PairedUser = {
-  userId: string | number
-  displayName: string
-  pairedAt: number
-}
-
-export type PairingState = {
-  code: string | null
-  expiresAt: number | null
-  createdAt: number | null
-}
-
-export type TelegramConfig = {
-  botToken: string
-  allowedUsers: number[]
-  pairedUsers: PairedUser[]
-  defaultWorkDir: string
-}
-
-export type FeishuConfig = {
-  appId: string
-  appSecret: string
-  encryptKey: string
-  verificationToken: string
-  allowedUsers: string[]
-  pairedUsers: PairedUser[]
-  defaultWorkDir: string
-  streamingCard: boolean
-}
-
-export type AdapterConfig = {
-  serverUrl: string
-  defaultProjectDir: string
-  pairing: PairingState
-  telegram: TelegramConfig
-  feishu: FeishuConfig
-}
-
-function getConfigPath(): string {
-  const configDir = process.env.CLAUDE_CONFIG_DIR || path.join(os.homedir(), '.claude')
-  return path.join(configDir, 'adapters.json')
-}
-
-function loadFile(): Record<string, any> {
-  try {
-    return JSON.parse(fs.readFileSync(getConfigPath(), 'utf-8'))
-  } catch (err: any) {
-    if (err?.code !== 'ENOENT') {
-      console.warn(`[Config] Failed to parse ${getConfigPath()}, using defaults`)
-    }
-    return {}
-  }
-}
-
-export function loadConfig(): AdapterConfig {
-  const file = loadFile()
-  const tg = file.telegram ?? {}
-  const fs_ = file.feishu ?? {}
-  const pairing = file.pairing ?? {}
-
-  return {
-    serverUrl: process.env.ADAPTER_SERVER_URL || file.serverUrl || 'ws://127.0.0.1:3456',
-    defaultProjectDir: file.defaultProjectDir || '',
-    pairing: {
-      code: pairing.code ?? null,
-      expiresAt: pairing.expiresAt ?? null,
-      createdAt: pairing.createdAt ?? null,
-    },
-    telegram: {
-      botToken: process.env.TELEGRAM_BOT_TOKEN || tg.botToken || '',
-      allowedUsers: tg.allowedUsers ?? [],
-      pairedUsers: tg.pairedUsers ?? [],
-      defaultWorkDir: tg.defaultWorkDir || process.cwd(),
-    },
-    feishu: {
-      appId: process.env.FEISHU_APP_ID || fs_.appId || '',
-      appSecret: process.env.FEISHU_APP_SECRET || fs_.appSecret || '',
-      encryptKey: process.env.FEISHU_ENCRYPT_KEY || fs_.encryptKey || '',
-      verificationToken: process.env.FEISHU_VERIFICATION_TOKEN || fs_.verificationToken || '',
-      allowedUsers: fs_.allowedUsers ?? [],
-      pairedUsers: fs_.pairedUsers ?? [],
-      defaultWorkDir: fs_.defaultWorkDir || process.cwd(),
-      streamingCard: fs_.streamingCard ?? false,
-    },
-  }
-}

package/adapters/common/format.ts

@@ -1,229 +0,0 @@
-/**
- * 消息格式化工具
- */
-
-type AdapterChatState =
-  | 'idle'
-  | 'thinking'
-  | 'streaming'
-  | 'tool_executing'
-  | 'permission_pending'
-
-type ImStatusSummary = {
-  sessionId?: string
-  projectName?: string | null
-  branch?: string | null
-  model?: string | null
-  state?: AdapterChatState | null
-  verb?: string | null
-  pendingPermissionCount?: number
-  taskCounts?: {
-    total: number
-    pending: number
-    inProgress: number
-    completed: number
-  }
-}
-
-const IM_HELP_LINES = [
-  '/new [项目] — 新建会话或切换项目',
-  '/projects — 查看最近项目',
-  '/status — 查看当前会话状态',
-  '/clear — 清空当前会话上下文',
-  '/stop — 停止当前生成',
-  '/help — 显示这份帮助',
-]
-
-/** Split text into chunks that fit within a character limit, respecting paragraph/sentence boundaries. */
-export function splitMessage(text: string, limit: number): string[] {
-  if (text.length <= limit) return [text]
-
-  const chunks: string[] = []
-  let remaining = text
-
-  while (remaining.length > 0) {
-    if (remaining.length <= limit) {
-      chunks.push(remaining)
-      break
-    }
-
-    let splitAt = remaining.lastIndexOf('\n\n', limit)
-    if (splitAt <= 0) splitAt = remaining.lastIndexOf('\n', limit)
-    if (splitAt <= 0) splitAt = remaining.lastIndexOf('. ', limit)
-    if (splitAt <= 0) splitAt = remaining.lastIndexOf(' ', limit)
-    if (splitAt <= 0) splitAt = limit
-
-    // Include the delimiter for paragraph/sentence breaks
-    if (remaining[splitAt] === '\n' || remaining[splitAt] === '.') splitAt += 1
-
-    chunks.push(remaining.slice(0, splitAt).trimEnd())
-    remaining = remaining.slice(splitAt).trimStart()
-  }
-
-  return chunks
-}
-
-/** Format tool use info for display in IM. */
-export function formatToolUse(toolName: string, input: unknown): string {
-  const inp = (input && typeof input === 'object' ? input : {}) as Record<string, unknown>
-  const summary = formatToolSummary(toolName, inp)
-  if (summary) return `🔧 ${toolName}  ${summary}`
-  const preview = truncateInput(input, 200)
-  return `🔧 ${toolName}\n${preview}`
-}
-
-/** Generate a concise human-readable summary for common tools. */
-function formatToolSummary(tool: string, inp: Record<string, unknown>): string | null {
-  switch (tool) {
-    case 'Bash': {
-      const desc = inp.description as string | undefined
-      const cmd = inp.command as string | undefined
-      if (desc) return desc
-      if (cmd) return truncate(cmd, 120)
-      return null
-    }
-    case 'Read': {
-      const fp = inp.file_path as string | undefined
-      if (fp) return shortPath(fp)
-      return null
-    }
-    case 'Edit': {
-      const fp = inp.file_path as string | undefined
-      if (fp) return shortPath(fp)
-      return null
-    }
-    case 'Write': {
-      const fp = inp.file_path as string | undefined
-      if (fp) return shortPath(fp)
-      return null
-    }
-    case 'Grep': {
-      const pat = inp.pattern as string | undefined
-      const p = inp.path as string | undefined
-      if (pat) return `"${truncate(pat, 60)}"` + (p ? ` in ${shortPath(p)}` : '')
-      return null
-    }
-    case 'Glob': {
-      const pat = inp.pattern as string | undefined
-      return pat ? `"${pat}"` : null
-    }
-    case 'Skill': {
-      const skill = inp.skill as string | undefined
-      return skill || null
-    }
-    case 'Agent': {
-      const desc = inp.description as string | undefined
-      return desc || null
-    }
-    case 'WebFetch': {
-      const url = inp.url as string | undefined
-      return url ? truncate(url, 120) : null
-    }
-    case 'WebSearch': {
-      const q = inp.query as string | undefined
-      return q ? `"${truncate(q, 80)}"` : null
-    }
-    default:
-      return null
-  }
-}
-
-function shortPath(fp: string): string {
-  const parts = fp.split('/')
-  return parts.length > 3 ? '…/' + parts.slice(-3).join('/') : fp
-}
-
-function truncate(s: string, max: number): string {
-  return s.length > max ? s.slice(0, max) + '…' : s
-}
-
-/** Format a permission request for display in IM. */
-export function formatPermissionRequest(toolName: string, input: unknown, requestId: string): string {
-  const preview = truncateInput(input, 300)
-  return `🔐 需要权限确认 [${requestId}]\n工具: ${toolName}\n${preview}`
-}
-
-/** Truncate tool input to a preview string. */
-export function truncateInput(input: unknown, maxLen: number): string {
-  try {
-    const s = typeof input === 'string' ? input : JSON.stringify(input, null, 2)
-    return s.length > maxLen ? s.slice(0, maxLen) + '…' : s
-  } catch {
-    return '(unserializable)'
-  }
-}
-
-/** Escape special characters for Telegram MarkdownV2. */
-export function escapeMarkdownV2(text: string): string {
-  return text.replace(/([_*\[\]()~`>#+\-=|{}.!\\])/g, '\\$1')
-}
-
-export function formatImHelp(): string {
-  return `可用命令：\n\n${IM_HELP_LINES.join('\n')}`
-}
-
-export function formatImStatus(summary: ImStatusSummary | null): string {
-  if (!summary?.sessionId) {
-    return '当前没有活动会话。\n\n发送 /new 新建会话，或发送 /projects 选择项目。'
-  }
-
-  const lines = ['当前会话状态：']
-
-  if (summary.projectName) {
-    lines.push(`项目: ${summary.projectName}${summary.branch ? ` (${summary.branch})` : ''}`)
-  } else if (summary.branch) {
-    lines.push(`分支: ${summary.branch}`)
-  }
-
-  lines.push(`会话: ${shortSessionId(summary.sessionId)}`)
-
-  if (summary.model) {
-    lines.push(`模型: ${summary.model}`)
-  }
-
-  lines.push(`状态: ${formatAdapterChatState(summary.state, summary.verb)}`)
-
-  const pendingPermissionCount = summary.pendingPermissionCount ?? 0
-  if (pendingPermissionCount > 0) {
-    lines.push(`审批: ${pendingPermissionCount} 个待确认`)
-  }
-
-  const taskCounts = summary.taskCounts
-  if (taskCounts && taskCounts.total > 0) {
-    const taskParts = [`总计 ${taskCounts.total}`]
-    if (taskCounts.inProgress > 0) taskParts.push(`进行中 ${taskCounts.inProgress}`)
-    if (taskCounts.pending > 0) taskParts.push(`待处理 ${taskCounts.pending}`)
-    if (taskCounts.completed > 0) taskParts.push(`已完成 ${taskCounts.completed}`)
-    lines.push(`任务: ${taskParts.join(' · ')}`)
-  }
-
-  return lines.join('\n')
-}
-
-function formatAdapterChatState(
-  state: AdapterChatState | null | undefined,
-  verb: string | null | undefined,
-): string {
-  const label = (() => {
-    switch (state) {
-      case 'thinking':
-        return '思考中'
-      case 'streaming':
-        return '生成中'
-      case 'tool_executing':
-        return '执行工具中'
-      case 'permission_pending':
-        return '等待权限确认'
-      case 'idle':
-      default:
-        return '空闲'
-    }
-  })()
-
-  if (!verb || verb === 'Thinking') return label
-  return `${label} (${verb})`
-}
-
-function shortSessionId(sessionId: string): string {
-  return sessionId.length > 12 ? `${sessionId.slice(0, 8)}…` : sessionId
-}

package/adapters/common/http-client.ts

@@ -1,107 +0,0 @@
-export type RecentProject = {
-  projectPath: string
-  realPath: string
-  projectName: string
-  isGit: boolean
-  repoName: string | null
-  branch: string | null
-  modifiedAt: string
-  sessionCount: number
-}
-
-export type GitInfo = {
-  branch: string | null
-  repoName: string | null
-  workDir: string
-  changedFiles: number
-}
-
-export type SessionTask = {
-  id: string
-  subject: string
-  status: 'pending' | 'in_progress' | 'completed'
-}
-
-export class AdapterHttpClient {
-  readonly httpBaseUrl: string
-
-  constructor(wsUrl: string) {
-    this.httpBaseUrl = wsUrl
-      .replace(/^ws:/, 'http:')
-      .replace(/^wss:/, 'https:')
-      .replace(/\/$/, '')
-  }
-
-  async createSession(workDir: string): Promise<string> {
-    const res = await fetch(`${this.httpBaseUrl}/api/sessions`, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ workDir }),
-    })
-    if (!res.ok) {
-      const err = await res.json().catch(() => ({ message: res.statusText }))
-      throw new Error(`Failed to create session: ${(err as any).message}`)
-    }
-    const data = (await res.json()) as { sessionId: string }
-    return data.sessionId
-  }
-
-  async listRecentProjects(): Promise<RecentProject[]> {
-    const res = await fetch(`${this.httpBaseUrl}/api/sessions/recent-projects`)
-    if (!res.ok) {
-      throw new Error(`Failed to list projects: ${res.statusText}`)
-    }
-    const data = (await res.json()) as { projects: RecentProject[] }
-    return data.projects
-  }
-
-  /**
-   * Match a project by index (1-based) or fuzzy name from recent projects.
-   * Returns { project, ambiguous[] } — ambiguous is set when multiple projects match.
-   */
-  async matchProject(query: string): Promise<{ project?: RecentProject; ambiguous?: RecentProject[] }> {
-    const projects = await this.listRecentProjects()
-
-    // Try as 1-based index
-    const num = parseInt(query, 10)
-    if (!isNaN(num) && num >= 1 && num <= projects.length && String(num) === query.trim()) {
-      return { project: projects[num - 1] }
-    }
-
-    const q = query.toLowerCase()
-
-    // Exact project name match
-    const exact = projects.find(p => p.projectName.toLowerCase() === q)
-    if (exact) return { project: exact }
-
-    // Fuzzy: name or path contains query
-    const matches = projects.filter(p =>
-      p.projectName.toLowerCase().includes(q) ||
-      p.realPath.toLowerCase().includes(q)
-    )
-    if (matches.length === 1) return { project: matches[0] }
-    if (matches.length > 1) return { ambiguous: matches }
-
-    return {}
-  }
-
-  async getGitInfo(sessionId: string): Promise<GitInfo> {
-    const res = await fetch(`${this.httpBaseUrl}/api/sessions/${encodeURIComponent(sessionId)}/git-info`)
-    if (!res.ok) {
-      const err = await res.json().catch(() => ({ message: res.statusText }))
-      throw new Error(`Failed to load git info: ${(err as any).message}`)
-    }
-    return (await res.json()) as GitInfo
-  }
-
-  async getTasksForSession(sessionId: string): Promise<SessionTask[]> {
-    const res = await fetch(`${this.httpBaseUrl}/api/tasks/lists/${encodeURIComponent(sessionId)}`)
-    if (!res.ok) {
-      if (res.status === 404) return []
-      const err = await res.json().catch(() => ({ message: res.statusText }))
-      throw new Error(`Failed to load tasks: ${(err as any).message}`)
-    }
-    const data = (await res.json()) as { tasks?: SessionTask[] }
-    return Array.isArray(data.tasks) ? data.tasks : []
-  }
-}

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