claw-code-parity/ts-worker/state/FeedStore.ts

/**
 * FeedStore — manages feed items and their payload files.
 *
 * Feed items are non-text outputs from Claude (images, HTML previews,
 * code files, diffs, etc.) that get surfaced in the Mini App.
 */

import { randomUUID } from 'crypto'
import { readFile, writeFile, mkdir, readdir, stat } from 'fs/promises'
import { join, basename } from 'path'
import type { FeedItemRecord, FeedItemKind, FeedItemSource } from './records.js'

export class FeedStore {
  private items = new Map<string, FeedItemRecord>()
  private stateRoot: string
  private payloadDir: string

  constructor(stateRoot: string) {
    this.stateRoot = stateRoot
    this.payloadDir = join(stateRoot, 'claw', 'feed')
  }

  async init(): Promise<void> {
    await mkdir(this.payloadDir, { recursive: true })
    // Load existing feed index if present
    try {
      const indexPath = join(this.payloadDir, 'index.json')
      const data = await readFile(indexPath, 'utf8')
      const records = JSON.parse(data) as FeedItemRecord[]
      for (const r of records) {
        this.items.set(r.feed_item_id, r)
      }
    } catch {
      // No existing index — start fresh
    }
  }

  async addItem(
    title: string,
    kind: FeedItemKind,
    source: FeedItemSource,
    payload?: Uint8Array,
    options?: {
      mediaType?: string
      fileName?: string
      linkedAppId?: string
      previewText?: string
    },
  ): Promise<FeedItemRecord> {
    const id = randomUUID()
    const now = Date.now()
    let storedPath: string | undefined

    if (payload) {
      const ext = options?.fileName
        ? basename(options.fileName)
        : id
      storedPath = join(this.payloadDir, ext)
      await writeFile(storedPath, payload)
    }

    const record: FeedItemRecord = {
      feed_item_id: id,
      title,
      kind,
      source,
      linked_app_id: options?.linkedAppId,
      media_type: options?.mediaType,
      file_name: options?.fileName,
      stored_path: storedPath,
      preview_text: options?.previewText,
      deleted: false,
      created_at: now,
      updated_at: now,
    }

    this.items.set(id, record)
    await this.persistIndex()
    return record
  }

  getItem(feedItemId: string): FeedItemRecord | undefined {
    return this.items.get(feedItemId)
  }

  listItems(turnId?: string): FeedItemRecord[] {
    let items = Array.from(this.items.values()).filter((i) => !i.deleted)
    if (turnId) {
      items = items.filter((i) => i.source.turn_id === turnId)
    }
    return items.sort((a, b) => b.created_at - a.created_at)
  }

  async getPayload(feedItemId: string): Promise<Uint8Array | null> {
    const item = this.items.get(feedItemId)
    if (!item?.stored_path) return null
    try {
      return await readFile(item.stored_path) as unknown as Uint8Array
    } catch {
      return null
    }
  }

  deleteItem(feedItemId: string): boolean {
    const item = this.items.get(feedItemId)
    if (!item) return false
    item.deleted = true
    item.updated_at = Date.now()
    return true
  }

  reset(): void {
    this.items.clear()
  }

  private async persistIndex(): Promise<void> {
    const indexPath = join(this.payloadDir, 'index.json')
    const records = Array.from(this.items.values())
    await writeFile(indexPath, JSON.stringify(records, null, 2))
  }
}