@echofiles/echo-pdf 0.4.2 → 0.5.0

package/dist/mcp-server.js

@@ -6,11 +6,11 @@ const ok = (id, result) => new Response(JSON.stringify({
     id: id ?? null,
     result,
 }), { headers: { "Content-Type": "application/json" } });
-const err = (id, code, message, data) => new Response(JSON.stringify({
+const err = (id, code, message, data, httpStatus = 400) => new Response(JSON.stringify({
     jsonrpc: "2.0",
     id: id ?? null,
     error: data ? { code, message, data } : { code, message },
-}), { status: 400, headers: { "Content-Type": "application/json" } });
+}), { status: httpStatus, headers: { "Content-Type": "application/json" } });
 const asObj = (v) => typeof v === "object" && v !== null && !Array.isArray(v) ? v : {};
 const resolvePublicBaseUrl = (request, configured) => typeof configured === "string" && configured.length > 0 ? configured : request.url;
 const prepareMcpToolArgs = (toolName, args) => {
@@ -32,10 +32,7 @@ export const handleMcpRequest = async (request, env, config, fileStore) => {
         contextName: "MCP",
     });
     if (!auth.ok) {
-        return new Response(JSON.stringify({ error: auth.message, code: auth.code }), {
-            status: auth.status,
-            headers: { "Content-Type": "application/json" },
-        });
+        return err(null, -32001, auth.message, { status: auth.status, code: auth.code }, 200);
     }
     let body;
     try {

package/dist/node/pdfium-local.d.ts

@@ -0,0 +1,8 @@
+import type { EchoPdfConfig } from "../pdf-types.js";
+export declare const getLocalPdfPageCount: (config: EchoPdfConfig, bytes: Uint8Array) => Promise<number>;
+export declare const renderLocalPdfPageToPng: (config: EchoPdfConfig, bytes: Uint8Array, pageIndex: number, scale?: number) => Promise<{
+    width: number;
+    height: number;
+    png: Uint8Array;
+}>;
+export declare const extractLocalPdfPageText: (config: EchoPdfConfig, bytes: Uint8Array, pageIndex: number) => Promise<string>;

package/dist/node/pdfium-local.js

@@ -0,0 +1,147 @@
+/// <reference path="./compat.d.ts" />
+import { encode as encodePng } from "@cf-wasm/png";
+import { init } from "@embedpdf/pdfium";
+let moduleInstance = null;
+let libraryInitialized = false;
+const isNodeRuntime = () => typeof process !== "undefined" && Boolean(process.versions?.node);
+const ensureWasmFunctionShim = () => {
+    const wasmApi = WebAssembly;
+    if (typeof wasmApi.Function === "function")
+        return;
+    wasmApi.Function = (_sig, fn) => fn;
+};
+const readLocalPdfiumWasm = async () => {
+    const [{ readFile }, { createRequire }] = await Promise.all([
+        import("node:fs/promises"),
+        import("node:module"),
+    ]);
+    const require = createRequire(import.meta.url);
+    const bytes = await readFile(require.resolve("@embedpdf/pdfium/pdfium.wasm"));
+    return new Uint8Array(bytes).slice().buffer;
+};
+const ensureLocalPdfium = async (_config) => {
+    if (!isNodeRuntime()) {
+        throw new Error("local document APIs require a Node-compatible runtime");
+    }
+    ensureWasmFunctionShim();
+    if (!moduleInstance) {
+        moduleInstance = await init({ wasmBinary: await readLocalPdfiumWasm() });
+    }
+    if (!libraryInitialized) {
+        moduleInstance.FPDF_InitLibrary();
+        libraryInitialized = true;
+    }
+    return moduleInstance;
+};
+const makeDoc = (pdfium, bytes) => {
+    const memPtr = pdfium.pdfium.wasmExports.malloc(bytes.length);
+    pdfium.pdfium.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, doc, memPtr) => {
+    pdfium.FPDF_CloseDocument(doc);
+    pdfium.pdfium.wasmExports.free(memPtr);
+};
+const decodeUtf16Le = (buf) => {
+    const view = new Uint16Array(buf.buffer, buf.byteOffset, Math.floor(buf.byteLength / 2));
+    const chars = [];
+    for (const code of view) {
+        if (code === 0)
+            break;
+        chars.push(code);
+    }
+    return String.fromCharCode(...chars);
+};
+const bgraToRgba = (bgra) => {
+    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;
+};
+export const getLocalPdfPageCount = async (config, bytes) => {
+    const pdfium = await ensureLocalPdfium(config);
+    const { doc, memPtr } = makeDoc(pdfium, bytes);
+    try {
+        return pdfium.FPDF_GetPageCount(doc);
+    }
+    finally {
+        closeDoc(pdfium, doc, memPtr);
+    }
+};
+export const renderLocalPdfPageToPng = async (config, bytes, pageIndex, scale = config.service.defaultRenderScale) => {
+    const pdfium = await ensureLocalPdfium(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.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 extractLocalPdfPageText = async (config, bytes, pageIndex) => {
+    const pdfium = await ensureLocalPdfium(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.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);
+    }
+};

package/dist/node/semantic-local.d.ts

@@ -0,0 +1,16 @@
+export interface SemanticPageInput {
+    readonly pageNumber: number;
+    readonly text: string;
+    readonly artifactPath: string;
+}
+export interface SemanticSectionNode {
+    readonly id: string;
+    readonly type: "section";
+    readonly title: string;
+    readonly level: number;
+    readonly pageNumber: number;
+    readonly pageArtifactPath: string;
+    readonly excerpt: string;
+    readonly children: ReadonlyArray<SemanticSectionNode>;
+}
+export declare const buildSemanticSectionTree: (pages: ReadonlyArray<SemanticPageInput>) => ReadonlyArray<SemanticSectionNode>;

package/dist/node/semantic-local.js

@@ -0,0 +1,113 @@
+const normalizeLine = (value) => value.replace(/\s+/g, " ").trim();
+const excerptFor = (value) => normalizeLine(value).slice(0, 160);
+const hasTocSuffix = (value) => /(?:\.{2,}|\s{2,}|\t)\d+$/.test(value);
+const hasTrailingPageNumber = (value) => /\s\d+$/.test(value);
+const isContentsHeading = (value) => {
+    const normalized = normalizeLine(value).toLowerCase();
+    return normalized === "contents" || normalized === "table of contents" || normalized === "目录";
+};
+const detectHeading = (line) => {
+    const normalized = normalizeLine(line);
+    if (!normalized || normalized.length > 120)
+        return null;
+    if (hasTocSuffix(normalized))
+        return null;
+    const numbered = normalized.match(/^(\d+(?:\.\d+){0,3})\s+(.+)$/);
+    if (numbered) {
+        const numberPath = numbered[1] || "";
+        const topLevelNumber = Number.parseInt(numberPath.split(".")[0] || "", 10);
+        const title = normalizeLine(numbered[2] || "");
+        const level = numberPath.split(".").length;
+        if (!title)
+            return null;
+        if (title.length < 2)
+            return null;
+        if (hasTrailingPageNumber(normalized))
+            return null;
+        if (!/^[A-Za-z\u4E00-\u9FFF第（(]/.test(title))
+            return null;
+        if (/^(GHz|MHz|Kbps|Mbps|Hz|kHz|mA|V|W)\b/i.test(title))
+            return null;
+        if (/[。；;：:]$/.test(title))
+            return null;
+        if (Number.isFinite(topLevelNumber) && topLevelNumber > 20)
+            return null;
+        if (/^[A-Z]+\d+$/.test(title))
+            return null;
+        if (level === 1 && title.length > 40)
+            return null;
+        if (level === 1 && /[，,×—]/.test(title))
+            return null;
+        return {
+            title: `${numberPath} ${title}`.trim(),
+            level,
+        };
+    }
+    const chinese = normalized.match(/^(第[0-9一二三四五六七八九十百]+)(章|节|部分)\s+(.+)$/);
+    if (chinese) {
+        const suffix = chinese[2] || "";
+        return {
+            title: normalized,
+            level: suffix === "节" ? 2 : 1,
+        };
+    }
+    const english = normalized.match(/^(Chapter|Section|Part|Appendix)\b[:\s-]*(.+)?$/i);
+    if (english) {
+        return {
+            title: normalized,
+            level: /section/i.test(english[1] || "") ? 2 : 1,
+        };
+    }
+    return null;
+};
+const toReadonlyTree = (node) => ({
+    ...node,
+    children: node.children.map(toReadonlyTree),
+});
+export const buildSemanticSectionTree = (pages) => {
+    const rootChildren = [];
+    const stack = [];
+    const emittedKeys = new Set();
+    let nextId = 1;
+    for (const page of pages) {
+        const lines = page.text
+            .split(/\r?\n/)
+            .map(normalizeLine)
+            .filter(Boolean);
+        if (lines.length === 0)
+            continue;
+        const contentsPage = isContentsHeading(lines[0] || "");
+        for (const line of lines) {
+            const heading = detectHeading(line);
+            if (!heading || contentsPage)
+                continue;
+            const emittedKey = `${heading.level}:${heading.title}`;
+            if (emittedKeys.has(emittedKey))
+                continue;
+            const node = {
+                id: `section-${nextId}`,
+                type: "section",
+                title: heading.title,
+                level: heading.level,
+                pageNumber: page.pageNumber,
+                pageArtifactPath: page.artifactPath,
+                excerpt: excerptFor(line),
+                children: [],
+            };
+            nextId += 1;
+            emittedKeys.add(emittedKey);
+            while (stack.length > 0 && (stack[stack.length - 1]?.level || 0) >= heading.level) {
+                stack.pop();
+            }
+            const parent = stack[stack.length - 1];
+            if (parent) {
+                parent.children.push(node);
+            }
+            else {
+                rootChildren.push(node);
+            }
+            stack.push(node);
+        }
+    }
+    return rootChildren.map(toReadonlyTree);
+};

package/dist/pdf-config.js

@@ -69,6 +69,8 @@ export const loadEchoPdfConfig = (env) => {
     const providerOverride = env.ECHO_PDF_DEFAULT_PROVIDER;
     const modelOverride = env.ECHO_PDF_DEFAULT_MODEL;
     const publicBaseUrlOverride = env.ECHO_PDF_PUBLIC_BASE_URL;
+    const computeAuthHeaderOverride = env.ECHO_PDF_COMPUTE_AUTH_HEADER;
+    const computeAuthEnvOverride = env.ECHO_PDF_COMPUTE_AUTH_ENV;
     const fileGetAuthHeaderOverride = env.ECHO_PDF_FILE_GET_AUTH_HEADER;
     const fileGetAuthEnvOverride = env.ECHO_PDF_FILE_GET_AUTH_ENV;
     const fileGetCacheTtlOverride = env.ECHO_PDF_FILE_GET_CACHE_TTL_SECONDS;
@@ -79,6 +81,14 @@ export const loadEchoPdfConfig = (env) => {
             publicBaseUrl: typeof publicBaseUrlOverride === "string" && publicBaseUrlOverride.trim().length > 0
                 ? publicBaseUrlOverride.trim()
                 : resolved.service.publicBaseUrl,
+            computeAuth: {
+                authHeader: typeof computeAuthHeaderOverride === "string" && computeAuthHeaderOverride.trim().length > 0
+                    ? computeAuthHeaderOverride.trim()
+                    : resolved.service.computeAuth?.authHeader,
+                authEnv: typeof computeAuthEnvOverride === "string" && computeAuthEnvOverride.trim().length > 0
+                    ? computeAuthEnvOverride.trim()
+                    : resolved.service.computeAuth?.authEnv,
+            },
             fileGet: {
                 authHeader: typeof fileGetAuthHeaderOverride === "string" && fileGetAuthHeaderOverride.trim().length > 0
                     ? fileGetAuthHeaderOverride.trim()

package/dist/pdf-types.d.ts

@@ -20,6 +20,10 @@ export interface EchoPdfConfig {
     readonly service: {
         readonly name: string;
         readonly publicBaseUrl?: string;
+        readonly computeAuth?: {
+            readonly authHeader?: string;
+            readonly authEnv?: string;
+        };
         readonly fileGet?: {
             readonly authHeader?: string;
             readonly authEnv?: string;

package/dist/provider-client.d.ts

@@ -10,3 +10,11 @@ export declare const visionRecognize: (input: {
     imageDataUrl: string;
     runtimeApiKeys?: Record<string, string>;
 }) => Promise<string>;
+export declare const generateText: (input: {
+    config: EchoPdfConfig;
+    env: Env;
+    providerAlias: string;
+    model: string;
+    prompt: string;
+    runtimeApiKeys?: Record<string, string>;
+}) => Promise<string>;

package/dist/provider-client.js

@@ -132,3 +132,42 @@ export const visionRecognize = async (input) => {
     }
     return "";
 };
+export const generateText = async (input) => {
+    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: input.prompt,
+                },
+            ],
+        }),
+    }, provider.timeoutMs ?? 30000);
+    if (!response.ok) {
+        throw new Error(`Text generation request failed: HTTP ${response.status} url=${url} detail=${await responseDetail(response)}`);
+    }
+    const payload = await response.json();
+    const message = payload.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)
+            .filter((part) => part.type === "text" && typeof part.text === "string")
+            .map((part) => part.text ?? "")
+            .join("");
+    }
+    return "";
+};

package/dist/worker.js

@@ -111,6 +111,14 @@ const operationArgsFromRequest = (request) => {
         args.prompt = request.prompt;
     return args;
 };
+const checkComputeAuth = (request, env, config) => checkHeaderAuth(request, env, {
+    authHeader: config.service.computeAuth?.authHeader,
+    authEnv: config.service.computeAuth?.authEnv,
+    allowMissingSecret: false,
+    misconfiguredCode: "COMPUTE_AUTH_MISCONFIGURED",
+    unauthorizedCode: "UNAUTHORIZED",
+    contextName: "compute endpoint",
+});
 export default {
     async fetch(request, env, ctx) {
         const url = new URL(request.url);
@@ -149,6 +157,9 @@ export default {
             return json({ tools: listToolSchemas() });
         }
         if (request.method === "POST" && url.pathname === "/tools/call") {
+            const auth = checkComputeAuth(request, env, config);
+            if (!auth.ok)
+                return json({ error: auth.message, code: auth.code }, auth.status);
             const body = await readJson(request);
             const name = typeof body.name === "string" ? body.name : "";
             if (!name)
@@ -180,6 +191,9 @@ export default {
             }
         }
         if (request.method === "POST" && url.pathname === "/providers/models") {
+            const auth = checkComputeAuth(request, env, config);
+            if (!auth.ok)
+                return json({ error: auth.message, code: auth.code }, auth.status);
             const body = await readJson(request);
             const provider = resolveProviderAlias(config, typeof body.provider === "string" ? body.provider : undefined);
             const runtimeKeys = typeof body.providerApiKeys === "object" && body.providerApiKeys !== null
@@ -194,6 +208,9 @@ export default {
             }
         }
         if (request.method === "POST" && url.pathname === "/api/agent/run") {
+            const auth = checkComputeAuth(request, env, config);
+            if (!auth.ok)
+                return json({ error: auth.message, code: auth.code }, auth.status);
             const body = await readJson(request);
             if (Object.hasOwn(body, "operation") && !isValidOperation(body.operation)) {
                 return json({ error: "Invalid operation. Must be one of: extract_pages, ocr_pages, tables_to_latex" }, 400);
@@ -213,6 +230,9 @@ export default {
             }
         }
         if (request.method === "POST" && url.pathname === "/api/agent/stream") {
+            const auth = checkComputeAuth(request, env, config);
+            if (!auth.ok)
+                return json({ error: auth.message, code: auth.code }, auth.status);
             const body = await readJson(request);
             if (Object.hasOwn(body, "operation") && !isValidOperation(body.operation)) {
                 return json({ error: "Invalid operation. Must be one of: extract_pages, ocr_pages, tables_to_latex" }, 400);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@echofiles/echo-pdf",
-  "description": "MCP-first PDF agent on Cloudflare Workers with CLI and web demo.",
-  "version": "0.4.2",
+  "description": "Local-first PDF document component core with CLI, workspace artifacts, and reusable page primitives.",
+  "version": "0.5.0",
   "type": "module",
   "publishConfig": {
     "access": "public"
@@ -20,6 +20,10 @@
       "types": "./dist/core/index.d.ts",
       "import": "./dist/core/index.js"
     },
+    "./local": {
+      "types": "./dist/local/index.d.ts",
+      "import": "./dist/local/index.js"
+    },
     "./worker": {
       "types": "./dist/worker.d.ts",
       "import": "./dist/worker.js"
@@ -38,6 +42,13 @@
     "check:runtime": "bash ./scripts/check-runtime.sh",
     "dev": "wrangler dev",
     "deploy": "wrangler deploy",
+    "document:dev": "ECHO_PDF_SOURCE_DEV=1 bun ./bin/echo-pdf.js",
+    "eval": "node ./eval/run-local.mjs",
+    "eval:smoke": "node ./eval/run-local.mjs --suite smoke",
+    "eval:core": "node ./eval/run-local.mjs --suite core",
+    "eval:stress": "node ./eval/run-local.mjs --suite stress",
+    "eval:known-bad": "node ./eval/run-local.mjs --suite known-bad",
+    "eval:fetch-public-samples": "node ./eval/fetch-public-samples.mjs",
     "typecheck": "npm run check:runtime && tsc --noEmit",
     "test:unit": "npm run check:runtime && vitest run tests/unit",
     "test:import-smoke": "npm run check:runtime && npm run build && vitest run tests/integration/npm-pack-import.integration.test.ts tests/integration/ts-nodenext-consumer.integration.test.ts",