Skip to content

CanvasAnvil is an open source AI diagram maker and flowchart generator - an infinite-canvas diagram editor and self-hosted drawio alternative that writes editable .drawio files. Text to diagram, then fix nodes, layout and labels in place. Also AI presentations, interior design CAD/BOM, posters and infographics.

8.2 KB
Raw Blame
import JSZip from "jszip"
import { z } from "zod"

const requestSchema = z.object({
    fileName: z.string().min(1).max(255),
    fileType: z.string().max(200).optional(),
    fileBase64: z.string().min(1),
    apiToken: z.string().min(1),
    apiBase: z.string().url().optional(),
    maxAssets: z.number().int().positive().max(50).optional(),
    maxWaitMs: z.number().int().positive().max(300000).optional(),
})

const getMimeByExt = (name: string) => {
    const lower = String(name || "").toLowerCase()
    if (lower.endsWith(".png")) return "image/png"
    if (lower.endsWith(".jpg") || lower.endsWith(".jpeg")) return "image/jpeg"
    if (lower.endsWith(".webp")) return "image/webp"
    if (lower.endsWith(".gif")) return "image/gif"
    if (lower.endsWith(".bmp")) return "image/bmp"
    if (lower.endsWith(".svg")) return "image/svg+xml"
    return "image/png"
}

const normalizeMineruImagePath = (rawPath: string) => {
    let p = String(rawPath || "").trim().replace(/^['"]|['"]$/g, "")
    if (!p) return ""
    p = p.replace(/\\/g, "/")
    if (p.startsWith("/")) p = p.slice(1)
    if (p.startsWith("file/")) p = p.slice(5)
    if (p.startsWith("files/")) p = p.slice(6)
    return p
}

const findZipImageEntry = (zip: JSZip, relPath: string) => {
    const target = normalizeMineruImagePath(relPath).toLowerCase()
    if (!target) return null
    const entries = Object.values(zip.files).filter((f) => !f.dir)
    const exact = entries.find(
        (e) =>
            String(e.name || "").replace(/\\/g, "/").toLowerCase() === target,
    )
    if (exact) return exact
    const suffix = `/${target}`
    return (
        entries.find((e) => {
            const name = String(e.name || "").replace(/\\/g, "/").toLowerCase()
            return name.endsWith(suffix) || name.endsWith(target)
        }) || null
    )
}

const uint8ToBase64 = (bytes: Uint8Array) => Buffer.from(bytes).toString("base64")

export async function POST(req: Request) {
    let data: z.infer<typeof requestSchema>
    try {
        data = requestSchema.parse(await req.json())
    } catch {
        return Response.json(
            { success: false, error: "Invalid input" },
            { status: 400 },
        )
    }

    const apiBase = String(data.apiBase || "https://mineru.net")
        .trim()
        .replace(/\/+$/, "")
    const token = String(data.apiToken || "").trim()
    const maxAssets = Math.max(1, data.maxAssets ?? 10)
    const maxWaitMs = Math.max(5000, data.maxWaitMs ?? 120000)
    const fileBytes = Buffer.from(data.fileBase64, "base64")

    const reqHeaders: Record<string, string> = {
        "Content-Type": "application/json",
        Authorization: `Bearer ${token}`,
    }

    try {
        const uploadUrlResp = await fetch(`${apiBase}/api/v4/file-urls/batch`, {
            method: "POST",
            headers: reqHeaders,
            body: JSON.stringify({
                files: [{ name: data.fileName }],
                model_version: "vlm",
            }),
        })
        if (!uploadUrlResp.ok) {
            throw new Error(
                `Third-party parser request failed: ${uploadUrlResp.status}`,
            )
        }
        const uploadPayload = await uploadUrlResp.json()
        if (uploadPayload?.code !== 0) {
            throw new Error(
                String(
                    uploadPayload?.msg ||
                        "Third-party parser get upload URL failed",
                ),
            )
        }

        const batchId = String(uploadPayload?.data?.batch_id || "")
        const uploadUrl = String(uploadPayload?.data?.file_urls?.[0] || "")
        if (!batchId || !uploadUrl) {
            throw new Error("Third-party parser missing batch id or upload URL")
        }

        const uploadResp = await fetch(uploadUrl, {
            method: "PUT",
            body: fileBytes,
        })
        if (!uploadResp.ok) {
            const body = await uploadResp.text().catch(() => "")
            throw new Error(
                `Third-party parser upload failed: ${uploadResp.status}${body ? ` body=${body.slice(0, 300)}` : ""}`,
            )
        }

        const resultUrl = `${apiBase}/api/v4/extract-results/batch/${batchId}`
        const start = Date.now()
        let fullZipUrl = ""
        while (Date.now() - start < maxWaitMs) {
            const pollResp = await fetch(resultUrl, {
                headers: { Authorization: `Bearer ${token}` },
            })
            if (!pollResp.ok) {
                throw new Error(`Third-party parser poll failed: ${pollResp.status}`)
            }
            const pollPayload = await pollResp.json()
            if (pollPayload?.code !== 0) {
                throw new Error(
                    String(
                        pollPayload?.msg || "Third-party parser poll returned error",
                    ),
                )
            }

            const extractResult = pollPayload?.data?.extract_result?.[0]
            const state = String(extractResult?.state || "")
            if (state === "done") {
                fullZipUrl = String(extractResult?.full_zip_url || "")
                break
            }
            if (state === "failed") {
                throw new Error(
                    String(extractResult?.err_msg || "Third-party parser extraction failed"),
                )
            }
            await new Promise((r) => setTimeout(r, 2000))
        }
        if (!fullZipUrl) throw new Error("Third-party parser timeout")

        const zipResp = await fetch(fullZipUrl)
        if (!zipResp.ok) {
            throw new Error(
                `Third-party parser result download failed: ${zipResp.status}`,
            )
        }
        const zipArrayBuffer = await zipResp.arrayBuffer()
        const zip = await JSZip.loadAsync(zipArrayBuffer)

        const markdownEntry =
            Object.values(zip.files).find(
                (f) => !f.dir && /\.md$/i.test(String(f.name || "")),
            ) || null
        const markdown = markdownEntry ? await markdownEntry.async("string") : ""

        const usedImageNames = new Set<string>()
        const assets: Array<{ dataUrl: string; textHint: string }> = []

        if (markdown) {
            const imageRe = /!\[([^\]]*)\]\(([^)]+)\)/g
            let match: RegExpExecArray | null
            while ((match = imageRe.exec(markdown))) {
                if (assets.length >= maxAssets) break
                const alt = String(match[1] || "").trim()
                const relPath = String(match[2] || "").trim()
                if (!relPath || /^https?:\/\//i.test(relPath)) continue

                const entry = findZipImageEntry(zip, relPath)
                if (!entry) continue
                const entryName = String(entry.name || "")
                if (usedImageNames.has(entryName)) continue

                const bytes = await entry.async("uint8array")
                const mime = getMimeByExt(entryName)
                assets.push({
                    dataUrl: `data:${mime};base64,${uint8ToBase64(bytes)}`,
                    textHint: alt,
                })
                usedImageNames.add(entryName)
            }
        }

        if (assets.length < maxAssets) {
            const imageEntries = Object.values(zip.files)
                .filter((f) => !f.dir)
                .filter((f) =>
                    /\.(png|jpg|jpeg|webp|gif|bmp|svg)$/i.test(String(f.name || "")),
                )
            for (const entry of imageEntries) {
                if (assets.length >= maxAssets) break
                const entryName = String(entry.name || "")
                if (usedImageNames.has(entryName)) continue
                const bytes = await entry.async("uint8array")
                const mime = getMimeByExt(entryName)
                assets.push({
                    dataUrl: `data:${mime};base64,${uint8ToBase64(bytes)}`,
                    textHint: "",
                })
                usedImageNames.add(entryName)
            }
        }

        return Response.json({ success: true, assets })
    } catch (error) {
        const msg = error instanceof Error ? error.message : "Unknown error"
        console.error("[third-party-parser] failed:", msg)
        return Response.json(
            { success: false, error: msg },
            { status: 500 },
        )
    }
}