bingocode 1.0.40 → 1.1.42

package/adapters/common/attachment/attachment-store.ts

@@ -1,121 +0,0 @@
-/**
- * Local staging directory for IM-downloaded resources.
- *
- * Layout: {root}/{platform}/{sessionId}/{safeName}
- * Default root: ~/.claude/im-downloads
- *
- * Responsibilities:
- *  - Generate unique, safe paths from (platform, sessionId, originalName)
- *  - Atomic write (tmp → rename) so concurrent downloads never corrupt each other
- *  - GC files that haven't been touched for `retentionMs` (default 24h)
- */
-
-import * as fs from 'node:fs/promises'
-import * as fsSync from 'node:fs'
-import type { Dirent } from 'node:fs'
-import * as path from 'node:path'
-import * as os from 'node:os'
-import type { ImPlatform } from './attachment-types.js'
-
-export interface AttachmentStoreConfig {
-  root: string
-  retentionMs: number
-  /** Grace window before a `.part` orphan (left behind by a crashed writer)
-   *  is eligible for GC. Default 10 minutes. */
-  orphanGraceMs: number
-}
-
-const DEFAULT_RETENTION_MS = 24 * 60 * 60 * 1000
-const DEFAULT_ORPHAN_GRACE_MS = 10 * 60 * 1000
-
-function defaultRoot(): string {
-  return path.join(os.homedir(), '.claude', 'im-downloads')
-}
-
-/** Strip path separators / .. / control chars from a filename. */
-function sanitizeFilename(name: string): string {
-  // eslint-disable-next-line no-control-regex
-  const base = path.basename(name || '').replace(/[\x00-\x1f]/g, '')
-  const cleaned = base.replace(/[\/\\]/g, '_').replace(/\.\.+/g, '_')
-  return cleaned.trim() || 'unnamed'
-}
-
-export class AttachmentStore {
-  private readonly root: string
-  private readonly retentionMs: number
-  private readonly orphanGraceMs: number
-
-  constructor(config?: Partial<AttachmentStoreConfig>) {
-    this.root = config?.root ?? defaultRoot()
-    this.retentionMs = config?.retentionMs ?? DEFAULT_RETENTION_MS
-    this.orphanGraceMs = config?.orphanGraceMs ?? DEFAULT_ORPHAN_GRACE_MS
-  }
-
-  /** Compute the target path. Creates parent dirs on demand.
-   *  If a file with the same name already exists, prefix with a timestamp
-   *  to avoid clobbering. */
-  resolvePath(platform: ImPlatform, sessionId: string, name: string): string {
-    const safeSession = sanitizeFilename(sessionId)
-    const dir = path.join(this.root, platform, safeSession)
-    fsSync.mkdirSync(dir, { recursive: true })
-    const safeName = sanitizeFilename(name)
-    const candidate = path.join(dir, safeName)
-    if (!fsSync.existsSync(candidate)) return candidate
-    const { name: base, ext } = path.parse(safeName)
-    // Collisions are rare in practice, but multiple downloads landing in the
-    // same millisecond must still produce unique paths — append a random
-    // suffix so the bare timestamp alone never clashes.
-    const rand = Math.random().toString(36).slice(2, 8)
-    return path.join(dir, `${base}-${Date.now()}-${rand}${ext}`)
-  }
-
-  /** Write atomically: stream to {target}.part, then rename. */
-  async write(target: string, data: Buffer): Promise<string> {
-    await fs.mkdir(path.dirname(target), { recursive: true })
-    const tmp = `${target}.${process.pid}.${Date.now()}.part`
-    await fs.writeFile(tmp, data)
-    await fs.rename(tmp, target)
-    return target
-  }
-
-  /** Remove files older than retentionMs. Returns summary. */
-  async gc(): Promise<{ removed: number; bytes: number }> {
-    let removed = 0
-    let bytes = 0
-    const now = Date.now()
-
-    const walk = async (dir: string): Promise<void> => {
-      let entries: Dirent<string>[]
-      try {
-        // Pass encoding explicitly so Dirent stays string-typed under
-        // newer @types/node where the Buffer overload becomes the default.
-        entries = await fs.readdir(dir, { withFileTypes: true, encoding: 'utf8' })
-      } catch {
-        return
-      }
-      for (const entry of entries) {
-        const full = path.join(dir, entry.name)
-        if (entry.isDirectory()) {
-          await walk(full)
-        } else if (entry.isFile()) {
-          try {
-            const stat = await fs.stat(full)
-            const age = now - stat.mtimeMs
-            const isOrphanPart = entry.name.endsWith('.part')
-            const threshold = isOrphanPart ? this.orphanGraceMs : this.retentionMs
-            if (age > threshold) {
-              bytes += stat.size
-              await fs.unlink(full)
-              removed++
-            }
-          } catch {
-            // ignore races
-          }
-        }
-      }
-    }
-
-    await walk(this.root).catch(() => {})
-    return { removed, bytes }
-  }
-}

package/adapters/common/attachment/attachment-types.ts

@@ -1,29 +0,0 @@
-/**
- * Shared attachment types for IM adapters.
- */
-
-import type { AttachmentRef } from '../ws-bridge.js'
-export type { AttachmentRef }
-
-/** Platform tag — used for local staging subdir and telemetry. */
-export type ImPlatform = 'feishu' | 'telegram'
-
-/** Result of downloading an IM resource into the local stage dir. */
-export interface LocalAttachment {
-  kind: 'image' | 'file'
-  name: string        // original filename, or synthesized if none
-  path: string        // absolute path on disk (under ~/.claude/im-downloads)
-  size: number        // bytes
-  mimeType: string    // detected or provided
-  buffer: Buffer      // raw bytes (kept so caller can choose base64 vs path)
-}
-
-/** Pending outbound media found in Agent stream output. */
-export interface PendingUpload {
-  id: string          // fingerprint, used for dedup
-  source:
-    | { kind: 'base64'; data: string; mime: string }
-    | { kind: 'path'; path: string; mime?: string }
-    | { kind: 'url'; url: string; mime?: string }
-  alt?: string
-}

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 : []
-  }
-}