@echofiles/echo-pdf 0.4.1 → 0.4.3

package/src/pdfium-engine.ts

@@ -1,207 +0,0 @@
-import { init } from "@embedpdf/pdfium"
-import { encode as encodePng } from "@cf-wasm/png/workerd"
-import type { WrappedPdfiumModule } from "@embedpdf/pdfium"
-import type { EchoPdfConfig } from "./pdf-types"
-import { toDataUrl } from "./file-utils"
-import compiledPdfiumModule from "@embedpdf/pdfium/dist/pdfium.wasm"
-
-let moduleInstance: WrappedPdfiumModule | null = null
-let libraryInitialized = false
-
-const toUint8 = (value: ArrayBuffer): Uint8Array => new Uint8Array(value)
-const textDecoder = new TextDecoder()
-
-const ensureWasmFunctionShim = (): void => {
-  const wasmApi = WebAssembly as unknown as {
-    Function?: unknown
-  }
-  if (typeof wasmApi.Function === "function") return
-  ;(wasmApi as { Function: (sig: unknown, fn: unknown) => unknown }).Function = (
-    _sig: unknown,
-    fn: unknown
-  ) => fn
-}
-
-const ensurePdfium = async (config: EchoPdfConfig): Promise<WrappedPdfiumModule> => {
-  ensureWasmFunctionShim()
-  if (!moduleInstance) {
-    const maybeModule = compiledPdfiumModule as unknown
-    if (maybeModule instanceof WebAssembly.Module) {
-      moduleInstance = await init({
-        instantiateWasm: (
-          imports: WebAssembly.Imports,
-          successCallback: (instance: WebAssembly.Instance, module: WebAssembly.Module) => void
-        ): WebAssembly.Exports => {
-          const instance = new WebAssembly.Instance(maybeModule, imports)
-          successCallback(instance, maybeModule)
-          return instance.exports
-        },
-      })
-    } else {
-      const wasmBinary = await fetch(config.pdfium.wasmUrl).then((res) => res.arrayBuffer())
-      moduleInstance = await init({ wasmBinary })
-    }
-  }
-  if (!libraryInitialized) {
-    moduleInstance.FPDF_InitLibrary()
-    libraryInitialized = true
-  }
-  return moduleInstance
-}
-
-const makeDoc = (pdfium: WrappedPdfiumModule, bytes: Uint8Array): {
-  readonly doc: number
-  readonly memPtr: number
-} => {
-  const memPtr = pdfium.pdfium.wasmExports.malloc(bytes.length)
-  ;(pdfium.pdfium as unknown as { HEAPU8: Uint8Array }).HEAPU8.set(bytes, memPtr)
-  const doc = pdfium.FPDF_LoadMemDocument(memPtr, bytes.length, "")
-  if (!doc) {
-    pdfium.pdfium.wasmExports.free(memPtr)
-    throw new Error("Failed to load PDF document")
-  }
-  return { doc, memPtr }
-}
-
-const closeDoc = (pdfium: WrappedPdfiumModule, doc: number, memPtr: number): void => {
-  pdfium.FPDF_CloseDocument(doc)
-  pdfium.pdfium.wasmExports.free(memPtr)
-}
-
-const bgraToRgba = (bgra: Uint8Array): Uint8Array => {
-  const rgba = new Uint8Array(bgra.length)
-  for (let i = 0; i < bgra.length; i += 4) {
-    rgba[i] = bgra[i + 2] ?? 0
-    rgba[i + 1] = bgra[i + 1] ?? 0
-    rgba[i + 2] = bgra[i] ?? 0
-    rgba[i + 3] = bgra[i + 3] ?? 255
-  }
-  return rgba
-}
-
-const decodeUtf16Le = (buf: Uint8Array): string => {
-  const view = new Uint16Array(buf.buffer, buf.byteOffset, Math.floor(buf.byteLength / 2))
-  const chars: number[] = []
-  for (const code of view) {
-    if (code === 0) break
-    chars.push(code)
-  }
-  return String.fromCharCode(...chars)
-}
-
-export const getPdfPageCount = async (config: EchoPdfConfig, bytes: Uint8Array): Promise<number> => {
-  const pdfium = await ensurePdfium(config)
-  const { doc, memPtr } = makeDoc(pdfium, bytes)
-  try {
-    return pdfium.FPDF_GetPageCount(doc)
-  } finally {
-    closeDoc(pdfium, doc, memPtr)
-  }
-}
-
-export const renderPdfPageToPng = async (
-  config: EchoPdfConfig,
-  bytes: Uint8Array,
-  pageIndex: number,
-  scale = config.service.defaultRenderScale
-): Promise<{
-  width: number
-  height: number
-  png: Uint8Array
-}> => {
-  const pdfium = await ensurePdfium(config)
-  const { doc, memPtr } = makeDoc(pdfium, bytes)
-  let page = 0
-  let bitmap = 0
-  try {
-    page = pdfium.FPDF_LoadPage(doc, pageIndex)
-    if (!page) {
-      throw new Error(`Failed to load page ${pageIndex}`)
-    }
-    const width = Math.max(1, Math.round(pdfium.FPDF_GetPageWidthF(page) * scale))
-    const height = Math.max(1, Math.round(pdfium.FPDF_GetPageHeightF(page) * scale))
-    bitmap = pdfium.FPDFBitmap_Create(width, height, 1)
-    if (!bitmap) {
-      throw new Error("Failed to create bitmap")
-    }
-    pdfium.FPDFBitmap_FillRect(bitmap, 0, 0, width, height, 0xffffffff)
-    pdfium.FPDF_RenderPageBitmap(bitmap, page, 0, 0, width, height, 0, 0)
-
-    const stride = pdfium.FPDFBitmap_GetStride(bitmap)
-    const bufferPtr = pdfium.FPDFBitmap_GetBuffer(bitmap)
-    const heap = (pdfium.pdfium as unknown as { HEAPU8: Uint8Array }).HEAPU8
-    const bgra = heap.slice(bufferPtr, bufferPtr + stride * height)
-    const rgba = bgraToRgba(bgra)
-    const png = encodePng(rgba, width, height)
-    return { width, height, png }
-  } finally {
-    if (bitmap) pdfium.FPDFBitmap_Destroy(bitmap)
-    if (page) pdfium.FPDF_ClosePage(page)
-    closeDoc(pdfium, doc, memPtr)
-  }
-}
-
-export const extractPdfPageText = async (
-  config: EchoPdfConfig,
-  bytes: Uint8Array,
-  pageIndex: number
-): Promise<string> => {
-  const pdfium = await ensurePdfium(config)
-  const { doc, memPtr } = makeDoc(pdfium, bytes)
-  let page = 0
-  let textPage = 0
-  let outPtr = 0
-  try {
-    page = pdfium.FPDF_LoadPage(doc, pageIndex)
-    if (!page) {
-      throw new Error(`Failed to load page ${pageIndex}`)
-    }
-    textPage = pdfium.FPDFText_LoadPage(page)
-    if (!textPage) return ""
-    const chars = pdfium.FPDFText_CountChars(textPage)
-    if (chars <= 0) return ""
-    const bytesLen = (chars + 1) * 2
-    outPtr = pdfium.pdfium.wasmExports.malloc(bytesLen)
-    pdfium.FPDFText_GetText(textPage, 0, chars, outPtr)
-    const heap = (pdfium.pdfium as unknown as { HEAPU8: Uint8Array }).HEAPU8
-    const raw = heap.slice(outPtr, outPtr + bytesLen)
-    return decodeUtf16Le(raw).trim()
-  } finally {
-    if (outPtr) pdfium.pdfium.wasmExports.free(outPtr)
-    if (textPage) pdfium.FPDFText_ClosePage(textPage)
-    if (page) pdfium.FPDF_ClosePage(page)
-    closeDoc(pdfium, doc, memPtr)
-  }
-}
-
-export const toBytes = async (value: string): Promise<Uint8Array> => {
-  const response = await fetch(value)
-  if (!response.ok) {
-    throw new Error(`Failed to fetch source: HTTP ${response.status}`)
-  }
-  const contentType = (response.headers.get("content-type") ?? "").toLowerCase()
-  const bytes = toUint8(await response.arrayBuffer())
-  const signature = textDecoder.decode(bytes.subarray(0, Math.min(8, bytes.length)))
-
-  if (contentType.includes("application/pdf") || signature.startsWith("%PDF-")) {
-    return bytes
-  }
-
-  const html = textDecoder.decode(bytes)
-  const pdfMatch = html.match(/https?:\/\/[^"' )]+\.pdf[^"' )]*/i)
-  if (!pdfMatch || pdfMatch.length === 0) {
-    throw new Error("URL does not point to a PDF and no PDF link was found in the page")
-  }
-
-  const resolvedUrl = pdfMatch[0].replace(/&amp;/g, "&")
-  const pdfResponse = await fetch(resolvedUrl)
-  if (!pdfResponse.ok) {
-    throw new Error(`Failed to fetch resolved PDF url: HTTP ${pdfResponse.status}`)
-  }
-  const pdfBytes = toUint8(await pdfResponse.arrayBuffer())
-  const pdfSignature = textDecoder.decode(pdfBytes.subarray(0, Math.min(8, pdfBytes.length)))
-  if (!pdfSignature.startsWith("%PDF-")) {
-    throw new Error("Resolved file is not a valid PDF")
-  }
-  return pdfBytes
-}

package/src/provider-client.ts

@@ -1,176 +0,0 @@
-import type { Env } from "./types"
-import type { EchoPdfConfig, EchoPdfProviderConfig } from "./pdf-types"
-import { resolveProviderApiKey } from "./provider-keys"
-
-const defaultBaseUrl = (provider: EchoPdfProviderConfig): string => {
-  if (provider.baseUrl) return provider.baseUrl
-  switch (provider.type) {
-    case "openrouter":
-      return "https://openrouter.ai/api/v1"
-    case "vercel-ai-gateway":
-      return "https://ai-gateway.vercel.sh/v1"
-    case "openai":
-    default:
-      return "https://api.openai.com/v1"
-  }
-}
-
-const noTrailingSlash = (url: string): string => url.replace(/\/+$/, "")
-
-const resolveEndpoint = (
-  provider: EchoPdfProviderConfig,
-  kind: "chatCompletionsPath" | "modelsPath"
-): string => {
-  const configured = provider.endpoints?.[kind]
-  if (configured?.startsWith("http://") || configured?.startsWith("https://")) {
-    return configured
-  }
-  const fallback = kind === "chatCompletionsPath" ? "/chat/completions" : "/models"
-  const path = configured && configured.length > 0 ? configured : fallback
-  return `${noTrailingSlash(defaultBaseUrl(provider))}${path.startsWith("/") ? path : `/${path}`}`
-}
-
-const toAuthHeader = (
-  config: EchoPdfConfig,
-  providerAlias: string,
-  provider: EchoPdfProviderConfig,
-  env: Env,
-  runtimeApiKeys?: Record<string, string>
-): Record<string, string> => {
-  const token = resolveProviderApiKey({
-    config,
-    env,
-    providerAlias,
-    provider,
-    runtimeApiKeys,
-  })
-  return { Authorization: `Bearer ${token}` }
-}
-
-const withTimeout = async (
-  url: string,
-  init: RequestInit,
-  timeoutMs: number
-): Promise<Response> => {
-  const ctrl = new AbortController()
-  const timer = setTimeout(() => ctrl.abort("timeout"), timeoutMs)
-  try {
-    return await fetch(url, { ...init, signal: ctrl.signal })
-  } catch (error) {
-    if (error instanceof Error && error.name === "AbortError") {
-      throw new Error(`Request timeout after ${timeoutMs}ms for ${url}`)
-    }
-    throw error
-  } finally {
-    clearTimeout(timer)
-  }
-}
-
-const responseDetail = async (response: Response): Promise<string> => {
-  const contentType = response.headers.get("content-type") ?? ""
-  try {
-    if (contentType.includes("application/json")) {
-      return JSON.stringify(await response.json()).slice(0, 800)
-    }
-    return (await response.text()).slice(0, 800)
-  } catch {
-    return "<unable to parse response payload>"
-  }
-}
-
-const getProvider = (config: EchoPdfConfig, alias: string): EchoPdfProviderConfig => {
-  const provider = config.providers[alias]
-  if (!provider) {
-    throw new Error(`Provider "${alias}" not configured`)
-  }
-  return provider
-}
-
-export const listProviderModels = async (
-  config: EchoPdfConfig,
-  env: Env,
-  alias: string,
-  runtimeApiKeys?: Record<string, string>
-): Promise<ReadonlyArray<string>> => {
-  const provider = getProvider(config, alias)
-  const url = resolveEndpoint(provider, "modelsPath")
-  const response = await withTimeout(
-    url,
-    {
-      method: "GET",
-      headers: {
-        Accept: "application/json",
-        ...toAuthHeader(config, alias, provider, env, runtimeApiKeys),
-        ...(provider.headers ?? {}),
-      },
-    },
-    provider.timeoutMs ?? 30000
-  )
-
-  if (!response.ok) {
-    throw new Error(`Model list request failed: HTTP ${response.status} url=${url} detail=${await responseDetail(response)}`)
-  }
-
-  const payload = await response.json()
-  const data = (payload as { data?: unknown }).data
-  if (!Array.isArray(data)) return []
-  return data
-    .map((item) => item as { id?: unknown })
-    .map((item) => (typeof item.id === "string" ? item.id : ""))
-    .filter((id) => id.length > 0)
-}
-
-export const visionRecognize = async (input: {
-  config: EchoPdfConfig
-  env: Env
-  providerAlias: string
-  model: string
-  prompt: string
-  imageDataUrl: string
-  runtimeApiKeys?: Record<string, string>
-}): Promise<string> => {
-  const provider = getProvider(input.config, input.providerAlias)
-  const url = resolveEndpoint(provider, "chatCompletionsPath")
-  const response = await withTimeout(
-    url,
-    {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        ...toAuthHeader(input.config, input.providerAlias, provider, input.env, input.runtimeApiKeys),
-        ...(provider.headers ?? {}),
-      },
-      body: JSON.stringify({
-        model: input.model,
-        messages: [
-          {
-            role: "user",
-            content: [
-              { type: "text", text: input.prompt },
-              { type: "image_url", image_url: { url: input.imageDataUrl } },
-            ],
-          },
-        ],
-      }),
-    },
-    provider.timeoutMs ?? 30000
-  )
-
-  if (!response.ok) {
-    throw new Error(`Vision request failed: HTTP ${response.status} url=${url} detail=${await responseDetail(response)}`)
-  }
-
-  const payload = await response.json()
-  const message = (payload as { choices?: Array<{ message?: { content?: unknown } }> }).choices?.[0]?.message
-  if (!message) return ""
-  const content = message.content
-  if (typeof content === "string") return content
-  if (Array.isArray(content)) {
-    return content
-      .map((part) => part as { type?: string; text?: string })
-      .filter((part) => part.type === "text" && typeof part.text === "string")
-      .map((part) => part.text ?? "")
-      .join("")
-  }
-  return ""
-}

package/src/provider-keys.ts

@@ -1,44 +0,0 @@
-import { readRequiredEnv } from "./pdf-config"
-import type { EchoPdfConfig, EchoPdfProviderConfig } from "./pdf-types"
-import type { Env } from "./types"
-
-const normalizeKey = (value: string): string => value.trim()
-
-const keyVariants = (value: string): string[] => {
-  const raw = normalizeKey(value)
-  if (raw.length === 0) return []
-  return Array.from(
-    new Set([
-      raw,
-      raw.replace(/-/g, "_"),
-      raw.replace(/_/g, "-"),
-    ])
-  )
-}
-
-export const runtimeProviderKeyCandidates = (
-  _config: EchoPdfConfig,
-  providerAlias: string,
-  provider: EchoPdfProviderConfig
-): string[] => {
-  const aliases = keyVariants(providerAlias)
-  const types = keyVariants(provider.type)
-  return Array.from(new Set([...aliases, ...types]))
-}
-
-export const resolveProviderApiKey = (input: {
-  config: EchoPdfConfig
-  env: Env
-  providerAlias: string
-  provider: EchoPdfProviderConfig
-  runtimeApiKeys?: Record<string, string>
-}): string => {
-  const candidates = runtimeProviderKeyCandidates(input.config, input.providerAlias, input.provider)
-  for (const candidate of candidates) {
-    const value = input.runtimeApiKeys?.[candidate]
-    if (typeof value === "string" && value.trim().length > 0) {
-      return value.trim()
-    }
-  }
-  return readRequiredEnv(input.env, input.provider.apiKeyEnv)
-}

package/src/r2-file-store.ts

@@ -1,195 +0,0 @@
-import type { StoragePolicy } from "./pdf-types"
-import type { FileStore, StoredFileMeta, StoredFileRecord } from "./types"
-
-const PREFIX = "file/"
-
-type MetaFields = {
-  filename?: string
-  mimeType?: string
-  createdAt?: string
-}
-
-const toId = (key: string): string => key.startsWith(PREFIX) ? key.slice(PREFIX.length) : key
-const toKey = (id: string): string => `${PREFIX}${id}`
-
-const parseCreatedAt = (value: string | undefined, fallback: Date): string => {
-  if (typeof value === "string" && value.trim().length > 0) {
-    const ms = Date.parse(value)
-    if (Number.isFinite(ms)) return new Date(ms).toISOString()
-  }
-  return fallback.toISOString()
-}
-
-const isExpired = (createdAtIso: string, ttlHours: number): boolean => {
-  const ms = Date.parse(createdAtIso)
-  if (!Number.isFinite(ms)) return false
-  return Date.now() - ms > ttlHours * 60 * 60 * 1000
-}
-
-export class R2FileStore implements FileStore {
-  constructor(
-    private readonly bucket: R2Bucket,
-    private readonly policy: StoragePolicy
-  ) {}
-
-  async put(input: { readonly filename: string; readonly mimeType: string; readonly bytes: Uint8Array }): Promise<StoredFileMeta> {
-    const sizeBytes = input.bytes.byteLength
-    if (sizeBytes > this.policy.maxFileBytes) {
-      const err = new Error(`file too large: ${sizeBytes} bytes exceeds maxFileBytes ${this.policy.maxFileBytes}`)
-      ;(err as { status?: number; code?: string; details?: unknown }).status = 413
-      ;(err as { status?: number; code?: string; details?: unknown }).code = "FILE_TOO_LARGE"
-      ;(err as { status?: number; code?: string; details?: unknown }).details = { policy: this.policy, sizeBytes }
-      throw err
-    }
-
-    await this.cleanupInternal(sizeBytes)
-
-    const id = crypto.randomUUID()
-    const createdAt = new Date().toISOString()
-    await this.bucket.put(toKey(id), input.bytes, {
-      httpMetadata: {
-        contentType: input.mimeType,
-      },
-      customMetadata: {
-        filename: input.filename,
-        mimeType: input.mimeType,
-        createdAt,
-      },
-    })
-
-    return { id, filename: input.filename, mimeType: input.mimeType, sizeBytes, createdAt }
-  }
-
-  async get(fileId: string): Promise<StoredFileRecord | null> {
-    const obj = await this.bucket.get(toKey(fileId))
-    if (!obj) return null
-    const meta = (obj.customMetadata ?? {}) as MetaFields
-    const createdAt = parseCreatedAt(meta.createdAt, obj.uploaded)
-    const filename = meta.filename ?? fileId
-    const mimeType = meta.mimeType ?? obj.httpMetadata?.contentType ?? "application/octet-stream"
-    const bytes = new Uint8Array(await obj.arrayBuffer())
-    return {
-      id: fileId,
-      filename,
-      mimeType,
-      sizeBytes: bytes.byteLength,
-      createdAt,
-      bytes,
-    }
-  }
-
-  async list(): Promise<ReadonlyArray<StoredFileMeta>> {
-    return await this.listAllFiles()
-  }
-
-  async delete(fileId: string): Promise<boolean> {
-    await this.bucket.delete(toKey(fileId))
-    return true
-  }
-
-  async stats(): Promise<unknown> {
-    const files = await this.listAllFiles()
-    const totalBytes = files.reduce((sum, file) => sum + file.sizeBytes, 0)
-    return {
-      backend: "r2",
-      policy: this.policy,
-      stats: {
-        fileCount: files.length,
-        totalBytes,
-      },
-    }
-  }
-
-  async cleanup(): Promise<unknown> {
-    const files = await this.listAllFiles()
-    const expired = files.filter((f) => isExpired(f.createdAt, this.policy.ttlHours))
-    const active = files.filter((f) => !isExpired(f.createdAt, this.policy.ttlHours))
-    if (expired.length > 0) {
-      await this.bucket.delete(expired.map((f) => toKey(f.id)))
-    }
-    const evict = this.pickEvictions(active, 0)
-    if (evict.length > 0) {
-      await this.bucket.delete(evict.map((f) => toKey(f.id)))
-    }
-    const evictIds = new Set(evict.map((f) => f.id))
-    const after = active.filter((f) => !evictIds.has(f.id))
-    const totalBytes = after.reduce((sum, file) => sum + file.sizeBytes, 0)
-    return {
-      backend: "r2",
-      policy: this.policy,
-      deletedExpired: expired.length,
-      deletedEvicted: evict.length,
-      stats: {
-        fileCount: after.length,
-        totalBytes,
-      },
-    }
-  }
-
-  private async cleanupInternal(incomingBytes: number): Promise<void> {
-    const files = await this.listAllFiles()
-    const expired = files.filter((f) => isExpired(f.createdAt, this.policy.ttlHours))
-    const active = files.filter((f) => !isExpired(f.createdAt, this.policy.ttlHours))
-    if (expired.length > 0) {
-      await this.bucket.delete(expired.map((f) => toKey(f.id)))
-    }
-    const evict = this.pickEvictions(active, incomingBytes)
-    if (evict.length > 0) {
-      await this.bucket.delete(evict.map((f) => toKey(f.id)))
-    }
-    const evictIds = new Set(evict.map((f) => f.id))
-    const remaining = active.filter((f) => !evictIds.has(f.id))
-    const finalTotal = remaining.reduce((sum, file) => sum + file.sizeBytes, 0)
-    if (finalTotal + incomingBytes > this.policy.maxTotalBytes) {
-      const err = new Error(
-        `storage quota exceeded: total ${finalTotal} + incoming ${incomingBytes} > maxTotalBytes ${this.policy.maxTotalBytes}`
-      )
-      ;(err as { status?: number; code?: string; details?: unknown }).status = 507
-      ;(err as { status?: number; code?: string; details?: unknown }).code = "STORAGE_QUOTA_EXCEEDED"
-      ;(err as { status?: number; code?: string; details?: unknown }).details = { policy: this.policy, totalBytes: finalTotal, incomingBytes }
-      throw err
-    }
-  }
-
-  private pickEvictions(files: ReadonlyArray<StoredFileMeta>, incomingBytes: number): StoredFileMeta[] {
-    const totalBytes = files.reduce((sum, f) => sum + f.sizeBytes, 0)
-    const projected = totalBytes + incomingBytes
-    if (projected <= this.policy.maxTotalBytes) return []
-
-    const needFree = projected - this.policy.maxTotalBytes
-    const candidates = [...files].sort((a, b) => Date.parse(a.createdAt) - Date.parse(b.createdAt))
-    const evict: StoredFileMeta[] = []
-    let freed = 0
-    for (const file of candidates) {
-      evict.push(file)
-      freed += file.sizeBytes
-      if (freed >= needFree) break
-      if (evict.length >= this.policy.cleanupBatchSize) break
-    }
-    return evict
-  }
-
-  private async listAllFiles(): Promise<StoredFileMeta[]> {
-    const files: StoredFileMeta[] = []
-    let cursor: string | undefined
-    while (true) {
-      const listed = await this.bucket.list({ prefix: PREFIX, limit: 1000, cursor })
-      for (const obj of listed.objects) {
-        const meta = (obj.customMetadata ?? {}) as MetaFields
-        const createdAt = parseCreatedAt(meta.createdAt, obj.uploaded)
-        const filename = meta.filename ?? toId(obj.key)
-        const mimeType = meta.mimeType ?? obj.httpMetadata?.contentType ?? "application/octet-stream"
-        files.push({
-          id: toId(obj.key),
-          filename,
-          mimeType,
-          sizeBytes: obj.size,
-          createdAt,
-        })
-      }
-      if (listed.truncated !== true || !listed.cursor) break
-      cursor = listed.cursor
-    }
-    return files
-  }
-}