@xpert-ai/plugin-opendataloader 0.0.1

package/.xpertai-plugin/plugin.json

@@ -0,0 +1,5 @@
+{
+  "name": "@xpert-ai/plugin-opendataloader",
+  "version": "0.0.1",
+  "sandboxActions": "./dist/sandbox-actions/convert/action.json"
+}

package/README.md

@@ -0,0 +1,48 @@
+# OpenDataLoader PDF
+
+Knowledge-base document parser `@xpert-ai/plugin-opendataloader`. Install as a **system plugin**; it registers the `opendataloader` transformer and `opendataloader.convert` Sandbox Action (1.2.1).
+
+## Execution
+
+- Uses platform Sandbox Jobs and scoped Workspace Files. API processes do not load native modules or start Java themselves.
+- Runtime profile: `document/java-17/v1`. Conversion dependencies are installed, pinned and verified by the host Runtime Suite.
+- No URL, token, executable-path or dependency-installation settings in the parser form.
+- Input limit 100 MiB; output/decoded assets limit 128 MiB; 1,000 assets maximum; job timeout 300 seconds.
+- Each conversion uses tenant/document/content/runtime-scoped identity and unique persisted asset paths. Cancelling processing cancels the same Job, including retries.
+- Conversion failures are failed Jobs and retain their parser error code and affected pages. Retrying after recovery executes again; successful results are reused only for the same conversion identity, including the Runtime dependency fingerprint.
+
+## Formats and limits
+
+Supports **PDF only**, using Java 17 and the official OpenDataLoader PDF 2.5.8 CLI JAR. Native text pages retain their Java extraction results. Pages without verified text use the official Hybrid OCR backend through a job-local Python process with Docling/EasyOCR, simplified Chinese and English models, and CPU execution. The managed Runtime preinstalls the Python dependencies and model weights; jobs do not download models or call an external OCR service. The local backend is stopped when the Job ends or fails.
+
+The parser form exposes an **OCR minimum confidence** slider (`ocrConfidenceThreshold`, 0–1, default 0.5). Lower values retain more uncertain recognized text; the setting applies to OCR pages and participates in the conversion identity.
+
+Markdown page separators and JSON page evidence must agree. OCR that cannot verify all requested pages fails explicitly instead of returning partial success; blank pages are not guessed from missing text. OCR uses the same 300-second Job budget, so large or slow scanned documents can time out.
+
+Text, tables, verified page numbers, external PNG images and the original JSON result are preserved. Extracted images are ordinary image assets; they are not labelled as full-page scans. Image paths must remain within the conversion directory; symlinks and traversal are rejected.
+
+## Local development
+
+The host must include this Runtime profile and support knowledge-document `fileScope`. Use the platform-managed installer from the host checkout with Node 20.20.2:
+
+```sh
+corepack pnpm --filter @xpert-ai/sandbox-runtime install:document-java
+corepack pnpm --filter @xpert-ai/sandbox-runtime verify:local-document-java
+```
+
+Local process execution is development/test only. Production needs a published `document-java` OCI image bound through the existing Runtime infrastructure; jobs use non-root, read-only filesystem and network isolation. Installing this plugin does not publish/bind a Runtime image.
+
+From `xpertai/`:
+
+```sh
+corepack pnpm exec nx run @xpert-ai/plugin-opendataloader:build
+corepack pnpm exec nx run @xpert-ai/plugin-opendataloader:test
+```
+
+From the repository root:
+
+```sh
+node plugin-dev-harness/dist/index.js --workspace ./xpertai --plugin @xpert-ai/plugin-opendataloader
+```
+
+The installable package includes `.xpertai-plugin/plugin.json`, which declares `dist/sandbox-actions/convert/action.json`, and its hashed bundle. Official artwork is bundled under `dist/_assets` and shared by the plugin card and parser metadata; displaying it does not fetch external URLs. After installing from this workspace into the local host, restart the API explicitly, then select OpenDataLoader PDF under the relevant file type. Existing documents need reprocessing to use a new parser. Browser/knowledge-base indexing acceptance is separate from converter and lifecycle tests.

package/dist/_assets/README.md

@@ -0,0 +1,8 @@
+# Official branding asset
+
+- Source: https://opendataloader.org/logo-icon.webp
+- Retrieved: 2026-09-15
+- SHA-256: `50b7dc9964a73bad4e3eae26f03ee58cccca1b1a5ae087fee0bb624b3b9e40e5`
+- Kept unmodified and bundled locally for plugin and parser identification.
+
+The original project retains its branding rights.

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+import type { XpertPlugin } from '@xpert-ai/plugin-sdk';
+declare const plugin: XpertPlugin;
+export default plugin;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAA;AAIvD,QAAA,MAAM,MAAM,EAAE,WAuBb,CAAA;AACD,eAAe,MAAM,CAAA"}

package/dist/index.js

@@ -0,0 +1,29 @@
+import { readFileSync } from 'node:fs';
+import { OpenDataLoaderPluginModule } from './lib/plugin.module.js';
+import { ConfigSchema, Icon } from './lib/types.js';
+const pkg = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8'));
+const plugin = {
+    meta: {
+        name: pkg.name,
+        version: pkg.version,
+        level: 'system',
+        artifactNamespace: 'opendataloader',
+        category: 'integration',
+        displayName: 'OpenDataLoader PDF',
+        description: 'Offline knowledge document parsing through platform-managed Sandbox Jobs.',
+        icon: Icon,
+        keywords: ['document', 'parser', 'pdf', 'opendataloader'],
+        author: 'XpertAI Team'
+    },
+    config: { schema: ConfigSchema, formSchema: { type: 'object', properties: {} } },
+    register() {
+        return { module: OpenDataLoaderPluginModule, global: true };
+    },
+    onStart(ctx) {
+        ctx.logger.log('OpenDataLoader PDF parser started');
+    },
+    onStop(ctx) {
+        ctx.logger.log('OpenDataLoader PDF parser stopped');
+    }
+};
+export default plugin;

package/dist/lib/convert.d.ts

@@ -0,0 +1,35 @@
+import { type AgentMiddlewareRuntimeCapabilityRegistry, type WorkspaceFileScope } from '@xpert-ai/plugin-sdk';
+import { type OpenDataLoaderParserConfig } from './types.js';
+export type OpenDataLoaderFileScope = WorkspaceFileScope & {
+    organizationId?: string | null;
+};
+export declare class OpenDataLoaderSandboxConverter {
+    private readonly capabilities?;
+    constructor(capabilities?: Pick<AgentMiddlewareRuntimeCapabilityRegistry, 'get'>);
+    checkHealth(): Promise<import("@xpert-ai/plugin-sdk").SandboxJobActionHealth>;
+    convert(filePath: string, extension: string, options: OpenDataLoaderParserConfig & {
+        fileScope?: OpenDataLoaderFileScope;
+        documentId?: string;
+        stage: 'test' | 'prod';
+        signal?: AbortSignal;
+    }): Promise<{
+        sandboxJobId: string;
+        runtimeProfile: string;
+        ok?: true;
+        pages?: {
+            markdown?: string;
+            page?: number;
+        }[];
+        markdown?: string;
+        assets?: {
+            page?: number;
+            name?: string;
+            mimeType?: string;
+            data?: string;
+            size?: number;
+            sha256?: string;
+        }[];
+    }>;
+    private runtime;
+}
+//# sourceMappingURL=convert.d.ts.map

package/dist/lib/convert.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"convert.d.ts","sourceRoot":"","sources":["../../src/lib/convert.ts"],"names":[],"mappings":"AAEA,OAAO,EAKL,KAAK,wCAAwC,EAC7C,KAAK,kBAAkB,EACxB,MAAM,sBAAsB,CAAA;AAE7B,OAAO,EAML,KAAK,0BAA0B,EAChC,MAAM,YAAY,CAAA;AAEnB,MAAM,MAAM,uBAAuB,GAAG,kBAAkB,GAAG;IAAE,cAAc,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,CAAA;AAgD7F,qBACa,8BAA8B;IAIvC,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAC;gBAAb,YAAY,CAAC,EAAE,IAAI,CAAC,wCAAwC,EAAE,KAAK,CAAC;IAGjF,WAAW;IAkBX,OAAO,CACX,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,0BAA0B,GAAG;QACpC,SAAS,CAAC,EAAE,uBAAuB,CAAA;QACnC,UAAU,CAAC,EAAE,MAAM,CAAA;QACnB,KAAK,EAAE,MAAM,GAAG,MAAM,CAAA;QACtB,MAAM,CAAC,EAAE,WAAW,CAAA;KACrB;;;;;;;;;;;;;;;;;;IAuHH,OAAO,CAAC,OAAO;CAShB"}

package/dist/lib/convert.js

@@ -0,0 +1,232 @@
+import { __decorate, __metadata, __param } from "tslib";
+import { Inject, Injectable, Optional, ServiceUnavailableException } from '@nestjs/common';
+import { createHash } from 'node:crypto';
+import { isSandboxJobRuntimeError, SandboxJobsRuntimeCapability, WorkspaceFilesRuntimeCapability, XPERT_RUNTIME_CAPABILITIES_TOKEN } from '@xpert-ai/plugin-sdk';
+import { z } from 'zod';
+import { PACKAGE_NAME, ACTION, ACTION_VERSION, FILE_TYPES, ParserConfigSchema } from './types.js';
+const failureSchema = z.object({
+    ok: z.literal(false),
+    code: z.enum([
+        'EMPTY_FILE',
+        'EMPTY_TEXT',
+        'INPUT_TOO_LARGE',
+        'OUTPUT_TOO_LARGE',
+        'INVALID_DOCUMENT',
+        'ENCRYPTED',
+        'UNSUPPORTED_FORMAT',
+        'NEEDS_OCR',
+        'OCR_FAILED',
+        'INCOMPLETE_PAGES',
+        'RESOURCE_LIMIT',
+        'RUNTIME_INVALID',
+        'INVALID_CONFIG'
+    ]),
+    pages: z.array(z.number().int().positive().max(10000)).max(100).optional()
+});
+const resultSchema = z.discriminatedUnion('ok', [
+    failureSchema,
+    z.object({
+        ok: z.literal(true),
+        markdown: z.string().min(1),
+        pages: z
+            .array(z.object({ page: z.number().int().positive(), markdown: z.string() }))
+            .max(10000)
+            .optional(),
+        assets: z
+            .array(z.object({
+            name: z.string().regex(/^[a-zA-Z0-9_-]+\.[a-zA-Z0-9]+$/),
+            mimeType: z.string().max(100),
+            data: z.string(),
+            size: z
+                .number()
+                .int()
+                .nonnegative()
+                .max(128 * 1024 * 1024),
+            sha256: z.string().regex(/^[a-f0-9]{64}$/),
+            page: z.number().int().positive().optional()
+        }))
+            .max(1000)
+    })
+]);
+let OpenDataLoaderSandboxConverter = class OpenDataLoaderSandboxConverter {
+    constructor(capabilities) {
+        this.capabilities = capabilities;
+    }
+    async checkHealth() {
+        const { jobs } = this.runtime();
+        const health = await jobs.getActionHealth({
+            pluginName: PACKAGE_NAME,
+            action: ACTION,
+            actionVersion: ACTION_VERSION
+        });
+        if (!health.available)
+            throw new ServiceUnavailableException(health.reason === 'ACTION_MISSING'
+                ? 'OpenDataLoader Sandbox Action is missing (ACTION_MISSING). Install OpenDataLoader as a system plugin, then restart the API.'
+                : `OpenDataLoader Sandbox Runtime is unavailable (${health.reason ?? 'RUNTIME_UNBOUND'}). ${health.message ?? 'Check the platform Sandbox Runtime configuration.'}`);
+        return health;
+    }
+    async convert(filePath, extension, options) {
+        const parserConfig = ParserConfigSchema.parse(options);
+        if (!FILE_TYPES.includes(extension))
+            throw new Error(`OpenDataLoader does not support this file type: ${extension}`);
+        const scope = options.fileScope;
+        if (!scope?.tenantId || scope.catalog !== 'knowledges' || !scope.scopeId) {
+            throw new Error('OpenDataLoader requires the host knowledge-base file scope');
+        }
+        options.signal?.throwIfAborted();
+        const health = await this.checkHealth();
+        const { files, jobs } = this.runtime();
+        const reference = await files.resolveRuntimeReference({
+            ...scope,
+            source: 'platform.workspace.files',
+            filePath,
+            workspacePath: filePath
+        });
+        const source = await files.readBuffer(reference);
+        if (!source.buffer.length)
+            throw new Error('OPENDATALOADER_EMPTY_FILE');
+        if (source.buffer.length > 100 * 1024 * 1024)
+            throw new Error('OPENDATALOADER_INPUT_TOO_LARGE');
+        const checksum = sha256(source.buffer);
+        const identity = sha256(JSON.stringify([
+            scope.tenantId,
+            scope.organizationId,
+            scope.userId,
+            scope.scopeId,
+            options.documentId,
+            reference.filePath,
+            extension,
+            checksum,
+            options.stage,
+            ACTION_VERSION,
+            health.sandboxRuntimeVersion,
+            health.artifactDigest,
+            health.manifest?.dependenciesSha256,
+            parserConfig
+        ]));
+        // A retry reattaches Core's existing Job; cancellation must target that same ID.
+        const jobId = jobIdFromIdentity(identity);
+        const folder = `opendataloader/jobs/${identity}`;
+        options.signal?.throwIfAborted();
+        let cancelRetry;
+        const cancel = () => {
+            // Abort can arrive before Core persists the Job. Retry until it exists or run() settles.
+            const attempt = () => void jobs
+                .cancel({ jobId })
+                .then(() => clearInterval(cancelRetry))
+                .catch(() => undefined);
+            cancelRetry = setInterval(attempt, 100);
+            cancelRetry.unref();
+            attempt();
+        };
+        options.signal?.addEventListener('abort', cancel, { once: true });
+        try {
+            const result = await jobs
+                .run({
+                jobId,
+                action: ACTION,
+                actionVersion: ACTION_VERSION,
+                idempotencyKey: `opendataloader:${identity}`,
+                scope: {
+                    tenantId: scope.tenantId,
+                    organizationId: scope.organizationId,
+                    userId: scope.userId,
+                    pluginName: PACKAGE_NAME,
+                    businessResourceType: 'knowledge-document',
+                    businessResourceId: options.documentId ?? identity
+                },
+                payload: { extension, ...parserConfig },
+                files: [{ reference, targetPath: 'source.bin', size: source.buffer.length, sha256: checksum }],
+                outputs: [
+                    {
+                        path: 'result.json',
+                        originalName: 'result.json',
+                        mimeType: 'application/json',
+                        destination: { ...scope, folder }
+                    }
+                ],
+                timeoutMs: 300000
+            })
+                .catch(rethrowConversionFailure);
+            options.signal?.throwIfAborted();
+            const output = result.outputs.find((item) => item.path === 'result.json');
+            if (!output || output.size > 128 * 1024 * 1024)
+                throw new Error('OpenDataLoader Sandbox output is missing or exceeds its limit');
+            const content = await files.readBuffer(output.reference);
+            if (content.buffer.length > 128 * 1024 * 1024)
+                throw new Error('OPENDATALOADER_OUTPUT_TOO_LARGE');
+            if (content.buffer.length !== output.size || sha256(content.buffer) !== output.sha256) {
+                throw new Error('OpenDataLoader Sandbox output integrity check failed');
+            }
+            const converted = resultSchema.parse(JSON.parse(content.buffer.toString('utf8')));
+            if (converted.ok === false)
+                throw Object.assign(new Error(`OPENDATALOADER_${converted.code}`), { pages: converted.pages });
+            let decodedSize = Buffer.byteLength(converted.markdown);
+            const names = new Set();
+            for (const asset of converted.assets) {
+                const data = Buffer.from(asset.data, 'base64');
+                if (names.has(asset.name) ||
+                    data.toString('base64') !== asset.data ||
+                    data.length !== asset.size ||
+                    sha256(data) !== asset.sha256)
+                    throw new Error('OPENDATALOADER_INVALID_DOCUMENT');
+                names.add(asset.name);
+                decodedSize += data.length;
+                if (decodedSize > 128 * 1024 * 1024)
+                    throw new Error('OPENDATALOADER_OUTPUT_TOO_LARGE');
+            }
+            if (!converted.markdown.trim())
+                throw new Error('OPENDATALOADER_EMPTY_TEXT');
+            return { ...converted, sandboxJobId: result.id, runtimeProfile: result.runtimeProfile };
+        }
+        finally {
+            options.signal?.removeEventListener('abort', cancel);
+            clearInterval(cancelRetry);
+        }
+    }
+    runtime() {
+        const jobs = this.capabilities?.get(SandboxJobsRuntimeCapability);
+        const files = this.capabilities?.get(WorkspaceFilesRuntimeCapability);
+        if (!jobs || !files)
+            throw new ServiceUnavailableException('OpenDataLoader requires platform Sandbox Jobs and Workspace Files. Update and restart the API.');
+        return { jobs, files };
+    }
+};
+OpenDataLoaderSandboxConverter = __decorate([
+    Injectable(),
+    __param(0, Optional()),
+    __param(0, Inject(XPERT_RUNTIME_CAPABILITIES_TOKEN)),
+    __metadata("design:paramtypes", [Object])
+], OpenDataLoaderSandboxConverter);
+export { OpenDataLoaderSandboxConverter };
+/** Restore only the bounded error envelope emitted by this Action, retaining other Runtime failures. */
+function rethrowConversionFailure(error) {
+    if (isSandboxJobRuntimeError(error)) {
+        const match = error.message.match(/^OPENDATALOADER_CONVERSION_ERROR: (\{[^\r\n]{1,2048}\})$/m);
+        let failure;
+        if (match) {
+            try {
+                const parsed = failureSchema.safeParse(JSON.parse(match[1]));
+                if (parsed.success)
+                    failure = parsed.data;
+            }
+            catch {
+                // Malformed or truncated output remains the original Runtime error.
+            }
+        }
+        if (failure)
+            throw Object.assign(new Error(`OPENDATALOADER_${failure.code}`), { pages: failure.pages });
+    }
+    throw error;
+}
+function sha256(value) {
+    return createHash('sha256').update(value).digest('hex');
+}
+/** UUIDv8 derived from the tenant-scoped conversion identity. */
+function jobIdFromIdentity(identity) {
+    const bytes = Buffer.from(identity.slice(0, 32), 'hex');
+    bytes[6] = (bytes[6] & 0x0f) | 0x80;
+    bytes[8] = (bytes[8] & 0x3f) | 0x80;
+    const hex = bytes.toString('hex');
+    return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}

package/dist/lib/plugin-opendataloader.d.ts

@@ -0,0 +1,2 @@
+export declare function pluginOpendataloader(): string;
+//# sourceMappingURL=plugin-opendataloader.d.ts.map

package/dist/lib/plugin-opendataloader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin-opendataloader.d.ts","sourceRoot":"","sources":["../../src/lib/plugin-opendataloader.ts"],"names":[],"mappings":"AAAA,wBAAgB,oBAAoB,IAAI,MAAM,CAE7C"}

package/dist/lib/plugin-opendataloader.js

@@ -0,0 +1,3 @@
+export function pluginOpendataloader() {
+    return 'plugin-opendataloader';
+}

package/dist/lib/plugin.module.d.ts

@@ -0,0 +1,3 @@
+export declare class OpenDataLoaderPluginModule {
+}
+//# sourceMappingURL=plugin.module.d.ts.map

package/dist/lib/plugin.module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin.module.d.ts","sourceRoot":"","sources":["../../src/lib/plugin.module.ts"],"names":[],"mappings":"AAGA,qBACa,0BAA0B;CAAG"}

package/dist/lib/plugin.module.js

@@ -0,0 +1,10 @@
+import { __decorate } from "tslib";
+import { XpertServerPlugin } from '@xpert-ai/plugin-sdk';
+import { OpenDataLoaderSandboxConverter } from './convert.js';
+import { OpenDataLoaderTransformerStrategy } from './transformer.strategy.js';
+let OpenDataLoaderPluginModule = class OpenDataLoaderPluginModule {
+};
+OpenDataLoaderPluginModule = __decorate([
+    XpertServerPlugin({ providers: [OpenDataLoaderSandboxConverter, OpenDataLoaderTransformerStrategy] })
+], OpenDataLoaderPluginModule);
+export { OpenDataLoaderPluginModule };

package/dist/lib/transformer.strategy.d.ts

@@ -0,0 +1,62 @@
+import { type IDocumentTransformerStrategy, type Permissions, type TDocumentTransformerConfig, type WorkspaceFileScope } from '@xpert-ai/plugin-sdk';
+import { OpenDataLoaderSandboxConverter } from './convert.js';
+import { type OpenDataLoaderParserConfig } from './types.js';
+type Config = TDocumentTransformerConfig & OpenDataLoaderParserConfig & {
+    signal?: AbortSignal;
+    fileScope?: WorkspaceFileScope;
+};
+type Documents = Parameters<IDocumentTransformerStrategy['transformDocuments']>[0];
+type Results = Awaited<ReturnType<IDocumentTransformerStrategy['transformDocuments']>>;
+export declare class OpenDataLoaderTransformerStrategy implements IDocumentTransformerStrategy<Config> {
+    private readonly converter;
+    constructor(converter: OpenDataLoaderSandboxConverter);
+    readonly permissions: Permissions;
+    readonly meta: {
+        name: string;
+        label: {
+            en_US: string;
+            zh_Hans: string;
+        };
+        description: {
+            en_US: string;
+            zh_Hans: string;
+        };
+        icon: {
+            type: "image";
+            value: string;
+        };
+        supportedFileTypes: string[];
+        providesImageText: boolean;
+        configSchema: {
+            type: string;
+            properties: {
+                ocrConfidenceThreshold: {
+                    type: string;
+                    title: {
+                        en_US: string;
+                        zh_Hans: string;
+                    };
+                    description: {
+                        en_US: string;
+                        zh_Hans: string;
+                    };
+                    default: number;
+                    minimum: number;
+                    maximum: number;
+                    'x-ui': {
+                        component: string;
+                        inputs: {
+                            min: number;
+                            max: number;
+                            step: number;
+                        };
+                    };
+                };
+            };
+        };
+    };
+    validateConfig(config: Config): Promise<void>;
+    transformDocuments(documents: Documents, config: Config): Promise<Results>;
+}
+export {};
+//# sourceMappingURL=transformer.strategy.d.ts.map

package/dist/lib/transformer.strategy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transformer.strategy.d.ts","sourceRoot":"","sources":["../../src/lib/transformer.strategy.ts"],"names":[],"mappings":"AACA,OAAO,EAEL,KAAK,4BAA4B,EACjC,KAAK,WAAW,EAEhB,KAAK,0BAA0B,EAC/B,KAAK,kBAAkB,EACxB,MAAM,sBAAsB,CAAA;AAE7B,OAAO,EAAE,8BAA8B,EAAE,MAAM,cAAc,CAAA;AAC7D,OAAO,EAAwC,KAAK,0BAA0B,EAAqB,MAAM,YAAY,CAAA;AAErH,KAAK,MAAM,GAAG,0BAA0B,GACtC,0BAA0B,GAAG;IAAE,MAAM,CAAC,EAAE,WAAW,CAAC;IAAC,SAAS,CAAC,EAAE,kBAAkB,CAAA;CAAE,CAAA;AACvF,KAAK,SAAS,GAAG,UAAU,CAAC,4BAA4B,CAAC,oBAAoB,CAAC,CAAC,CAAC,CAAC,CAAC,CAAA;AAClF,KAAK,OAAO,GAAG,OAAO,CAAC,UAAU,CAAC,4BAA4B,CAAC,oBAAoB,CAAC,CAAC,CAAC,CAAA;AACtF,qBAEa,iCAAkC,YAAW,4BAA4B,CAAC,MAAM,CAAC;IAChF,OAAO,CAAC,QAAQ,CAAC,SAAS;gBAAT,SAAS,EAAE,8BAA8B;IACtE,QAAQ,CAAC,WAAW,EAAE,WAAW,CAAqE;IACtG,QAAQ,CAAC,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA+BZ;IACK,cAAc,CAAC,MAAM,EAAE,MAAM;IAK7B,kBAAkB,CAAC,SAAS,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;CAiEjF"}

package/dist/lib/transformer.strategy.js

@@ -0,0 +1,120 @@
+import { __decorate, __metadata } from "tslib";
+import { Injectable } from '@nestjs/common';
+import { DocumentTransformerStrategy } from '@xpert-ai/plugin-sdk';
+import { randomUUID } from 'node:crypto';
+import { OpenDataLoaderSandboxConverter } from './convert.js';
+import { FILE_TYPES, Icon, ParserConfigSchema, documentExtension } from './types.js';
+let OpenDataLoaderTransformerStrategy = class OpenDataLoaderTransformerStrategy {
+    constructor(converter) {
+        this.converter = converter;
+        this.permissions = [{ type: 'filesystem', operations: ['read', 'write'], scope: [] }];
+        this.meta = {
+            name: 'opendataloader',
+            label: { en_US: 'OpenDataLoader PDF', zh_Hans: 'OpenDataLoader PDF' },
+            description: {
+                en_US: 'Offline PDF text extraction with local OCR for scanned pages, using platform Sandbox Jobs.',
+                zh_Hans: '通过平台沙箱离线解析 PDF；扫描页自动使用本地 OCR 识别中文和英文。'
+            },
+            icon: Icon,
+            supportedFileTypes: FILE_TYPES,
+            providesImageText: false,
+            configSchema: {
+                type: 'object',
+                properties: {
+                    ocrConfidenceThreshold: {
+                        type: 'number',
+                        title: { en_US: 'Minimum OCR confidence', zh_Hans: 'OCR 最低置信度' },
+                        description: {
+                            en_US: 'Text below this confidence is discarded. Lower values retain more text but may include recognition errors. Applies to scanned pages.',
+                            zh_Hans: '低于此置信度的文字会被丢弃。降低数值可保留更多文字，也可能保留误识别内容。仅影响扫描页 OCR。'
+                        },
+                        default: 0.5,
+                        minimum: 0,
+                        maximum: 1,
+                        'x-ui': {
+                            component: 'slider',
+                            inputs: { min: 0, max: 1, step: 0.01 }
+                        }
+                    }
+                }
+            }
+        };
+    }
+    async validateConfig(config) {
+        config.signal?.throwIfAborted();
+        ParserConfigSchema.parse(config);
+        await this.converter.checkHealth();
+    }
+    async transformDocuments(documents, config) {
+        const fs = config.permissions?.fileSystem;
+        if (!fs)
+            throw new Error('OpenDataLoader PDF requires the scoped knowledge-base filesystem');
+        const output = [];
+        for (const document of documents) {
+            config.signal?.throwIfAborted();
+            const extension = documentExtension(document.type, document.mimeType);
+            if (!document.filePath || !FILE_TYPES.includes(extension))
+                throw new Error('OPENDATALOADER_UNSUPPORTED_FORMAT');
+            const result = await this.converter.convert(document.filePath, extension, {
+                signal: config.signal,
+                fileScope: config.fileScope,
+                documentId: document.id,
+                stage: config.stage,
+                ocrConfidenceThreshold: config.ocrConfidenceThreshold
+            });
+            const folder = 'opendataloader/' + randomUUID();
+            const assets = [];
+            const references = new Map();
+            for (const asset of result.assets) {
+                config.signal?.throwIfAborted();
+                const filePath = `${folder}/${asset.name}`;
+                const url = await fs.writeFile(filePath, Buffer.from(asset.data, 'base64'));
+                references.set(`xpert-asset://${asset.name}`, url);
+                assets.push({
+                    type: /^(image\/(png|jpeg|gif|webp))$/.test(asset.mimeType) ? 'image' : 'file',
+                    filePath,
+                    url,
+                    order: assets.length,
+                    ...(asset.page ? { page: asset.page } : {})
+                });
+            }
+            const replaceReferences = (text) => text.replace(/xpert-asset:\/\/[a-zA-Z0-9_-]+\.[a-zA-Z0-9]+/g, (match) => references.get(match) ?? match);
+            const markdown = replaceReferences(result.markdown);
+            const originalPath = `${folder}/result.md`;
+            assets.push({ type: 'file', filePath: originalPath, url: await fs.writeFile(originalPath, markdown) });
+            const pages = result.pages ?? [{ page: undefined, markdown: result.markdown }];
+            const chunks = pages
+                .filter((page) => page.markdown.trim())
+                .map((page, index) => ({
+                pageContent: replaceReferences(page.markdown),
+                metadata: {
+                    chunkId: randomUUID(),
+                    chunkIndex: index,
+                    parser: 'opendataloader',
+                    mediaType: 'text',
+                    contentFormat: 'markdown',
+                    ...(page.page ? { page: page.page } : {}),
+                    assets: assets.filter((asset) => asset.type === 'image' && (!page.page || asset.page === page.page))
+                }
+            }));
+            output.push({
+                id: document.id,
+                chunks,
+                metadata: {
+                    chunkId: randomUUID(),
+                    parser: 'opendataloader',
+                    sandboxJobId: result.sandboxJobId,
+                    runtimeProfile: result.runtimeProfile,
+                    assets
+                }
+            });
+        }
+        return output;
+    }
+};
+OpenDataLoaderTransformerStrategy = __decorate([
+    Injectable(),
+    DocumentTransformerStrategy('opendataloader'),
+    __metadata("design:paramtypes", [OpenDataLoaderSandboxConverter])
+], OpenDataLoaderTransformerStrategy);
+export { OpenDataLoaderTransformerStrategy };

package/dist/lib/types.d.ts

@@ -0,0 +1,23 @@
+import { z } from 'zod';
+export declare const PACKAGE_NAME = "@xpert-ai/plugin-opendataloader";
+export declare const PARSER_NAME = "opendataloader";
+export declare const FILE_TYPES: string[];
+export declare const ACTION = "opendataloader.convert";
+export declare const ACTION_VERSION = "1.2.1";
+export declare const PROFILE = "document/java-17/v1";
+export declare const ConfigSchema: z.ZodObject<{}, "strict", z.ZodTypeAny, {}, {}>;
+export declare const ParserConfigSchema: z.ZodObject<{
+    ocrConfidenceThreshold: z.ZodEffects<z.ZodOptional<z.ZodNullable<z.ZodNumber>>, number, number>;
+}, "strip", z.ZodTypeAny, {
+    ocrConfidenceThreshold?: number;
+}, {
+    ocrConfidenceThreshold?: number;
+}>;
+export type OpenDataLoaderParserConfig = z.input<typeof ParserConfigSchema>;
+export declare const Icon: {
+    type: "image";
+    value: string;
+};
+/** Host uploads usually supply an extension; MIME-only callers use the same upstream format. */
+export declare function documentExtension(type?: string, mimeType?: string): string;
+//# sourceMappingURL=types.d.ts.map

package/dist/lib/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/lib/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,eAAO,MAAM,YAAY,oCAAoC,CAAA;AAC7D,eAAO,MAAM,WAAW,mBAAmB,CAAA;AAC3C,eAAO,MAAM,UAAU,UAAU,CAAA;AACjC,eAAO,MAAM,MAAM,2BAA2B,CAAA;AAC9C,eAAO,MAAM,cAAc,UAAU,CAAA;AACrC,eAAO,MAAM,OAAO,wBAAwB,CAAA;AAC5C,eAAO,MAAM,YAAY,iDAAwB,CAAA;AACjD,eAAO,MAAM,kBAAkB;;;;;;EAQ7B,CAAA;AACF,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA;AAC3E,eAAO,MAAM,IAAI;;;CAGhB,CAAA;AAED,gGAAgG;AAChG,wBAAgB,iBAAiB,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM,CAsB1E"}

package/dist/lib/types.js

@@ -0,0 +1,45 @@
+import { z } from 'zod';
+import { readFileSync } from 'node:fs';
+export const PACKAGE_NAME = '@xpert-ai/plugin-opendataloader';
+export const PARSER_NAME = 'opendataloader';
+export const FILE_TYPES = ['pdf'];
+export const ACTION = 'opendataloader.convert';
+export const ACTION_VERSION = '1.2.1';
+export const PROFILE = 'document/java-17/v1';
+export const ConfigSchema = z.object({}).strict();
+export const ParserConfigSchema = z.object({
+    ocrConfidenceThreshold: z
+        .number()
+        .finite()
+        .min(0)
+        .max(1)
+        .nullish()
+        .transform((value) => value ?? 0.5)
+});
+export const Icon = {
+    type: 'image',
+    value: `data:image/webp;base64,${readFileSync(new URL('../_assets/icon.webp', import.meta.url)).toString('base64')}`
+};
+/** Host uploads usually supply an extension; MIME-only callers use the same upstream format. */
+export function documentExtension(type, mimeType) {
+    const value = (type && type !== 'unknown' ? type : mimeType)
+        ?.split(';')[0]
+        .trim()
+        .toLowerCase()
+        .replace(/^.*\//, '')
+        .replace(/^\./, '') ?? '';
+    const aliases = {
+        msword: 'doc',
+        'vnd.ms-powerpoint': 'ppt',
+        'vnd.ms-excel': 'xls',
+        'vnd.openxmlformats-officedocument.wordprocessingml.document': 'docx',
+        'vnd.openxmlformats-officedocument.presentationml.presentation': 'pptx',
+        'vnd.openxmlformats-officedocument.spreadsheetml.sheet': 'xlsx',
+        'vnd.oasis.opendocument.text': 'odt',
+        'vnd.oasis.opendocument.spreadsheet': 'ods',
+        'vnd.oasis.opendocument.presentation': 'odp',
+        'epub+zip': 'epub',
+        'x-rtf': 'rtf'
+    };
+    return Object.prototype.hasOwnProperty.call(aliases, value) ? aliases[value] : value;
+}

package/dist/sandbox-actions/convert/action.json

@@ -0,0 +1,9 @@
+{
+  "name": "opendataloader.convert",
+  "version": "1.2.1",
+  "runtimeProfile": "document/java-17/v1",
+  "runtimeContractVersion": "1",
+  "bundle": "./bundle",
+  "entrypoint": "runner.mjs",
+  "bundleSha256": "a268595f7ae831799e4d7b3e5d4e4d93e7ccf0e8349ea4ea39d241a18c70a8e6"
+}

package/dist/sandbox-actions/convert/bundle/convert.mjs

@@ -0,0 +1,209 @@
+import { execFile } from 'node:child_process'
+import { promisify } from 'node:util'
+import { copyFile, mkdir, readFile, unlink } from 'node:fs/promises'
+import { randomUUID } from 'node:crypto'
+import path from 'node:path'
+import { INPUT_LIMIT, ASSET_LIMIT, asset, fail, finish, readBounded, safeOutput, checkOutputTree } from './result.mjs'
+import { normalizeOcrConfidenceThreshold, withOcrBackend } from './ocr.mjs'
+
+export async function convert(file, extension, output, ocrConfidenceThreshold) {
+  const threshold = normalizeOcrConfidenceThreshold(ocrConfidenceThreshold)
+  if (extension !== 'pdf') fail('UNSUPPORTED_FORMAT')
+  let bytes
+  try {
+    bytes = await readBounded(file, INPUT_LIMIT)
+  } catch (error) {
+    if (error.code === 'OUTPUT_TOO_LARGE') fail('INPUT_TOO_LARGE')
+    throw error
+  }
+  if (!bytes.length) fail('EMPTY_FILE')
+  if (!bytes.subarray(0, 1024).includes(Buffer.from('%PDF-'))) fail('INVALID_DOCUMENT')
+  const root = process.env.XPERT_SANDBOX_DOCUMENT_DEPENDENCY_ROOT
+  if (!root || !path.isAbsolute(root)) fail('RUNTIME_INVALID')
+  let lock
+  try {
+    lock = JSON.parse(await readFile(path.join(root, 'dependencies.lock.json'), 'utf8'))
+  } catch {
+    fail('RUNTIME_INVALID')
+  }
+  if (lock.cli?.jar !== 'opendataloader-pdf-cli-2.5.8.jar') fail('RUNTIME_INVALID')
+  return finish(
+    await convertPages(async (pages) => {
+      const work = path.join(output, `convert-${randomUUID()}`)
+      await mkdir(work, { recursive: true })
+      if (pages) return withOcrBackend(root, work, (url) => extractPdf(file, root, lock, work, pages, url), threshold)
+      return extractPdf(file, root, lock, work)
+    })
+  )
+}
+
+async function extractPdf(file, root, lock, work, pages, hybridUrl) {
+  await mkdir(work, { recursive: true })
+  const input = path.join(work, 'document.pdf')
+  await copyFile(file, input)
+  const separator = `XPERT-${randomUUID()}-PAGE-`
+  try {
+    await promisify(execFile)(
+      path.join(root, 'jre/bin/java'),
+      [
+        '-Djava.awt.headless=true',
+        `-Djava.io.tmpdir=${work}`,
+        '-Xmx2g',
+        '-jar',
+        path.join(root, 'cli', lock.cli.jar),
+        '--format',
+        'markdown,json',
+        '--output-dir',
+        work,
+        '--image-output',
+        'external',
+        '--image-format',
+        'png',
+        '--image-dir',
+        path.join(work, 'images'),
+        '--markdown-page-separator',
+        `${separator}%page-number%-END`,
+        '--reading-order',
+        'xycut',
+        '--threads',
+        '1',
+        ...(hybridUrl
+          ? [
+              '--pages',
+              pages.join(','),
+              '--hybrid',
+              'docling-fast',
+              '--hybrid-mode',
+              'full',
+              '--hybrid-url',
+              hybridUrl,
+              '--hybrid-timeout',
+              '240000'
+            ]
+          : ['--hybrid', 'off']),
+        '--quiet',
+        input
+      ],
+      { timeout: 290000, maxBuffer: 256 * 1024, killSignal: 'SIGKILL' }
+    )
+  } catch (error) {
+    if (error.killed || error.code === 'ERR_CHILD_PROCESS_STDIO_MAXBUFFER') fail('RESOURCE_LIMIT')
+    if (/password|encrypt/i.test(String(error.stderr ?? ''))) fail('ENCRYPTED')
+    if (hybridUrl && error.stderr)
+      process.stderr.write(`OpenDataLoader OCR conversion: ${String(error.stderr).slice(-8192)}\n`)
+    fail(hybridUrl ? 'OCR_FAILED' : 'INVALID_DOCUMENT', pages)
+  }
+  await unlink(input)
+  await checkOutputTree(work)
+  const raw = await readBounded(path.join(work, 'document.json'))
+  const markdown = (await readBounded(path.join(work, 'document.md'))).toString('utf8')
+  return { json: JSON.parse(raw), markdown, separator, root: work }
+}
+
+/** Preserve Java text verbatim; OCR receives only pages whose text coverage is missing. */
+export async function convertPages(extract) {
+  const native = await extract()
+  const result = await mapResult(native.json, native.markdown, native.separator, native.root, { allowUncovered: true })
+  const assets = [
+    ...result.assets,
+    asset('result-raw.json', 'application/json', Buffer.from(JSON.stringify(native.json)))
+  ]
+  let pages = result.pages
+  if (result.uncovered.length) {
+    const ocr = await extract(result.uncovered)
+    if (ocr.json['number of pages'] !== native.json['number of pages']) fail('INCOMPLETE_PAGES', result.uncovered)
+    const recognized = await mapResult(ocr.json, ocr.markdown, ocr.separator, ocr.root, {
+      selectedPages: result.uncovered,
+      assetPrefix: 'ocr-'
+    })
+    const replacements = new Map(recognized.pages.map((p) => [p.page, p]))
+    pages = pages.map((p) => replacements.get(p.page) ?? p)
+    assets.push(
+      ...recognized.assets,
+      asset('result-ocr.json', 'application/json', Buffer.from(JSON.stringify(ocr.json)))
+    )
+  }
+  return { markdown: pages.map((p) => p.markdown).join('\n\n'), pages, assets }
+}
+
+/** Coverage is established from page markers plus JSON text, never from filenames or missing text alone. */
+export async function mapResult(json, markdown, separator, root, options = {}) {
+  const count = json?.['number of pages']
+  if (!Number.isSafeInteger(count) || count <= 0 || count > 10000 || !Array.isArray(json.kids)) fail('INCOMPLETE_PAGES')
+  const pages = splitPages(markdown, separator, count, options.selectedPages)
+  const textPages = new Set(),
+    imagePages = new Set(),
+    images = []
+  let nodes = 0
+  function walk(value, inheritedPage, depth = 0) {
+    if (++nodes > 200000 || depth > 100) fail('RESOURCE_LIMIT')
+    if (!value || typeof value !== 'object') return
+    const page = value['page number'] ?? inheritedPage
+    if (value['page number'] != null && (!Number.isSafeInteger(page) || page < 1 || page > count))
+      fail('INCOMPLETE_PAGES')
+    if (page && typeof value.content === 'string' && value.content.trim()) textPages.add(page)
+    if (value.type === 'image') {
+      if (!page || typeof value.source !== 'string') fail('INCOMPLETE_PAGES')
+      imagePages.add(page)
+      images.push({ source: value.source, page })
+      if (images.length > ASSET_LIMIT) fail('OUTPUT_TOO_LARGE')
+    }
+    for (const child of Object.values(value))
+      if (child && typeof child === 'object') {
+        if (Array.isArray(child)) child.forEach((item) => walk(item, page, depth + 1))
+        else walk(child, page, depth + 1)
+      }
+  }
+  walk(json.kids)
+  const uncovered = pages.filter((p) => !textPages.has(p.page)).map((p) => p.page)
+  if (uncovered.length && !options.allowUncovered)
+    fail(
+      options.selectedPages
+        ? 'OCR_FAILED'
+        : uncovered.some((p) => imagePages.has(p))
+        ? 'NEEDS_OCR'
+        : 'INCOMPLETE_PAGES',
+      uncovered
+    )
+  const assets = []
+  const seenImages = new Set()
+  for (const image of images) {
+    // Full scan images on uncovered pages are replaced by OCR text, not sent to VLM again.
+    if (uncovered.includes(image.page)) continue
+    const source = image.source
+    const key = `${image.page}\0${source}`
+    if (seenImages.has(key)) continue
+    seenImages.add(key)
+    const file = await safeOutput(root, source)
+    const data = await readBounded(file)
+    if (!data.subarray(0, 8).equals(Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]))) fail('INVALID_DOCUMENT')
+    const name = `${options.assetPrefix ?? ''}image-${assets.length + 1}.png`
+    assets.push(asset(name, 'image/png', data, image.page))
+    const page = pages.find((page) => page.page === image.page)
+    if (!page) fail('INCOMPLETE_PAGES')
+    // Only generated image destinations are rewritten. Text, links and repeated basenames remain intact.
+    const escapedSource = source.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+    const reference = new RegExp(`(!\\[(?:\\\\.|[^\\]\\\\])*\\]\\()<${escapedSource}>(\\))`, 'g')
+    let matched = false
+    page.markdown = page.markdown.replace(reference, (_match, before, after) => {
+      matched = true
+      return `${before}xpert-asset://${name}${after}`
+    })
+    if (!matched) fail('INCOMPLETE_PAGES')
+  }
+  return { markdown: pages.map((p) => p.markdown).join('\n\n'), pages, assets, uncovered }
+}
+
+export function splitPages(markdown, separator, count, selectedPages) {
+  const expected = selectedPages ?? Array.from({ length: count }, (_, i) => i + 1)
+  const escaped = separator.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+  const matches = [...markdown.matchAll(new RegExp(`^${escaped}(\\d+)-END\\s*$`, 'gm'))]
+  if (matches.length !== expected.length || markdown.slice(0, matches[0]?.index).trim()) fail('INCOMPLETE_PAGES')
+  return matches.map((match, index) => {
+    if (Number(match[1]) !== expected[index]) fail('INCOMPLETE_PAGES')
+    return {
+      page: expected[index],
+      markdown: markdown.slice(match.index + match[0].length, matches[index + 1]?.index ?? markdown.length).trim()
+    }
+  })
+}

package/dist/sandbox-actions/convert/bundle/ocr.mjs

@@ -0,0 +1,88 @@
+// The backend belongs to this Job only. stdin closure also stops it when the Action is killed.
+import { spawn } from 'node:child_process'
+import { readFile } from 'node:fs/promises'
+import { once } from 'node:events'
+import path from 'node:path'
+import { fail } from './result.mjs'
+
+export function normalizeOcrConfidenceThreshold(value = 0.5) {
+  if (typeof value !== 'number' || !Number.isFinite(value) || value < 0 || value > 1) fail('INVALID_CONFIG')
+  return value
+}
+
+export async function withOcrBackend(root, work, convert, ocrConfidenceThreshold = 0.5) {
+  const threshold = normalizeOcrConfidenceThreshold(ocrConfidenceThreshold)
+  const ready = path.join(work, 'ocr-ready.json')
+  const child = spawn(
+    path.join(root, 'python/bin/python3'),
+    [
+      '-I',
+      '-X',
+      'faulthandler',
+      path.join(root, 'hybrid-backend.py'),
+      '--root',
+      root,
+      '--ready',
+      ready,
+      '--ocr-confidence-threshold',
+      String(threshold)
+    ],
+    {
+      stdio: ['pipe', 'ignore', 'pipe'],
+      env: {
+        ...process.env,
+        TMPDIR: work,
+        HOME: work,
+        XDG_CACHE_HOME: path.join(work, 'cache'),
+        HF_HUB_OFFLINE: '1',
+        TRANSFORMERS_OFFLINE: '1',
+        HF_HUB_DISABLE_TELEMETRY: '1',
+        DOCLING_ARTIFACTS_PATH: path.join(root, 'models'),
+        PYTHONDONTWRITEBYTECODE: '1',
+        OMP_NUM_THREADS: '2',
+        MKL_NUM_THREADS: '2',
+        OPENBLAS_NUM_THREADS: '2'
+      }
+    }
+  )
+  let spawnError,
+    diagnostics = ''
+  child.on('error', (error) => {
+    spawnError = error
+  })
+  child.stderr.on('data', (bytes) => {
+    diagnostics = (diagnostics + bytes.toString()).slice(-8192)
+  })
+  const exited = once(child, 'exit').catch(() => undefined)
+  try {
+    const deadline = Date.now() + 90000
+    while (Date.now() < deadline) {
+      if (spawnError || child.exitCode !== null || child.signalCode) fail('RUNTIME_INVALID')
+      let port
+      try {
+        port = JSON.parse(await readFile(ready, 'utf8')).port
+      } catch (error) {
+        if (error.code !== 'ENOENT') throw error
+      }
+      if (Number.isSafeInteger(port) && port > 0 && port <= 65535) {
+        const url = `http://127.0.0.1:${port}`
+        const health = await fetch(`${url}/health`, { signal: AbortSignal.timeout(1000) }).catch(() => undefined)
+        if (health?.ok) return await convert(url)
+      }
+      await new Promise((resolve) => setTimeout(resolve, 100))
+    }
+    fail('RESOURCE_LIMIT')
+  } catch (error) {
+    process.stderr.write(`OpenDataLoader OCR backend exit: code=${child.exitCode}, signal=${child.signalCode}\n`)
+    if (diagnostics) process.stderr.write(`OpenDataLoader OCR backend: ${diagnostics}\n`)
+    if (child.signalCode === 'SIGKILL') fail('RESOURCE_LIMIT')
+    throw error
+  } finally {
+    child.stdin.destroy()
+    child.kill('SIGTERM')
+    const kill = setTimeout(() => child.kill('SIGKILL'), 3000)
+    kill.unref()
+    if (!spawnError) await exited
+    clearTimeout(kill)
+  }
+}

package/dist/sandbox-actions/convert/bundle/result.mjs

@@ -0,0 +1,71 @@
+import { createHash } from 'node:crypto'
+import { readFile, lstat, realpath, readdir } from 'node:fs/promises'
+import path from 'node:path'
+export const INPUT_LIMIT = 100 * 1024 * 1024
+export const OUTPUT_LIMIT = 128 * 1024 * 1024
+export const ASSET_LIMIT = 1000
+export function fail(code, pages) {
+  throw Object.assign(new Error(code), { code, pages })
+}
+export function asset(name, mimeType, data, page) {
+  if (data.length > OUTPUT_LIMIT) fail('OUTPUT_TOO_LARGE')
+  return {
+    name,
+    mimeType,
+    size: data.length,
+    sha256: createHash('sha256').update(data).digest('hex'),
+    data: data.toString('base64'),
+    ...(page ? { page } : {})
+  }
+}
+export async function readBounded(file, limit = OUTPUT_LIMIT) {
+  const stat = await lstat(file)
+  if (!stat.isFile() || stat.isSymbolicLink()) fail('INVALID_DOCUMENT')
+  if (stat.size > limit) fail('OUTPUT_TOO_LARGE')
+  const data = await readFile(file)
+  if (data.length > limit) fail('OUTPUT_TOO_LARGE')
+  return data
+}
+export async function safeOutput(root, relative) {
+  if (
+    !relative ||
+    path.isAbsolute(relative) ||
+    /[\\\0]/.test(relative) ||
+    relative.split('/').some((p) => !p || p === '..' || p === '.')
+  )
+    fail('INVALID_DOCUMENT')
+  const target = path.join(root, relative)
+  let current = root
+  for (const part of relative.split('/')) {
+    current = path.join(current, part)
+    if ((await lstat(current)).isSymbolicLink()) fail('INVALID_DOCUMENT')
+  }
+  const resolved = await realpath(target)
+  if (!resolved.startsWith((await realpath(root)) + path.sep)) fail('INVALID_DOCUMENT')
+  return target
+}
+export async function checkOutputTree(root) {
+  let total = 0,
+    count = 0
+  async function visit(dir) {
+    for (const entry of await readdir(dir, { withFileTypes: true })) {
+      if (++count > 5000 || entry.isSymbolicLink()) fail('OUTPUT_TOO_LARGE')
+      const file = path.join(dir, entry.name)
+      if (entry.isDirectory()) await visit(file)
+      else {
+        const stat = await lstat(file)
+        if (!stat.isFile()) fail('INVALID_DOCUMENT')
+        total += stat.size
+        if (total > OUTPUT_LIMIT) fail('OUTPUT_TOO_LARGE')
+      }
+    }
+  }
+  await visit(root)
+}
+export function finish(result) {
+  if (!result.markdown.trim()) fail('EMPTY_TEXT')
+  if (result.assets.length > ASSET_LIMIT) fail('OUTPUT_TOO_LARGE')
+  const decoded = Buffer.byteLength(result.markdown) + result.assets.reduce((n, a) => n + a.size, 0)
+  if (decoded > OUTPUT_LIMIT || Buffer.byteLength(JSON.stringify(result)) > OUTPUT_LIMIT) fail('OUTPUT_TOO_LARGE')
+  return { ok: true, ...result }
+}

package/dist/sandbox-actions/convert/bundle/runner.mjs

@@ -0,0 +1,61 @@
+import { readFile, writeFile, mkdir } from 'node:fs/promises'
+import path from 'node:path'
+import { convert } from './convert.mjs'
+const argument = (name) => {
+  const index = process.argv.indexOf(name)
+  if (index < 0 || !process.argv[index + 1]) throw new Error('Invalid Action arguments')
+  return path.resolve(process.argv[index + 1])
+}
+try {
+  const requestPath = argument('--request'),
+    output = argument('--output')
+  const request = JSON.parse(await readFile(requestPath, 'utf8'))
+  if (
+    request.contractVersion !== '1' ||
+    request.action !== 'opendataloader.convert' ||
+    request.actionVersion !== '1.2.1'
+  )
+    throw new Error('Invalid Action contract')
+  await mkdir(output, { recursive: true })
+  let result
+  try {
+    result = await convert(
+      path.join(path.dirname(requestPath), 'source.bin'),
+      request.payload?.extension,
+      output,
+      request.payload?.ocrConfidenceThreshold
+    )
+  } catch (error) {
+    const codes = [
+      'EMPTY_FILE',
+      'EMPTY_TEXT',
+      'INPUT_TOO_LARGE',
+      'OUTPUT_TOO_LARGE',
+      'INVALID_DOCUMENT',
+      'ENCRYPTED',
+      'UNSUPPORTED_FORMAT',
+      'NEEDS_OCR',
+      'OCR_FAILED',
+      'INCOMPLETE_PAGES',
+      'RESOURCE_LIMIT',
+      'RUNTIME_INVALID',
+      'INVALID_CONFIG'
+    ]
+    result = {
+      ok: false,
+      code: codes.includes(error?.code) ? error.code : 'INVALID_DOCUMENT',
+      ...(Array.isArray(error?.pages)
+        ? { pages: error.pages.filter((n) => Number.isSafeInteger(n) && n > 0 && n <= 10000).slice(0, 100) }
+        : {})
+    }
+  }
+  await writeFile(path.join(output, 'result.json'), JSON.stringify(result))
+  if (!result.ok) {
+    // Core must persist a failed Job so a later attempt can run after recovery.
+    process.stderr.write(`OPENDATALOADER_CONVERSION_ERROR: ${JSON.stringify(result)}\n`)
+    process.exitCode = 1
+  }
+} catch {
+  process.stderr.write('EXPORT_OUTPUT_INVALID: Document conversion Action failed.\n')
+  process.exitCode = 1
+}

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@xpert-ai/plugin-opendataloader",
+  "version": "0.0.1",
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "@xpert-plugins-starter/source": "./src/index.ts",
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    ".xpertai-plugin",
+    "!**/*.tsbuildinfo"
+  ],
+  "dependencies": {
+    "tslib": "^2.3.0"
+  },
+  "license": "AGPL-3.0",
+  "author": "XpertAI",
+  "description": "OpenDataLoader PDF knowledge document parser using platform-managed Sandbox Jobs.",
+  "peerDependencies": {
+    "@nestjs/common": "^11.1.6",
+    "@xpert-ai/plugin-sdk": "^3.17.3",
+    "zod": "3.25.67"
+  },
+  "xpert": {
+    "plugin": {
+      "level": "system",
+      "artifactNamespace": "opendataloader"
+    }
+  },
+  "scripts": {
+    "test:runtime": "node --test tests/*.test.mjs"
+  }
+}