bingocode 1.0.28 → 1.0.30

package/adapters/telegram/__tests__/media.test.ts

@@ -0,0 +1,86 @@
+import { describe, it, expect, beforeEach, afterEach, mock } from 'bun:test'
+import * as fs from 'node:fs/promises'
+import * as path from 'node:path'
+import * as os from 'node:os'
+import { TelegramMediaService } from '../media.js'
+import { AttachmentStore } from '../../common/attachment/attachment-store.js'
+
+let tmpRoot: string
+let originalFetch: typeof fetch
+
+function makeMockBot() {
+  const fetchMock = mock(async (url: string | URL) => {
+    const u = typeof url === 'string' ? url : url.toString()
+    expect(u).toContain('/file/botFAKE_TOKEN/photos/abc.jpg')
+    return new Response(Buffer.from('PHOTODATA'), {
+      status: 200,
+      headers: { 'content-type': 'image/jpeg' },
+    })
+  })
+  ;(globalThis as any).fetch = fetchMock
+  return {
+    token: 'FAKE_TOKEN',
+    api: {
+      getFile: mock(async (fileId: string) => ({
+        file_id: fileId,
+        file_unique_id: 'unique',
+        file_path: 'photos/abc.jpg',
+      })),
+      sendPhoto: mock(async () => ({ message_id: 1 })),
+      sendDocument: mock(async () => ({ message_id: 2 })),
+    },
+    fetchMock,
+  }
+}
+
+beforeEach(async () => {
+  originalFetch = globalThis.fetch
+  tmpRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'tg-media-test-'))
+})
+
+afterEach(async () => {
+  globalThis.fetch = originalFetch
+  await fs.rm(tmpRoot, { recursive: true, force: true })
+})
+
+describe('TelegramMediaService', () => {
+  it('downloadFile fetches the real URL and stores a LocalAttachment', async () => {
+    const bot = makeMockBot()
+    const store = new AttachmentStore({ root: tmpRoot, retentionMs: 60_000 })
+    const svc = new TelegramMediaService(bot as any, store)
+    const local = await svc.downloadFile('fid_123', 'sess-1', {
+      fileName: 'abc.jpg',
+      mimeType: 'image/jpeg',
+    })
+    expect(local.kind).toBe('image')
+    expect(local.name).toBe('abc.jpg')
+    expect(local.size).toBe('PHOTODATA'.length)
+    expect(local.buffer.toString()).toBe('PHOTODATA')
+    const onDisk = await fs.readFile(local.path)
+    expect(onDisk.toString()).toBe('PHOTODATA')
+  })
+
+  it('sendPhoto calls bot.api.sendPhoto with InputFile-like payload', async () => {
+    const bot = makeMockBot()
+    const store = new AttachmentStore({ root: tmpRoot, retentionMs: 60_000 })
+    const svc = new TelegramMediaService(bot as any, store)
+    await svc.sendPhoto(42, Buffer.from('IMG'), 'caption text')
+    expect(bot.api.sendPhoto).toHaveBeenCalledTimes(1)
+    const args = (bot.api.sendPhoto as any).mock.calls[0]
+    expect(args[0]).toBe(42)
+    // grammY InputFile wraps the buffer; just verify it's an object.
+    expect(args[1]).toBeDefined()
+    expect(args[2]?.caption).toBe('caption text')
+  })
+
+  it('sendDocument calls bot.api.sendDocument', async () => {
+    const bot = makeMockBot()
+    const store = new AttachmentStore({ root: tmpRoot, retentionMs: 60_000 })
+    const svc = new TelegramMediaService(bot as any, store)
+    await svc.sendDocument(42, Buffer.from('DOC'), 'spec.pdf')
+    expect(bot.api.sendDocument).toHaveBeenCalledTimes(1)
+    const args = (bot.api.sendDocument as any).mock.calls[0]
+    expect(args[0]).toBe(42)
+    expect(args[1]).toBeDefined()
+  })
+})

package/adapters/telegram/__tests__/telegram.test.ts

@@ -0,0 +1,115 @@
+import { describe, it, expect } from 'bun:test'
+import { splitMessage, formatPermissionRequest, truncateInput, escapeMarkdownV2 } from '../../common/format.js'
+
+/**
+ * Telegram Adapter 翻译逻辑测试
+ *
+ * 由于 grammy Bot 需要实际 Token 才能初始化，
+ * 这里测试的是不依赖 Bot 实例的核心翻译逻辑。
+ */
+
+describe('Telegram message formatting', () => {
+  describe('long message splitting', () => {
+    it('splits messages at Telegram 4096 char limit', () => {
+      const longText = 'a'.repeat(8000)
+      const chunks = splitMessage(longText, 4000)
+      expect(chunks.length).toBe(2)
+      expect(chunks[0]!.length).toBeLessThanOrEqual(4000)
+      expect(chunks[1]!.length).toBeLessThanOrEqual(4000)
+    })
+
+    it('keeps short messages as single chunk', () => {
+      const chunks = splitMessage('Hello World', 4000)
+      expect(chunks).toEqual(['Hello World'])
+    })
+
+    it('splits at paragraph boundary when possible', () => {
+      const text = 'A'.repeat(2000) + '\n\n' + 'B'.repeat(2000)
+      const chunks = splitMessage(text, 3000)
+      expect(chunks.length).toBe(2)
+    })
+  })
+
+  describe('permission request formatting', () => {
+    it('formats Bash command request', () => {
+      const result = formatPermissionRequest('Bash', { command: 'npm test' }, 'abcde')
+      expect(result).toContain('🔐')
+      expect(result).toContain('Bash')
+      expect(result).toContain('npm test')
+      expect(result).toContain('abcde')
+    })
+
+    it('formats Write file request', () => {
+      const result = formatPermissionRequest(
+        'Write',
+        { file_path: '/src/index.ts', content: 'console.log("hello")' },
+        'fghij',
+      )
+      expect(result).toContain('Write')
+      expect(result).toContain('index.ts')
+      expect(result).toContain('fghij')
+    })
+
+    it('truncates long input in permission request', () => {
+      const longInput = { command: 'x'.repeat(500) }
+      const result = formatPermissionRequest('Bash', longInput, 'xxxxx')
+      expect(result.length).toBeLessThan(600)
+    })
+  })
+
+  describe('callback_data parsing', () => {
+    it('parses permit:requestId:yes format', () => {
+      const data = 'permit:abcde:yes'
+      const parts = data.split(':')
+      expect(parts[0]).toBe('permit')
+      expect(parts[1]).toBe('abcde')
+      expect(parts[2]).toBe('yes')
+    })
+
+    it('parses permit:requestId:no format', () => {
+      const data = 'permit:abcde:no'
+      const parts = data.split(':')
+      expect(parts[2]).toBe('no')
+    })
+
+    it('ignores non-permit callbacks', () => {
+      const data = 'other:action'
+      expect(data.startsWith('permit:')).toBe(false)
+    })
+  })
+
+  describe('MarkdownV2 escaping', () => {
+    it('escapes underscores', () => {
+      expect(escapeMarkdownV2('hello_world')).toBe('hello\\_world')
+    })
+
+    it('escapes multiple special chars', () => {
+      const result = escapeMarkdownV2('file.ts (line 42)')
+      expect(result).toBe('file\\.ts \\(line 42\\)')
+    })
+
+    it('handles code blocks safely', () => {
+      const result = escapeMarkdownV2('`code`')
+      expect(result).toBe('\\`code\\`')
+    })
+  })
+
+  describe('whitelist logic', () => {
+    it('empty allowedUsers means allow all', () => {
+      const allowedUsers: number[] = []
+      const isAllowed = (userId: number) =>
+        allowedUsers.length === 0 || allowedUsers.includes(userId)
+      expect(isAllowed(12345)).toBe(true)
+      expect(isAllowed(99999)).toBe(true)
+    })
+
+    it('non-empty allowedUsers filters correctly', () => {
+      const allowedUsers = [111, 222]
+      const isAllowed = (userId: number) =>
+        allowedUsers.length === 0 || allowedUsers.includes(userId)
+      expect(isAllowed(111)).toBe(true)
+      expect(isAllowed(222)).toBe(true)
+      expect(isAllowed(333)).toBe(false)
+    })
+  })
+})

package/adapters/tsconfig.json

@@ -0,0 +1,18 @@
+{
+  "compilerOptions": {
+    "target": "ESNext",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "types": ["bun-types"],
+    "outDir": "dist",
+    "rootDir": ".",
+    "paths": {
+      "@server/*": ["../src/server/*"]
+    }
+  },
+  "include": ["**/*.ts"],
+  "exclude": ["node_modules", "dist"]
+}

package/bunfig.toml

@@ -0,0 +1 @@
+preload = ["./preload.ts"]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bingocode",
-  "version": "1.0.28",
+  "version": "1.0.30",
   "type": "module",
   "bin": {
     "claude": "bin/claude-win.cjs",

package/preload.ts

@@ -0,0 +1,30 @@
+// 优先用环境变量，其次从 package.json 读取真实版本号
+import { readFileSync } from 'fs'
+import { join } from 'path'
+let _pkgVersion = '1.0.0'
+try {
+  const _pkgPath = join(import.meta.dir, 'package.json')
+  const _pkg = JSON.parse(readFileSync(_pkgPath, 'utf-8')) as { version?: string }
+  if (_pkg.version) _pkgVersion = _pkg.version
+} catch { /* ignore */ }
+const version = process.env.CLAUDE_CODE_LOCAL_VERSION ?? _pkgVersion;
+const packageUrl = process.env.CLAUDE_CODE_LOCAL_PACKAGE_URL ?? 'claude-code-local';
+const buildTime = process.env.CLAUDE_CODE_LOCAL_BUILD_TIME ?? new Date().toISOString();
+
+process.env.CLAUDE_CODE_LOCAL_SKIP_REMOTE_PREFETCH ??= '1';
+
+Object.assign(globalThis, {
+  MACRO: {
+    VERSION: version,
+    PACKAGE_URL: packageUrl,
+    NATIVE_PACKAGE_URL: packageUrl,
+    BUILD_TIME: buildTime,
+    FEEDBACK_CHANNEL: 'local',
+    VERSION_CHANGELOG: '',
+    ISSUES_EXPLAINER: '',
+  },
+});
+// Switch to the current workspace
+if (process.env.CALLER_DIR) {
+  process.chdir(process.env.CALLER_DIR);
+}

package/scripts/count-app-loc.ts

@@ -0,0 +1,256 @@
+import { readdirSync, readFileSync, statSync } from 'node:fs'
+import { extname, join, relative, sep } from 'node:path'
+
+type Bucket = {
+  files: number
+  lines: number
+  nonBlankLines: number
+}
+
+type FileStat = Bucket & {
+  path: string
+  extension: string
+}
+
+const root = process.cwd()
+
+const targetRoots = ['adapters', 'desktop', 'runtime', 'src/server']
+
+const codeExtensions = new Set([
+  '.css',
+  '.cjs',
+  '.html',
+  '.js',
+  '.jsx',
+  '.mjs',
+  '.nsh',
+  '.ps1',
+  '.py',
+  '.rs',
+  '.sh',
+  '.ts',
+  '.tsx',
+])
+
+const excludedDirectoryNames = new Set([
+  '.cache',
+  '.git',
+  '.next',
+  '.nuxt',
+  '.omx',
+  '.parcel-cache',
+  '.svelte-kit',
+  '.tauri',
+  '.turbo',
+  '.vite',
+  '.vite-temp',
+  '__pycache__',
+  'build',
+  'build-artifacts',
+  'coverage',
+  'dist',
+  'node_modules',
+  'out',
+  'target',
+])
+
+const excludedRelativePaths = new Set([
+  'desktop/src-tauri/binaries',
+  'desktop/src-tauri/icons',
+])
+
+const files: FileStat[] = []
+
+function emptyBucket(): Bucket {
+  return {
+    files: 0,
+    lines: 0,
+    nonBlankLines: 0,
+  }
+}
+
+function addToBucket(bucket: Bucket, file: FileStat) {
+  bucket.files += file.files
+  bucket.lines += file.lines
+  bucket.nonBlankLines += file.nonBlankLines
+}
+
+function shouldSkipDirectory(path: string) {
+  const name = path.split(sep).at(-1)
+  const normalized = relative(root, path).split(sep).join('/')
+
+  return (
+    Boolean(name && excludedDirectoryNames.has(name)) ||
+    excludedRelativePaths.has(normalized)
+  )
+}
+
+function countFile(path: string): FileStat | null {
+  const extension = extname(path)
+
+  if (!codeExtensions.has(extension)) {
+    return null
+  }
+
+  const content = readFileSync(path, 'utf8')
+  const newlineCount = content.match(/\r\n|\r|\n/g)?.length ?? 0
+  const lines =
+    content.length === 0 || content.endsWith('\n') || content.endsWith('\r')
+      ? newlineCount
+      : newlineCount + 1
+  const nonBlankLines = content
+    .split(/\r\n|\r|\n/)
+    .filter((line) => line.trim().length > 0).length
+
+  return {
+    files: 1,
+    lines,
+    nonBlankLines,
+    path: relative(root, path).split(sep).join('/'),
+    extension,
+  }
+}
+
+function walk(path: string) {
+  const stat = statSync(path)
+
+  if (stat.isDirectory()) {
+    if (shouldSkipDirectory(path)) {
+      return
+    }
+
+    for (const entry of readdirSync(path)) {
+      walk(join(path, entry))
+    }
+
+    return
+  }
+
+  if (!stat.isFile()) {
+    return
+  }
+
+  const result = countFile(path)
+  if (result) {
+    files.push(result)
+  }
+}
+
+function formatNumber(value: number) {
+  return value.toLocaleString('en-US')
+}
+
+function printTable(
+  title: string,
+  rows: Array<{ name: string } & Bucket>,
+  nameHeader = 'Group',
+) {
+  console.log(`\n${title}`)
+  console.log(`${nameHeader.padEnd(28)} ${'Files'.padStart(7)} ${'Lines'.padStart(9)} ${'Nonblank'.padStart(9)}`)
+  console.log(`${'-'.repeat(28)} ${'-'.repeat(7)} ${'-'.repeat(9)} ${'-'.repeat(9)}`)
+
+  for (const row of rows) {
+    console.log(
+      `${row.name.padEnd(28)} ${formatNumber(row.files).padStart(7)} ${formatNumber(row.lines).padStart(9)} ${formatNumber(row.nonBlankLines).padStart(9)}`,
+    )
+  }
+}
+
+function groupBy<T extends string>(getKey: (file: FileStat) => T) {
+  const result = new Map<T, Bucket>()
+
+  for (const file of files) {
+    const key = getKey(file)
+    const bucket = result.get(key) ?? emptyBucket()
+    addToBucket(bucket, file)
+    result.set(key, bucket)
+  }
+
+  return [...result.entries()]
+    .map(([name, bucket]) => ({ name, ...bucket }))
+    .sort((left, right) => right.lines - left.lines)
+}
+
+function areaForPath(path: string) {
+  if (path.startsWith('src/server/')) {
+    return 'server'
+  }
+
+  if (path.startsWith('desktop/src/')) {
+    return 'desktop frontend'
+  }
+
+  if (path.startsWith('desktop/src-tauri/')) {
+    return 'desktop tauri'
+  }
+
+  if (path.startsWith('desktop/')) {
+    return 'desktop support'
+  }
+
+  if (path.startsWith('adapters/')) {
+    return 'adapters'
+  }
+
+  if (path.startsWith('runtime/')) {
+    return 'runtime'
+  }
+
+  return 'other'
+}
+
+function purposeForPath(path: string) {
+  const fileName = path.split('/').at(-1) ?? ''
+
+  if (
+    path.includes('/__tests__/') ||
+    path.includes('/fixtures/') ||
+    fileName.startsWith('test_') ||
+    /\.test\.[cm]?[jt]sx?$/.test(path) ||
+    /\.spec\.[cm]?[jt]sx?$/.test(path)
+  ) {
+    return 'tests and fixtures'
+  }
+
+  return 'product source'
+}
+
+for (const targetRoot of targetRoots) {
+  walk(join(root, targetRoot))
+}
+
+const total = emptyBucket()
+for (const file of files) {
+  addToBucket(total, file)
+}
+
+const sortedByPath = [...files].sort((left, right) =>
+  left.path.localeCompare(right.path),
+)
+
+console.log('Desktop app source line count')
+console.log('')
+console.log(`Targets: ${targetRoots.join(', ')}`)
+console.log(`Included extensions: ${[...codeExtensions].sort().join(', ')}`)
+console.log(
+  `Excluded directories: ${[...excludedDirectoryNames].sort().join(', ')}`,
+)
+console.log(`Excluded paths: ${[...excludedRelativePaths].sort().join(', ')}`)
+
+printTable('By area', groupBy((file) => areaForPath(file.path)))
+printTable('By purpose', groupBy((file) => purposeForPath(file.path)))
+printTable('By top-level target', groupBy((file) => file.path.split('/')[0]))
+printTable('By extension', groupBy((file) => file.extension), 'Extension')
+
+console.log('\nTotal')
+console.log(`Files: ${formatNumber(total.files)}`)
+console.log(`Lines: ${formatNumber(total.lines)}`)
+console.log(`Nonblank lines: ${formatNumber(total.nonBlankLines)}`)
+
+if (process.argv.includes('--files')) {
+  printTable(
+    'By file',
+    sortedByPath.map((file) => ({ name: file.path, ...file })),
+    'File',
+  )
+}

package/scripts/release.ts

@@ -0,0 +1,130 @@
+#!/usr/bin/env bun
+/**
+ * Release script for Claude Code Haha Desktop
+ *
+ * Usage:
+ *   bun run scripts/release.ts patch       # 0.1.0 → 0.1.1
+ *   bun run scripts/release.ts minor       # 0.1.0 → 0.2.0
+ *   bun run scripts/release.ts major       # 0.1.0 → 1.0.0
+ *   bun run scripts/release.ts 2.0.0       # explicit version
+ *   bun run scripts/release.ts patch --dry  # preview without changes
+ */
+
+import { readFileSync, writeFileSync } from 'node:fs'
+import path from 'node:path'
+
+const root = path.resolve(import.meta.dir, '..')
+
+const VERSION_FILES = [
+  {
+    path: path.join(root, 'desktop/package.json'),
+    update(content: string, version: string) {
+      return content.replace(/"version":\s*"[^"]*"/, `"version": "${version}"`)
+    },
+  },
+  {
+    path: path.join(root, 'desktop/src-tauri/tauri.conf.json'),
+    update(content: string, version: string) {
+      return content.replace(/"version":\s*"[^"]*"/, `"version": "${version}"`)
+    },
+  },
+  {
+    path: path.join(root, 'desktop/src-tauri/Cargo.toml'),
+    update(content: string, version: string) {
+      return content.replace(/^version\s*=\s*"[^"]*"/m, `version = "${version}"`)
+    },
+  },
+]
+
+function getCurrentVersion(): string {
+  const tauriConf = JSON.parse(
+    readFileSync(path.join(root, 'desktop/src-tauri/tauri.conf.json'), 'utf-8'),
+  )
+  return tauriConf.version
+}
+
+function bumpVersion(current: string, bump: string): string {
+  if (/^\d+\.\d+\.\d+$/.test(bump)) {
+    return bump
+  }
+
+  const [major, minor, patch] = current.split('.').map(Number)
+
+  switch (bump) {
+    case 'patch':
+      return `${major}.${minor}.${patch + 1}`
+    case 'minor':
+      return `${major}.${minor + 1}.0`
+    case 'major':
+      return `${major + 1}.0.0`
+    default:
+      console.error(`Invalid bump type: ${bump}`)
+      console.error('Usage: bun run scripts/release.ts <patch|minor|major|x.y.z> [--dry]')
+      process.exit(1)
+  }
+}
+
+async function run(cmd: string[], cwd = root) {
+  const proc = Bun.spawn(cmd, { cwd, stdout: 'pipe', stderr: 'pipe' })
+  const stdout = await new Response(proc.stdout).text()
+  const stderr = await new Response(proc.stderr).text()
+  const code = await proc.exited
+  if (code !== 0) {
+    throw new Error(`Command failed: ${cmd.join(' ')}\n${stderr || stdout}`)
+  }
+  return stdout.trim()
+}
+
+// ── Main ──────────────────────────────────────────────
+
+const args = process.argv.slice(2)
+const dryRun = args.includes('--dry')
+const bumpArg = args.find((a) => a !== '--dry')
+
+if (!bumpArg) {
+  console.error('Usage: bun run scripts/release.ts <patch|minor|major|x.y.z> [--dry]')
+  process.exit(1)
+}
+
+const current = getCurrentVersion()
+const next = bumpVersion(current, bumpArg)
+
+console.log(`\n  Version: ${current} → ${next}`)
+console.log(`  Tag:     v${next}`)
+console.log(`  Dry run: ${dryRun}\n`)
+
+if (dryRun) {
+  console.log('Files that would be updated:')
+  for (const file of VERSION_FILES) {
+    console.log(`  - ${path.relative(root, file.path)}`)
+  }
+  process.exit(0)
+}
+
+// Update version in all files
+for (const file of VERSION_FILES) {
+  const content = readFileSync(file.path, 'utf-8')
+  const updated = file.update(content, next)
+  writeFileSync(file.path, updated)
+  console.log(`  Updated: ${path.relative(root, file.path)}`)
+}
+
+// Regenerate Cargo.lock
+console.log('\n  Updating Cargo.lock...')
+await run(['cargo', 'generate-lockfile'], path.join(root, 'desktop/src-tauri'))
+
+// Git commit + tag
+console.log('  Creating git commit...')
+await run([
+  'git',
+  'add',
+  'desktop/package.json',
+  'desktop/src-tauri/tauri.conf.json',
+  'desktop/src-tauri/Cargo.toml',
+  'desktop/src-tauri/Cargo.lock',
+])
+await run(['git', 'commit', '-m', `release: v${next}`])
+await run(['git', 'tag', '-a', `v${next}`, '-m', `Release v${next}`])
+
+console.log(`\n  Done! Created commit and tag v${next}`)
+console.log(`\n  To trigger the build:\n    git push origin main --tags\n`)