@xpert-ai/plugin-anydoc 0.0.1

package/.xpertai-plugin/plugin.json

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

package/README.md

@@ -0,0 +1,47 @@
+# AnyDoc
+
+Knowledge-base document parser `@xpert-ai/plugin-anydoc`. Install as a **system plugin**; it registers the `anydoc` transformer and `anydoc.convert` Sandbox Action (1.0.3).
+
+## Execution
+
+- Uses platform Sandbox Jobs and scoped Workspace Files. API processes do not load native modules or start Java themselves.
+- Runtime profile: `document/node-20/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.
+
+## Formats and limits
+
+Supports `doc`, `docx`, `ppt`, `pptx`, `xls`, `xlsx`, `csv`, `odt`, `ods`, `odp`, `rtf`, `epub`, and PDF using `@firecrawl/anydoc@0.2.4`.
+
+XLS/XLSX/CSV use **document/form interpretation**; row-record ingestion remains builtin. CSV must be UTF-8. Embedded raster images are exported separately for the existing image-understanding stage; unsupported embedded objects are retained as file assets. Their page/position is not invented.
+
+Native PDF text is extracted locally. When AnyDoc reports scanned pages, the managed Runtime isolates pages and renders scans as PNG assets, preserving page order and coverage diagnostics. Enable knowledge-base image understanding and select a vision model to transcribe those pages. Without successful image understanding, scanned pages remain explicitly unrecognized. The renderer limits PDFs to 500 pages and page images to a 2,200-pixel longest edge. Firecrawl hosted OCR is never enabled; whether vision inference is local depends on the configured model.
+
+Conversion failures are failed Jobs with bounded parser error codes. Retrying after recovery executes again; successful Job reuse includes the Runtime dependency fingerprint.
+
+## 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-node
+corepack pnpm --filter @xpert-ai/sandbox-runtime verify:local-document-node
+```
+
+Local process execution is development/test only. Production needs a published `document-node` 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-anydoc:build
+corepack pnpm exec nx run @xpert-ai/plugin-anydoc:test
+```
+
+From the repository root:
+
+```sh
+node plugin-dev-harness/dist/index.js --workspace ./xpertai --plugin @xpert-ai/plugin-anydoc
+```
+
+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 AnyDoc 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/LICENSE.anydoc

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Sideguide Technologies Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/_assets/README.md

@@ -0,0 +1,8 @@
+# Official branding asset
+
+- Source: https://raw.githubusercontent.com/firecrawl/anydoc/261fc257d17c3eab0f673be31c408fd9fdc2171a/wasm/www/assets/logo.svg
+- Retrieved: 2026-09-15
+- SHA-256: `eaae76b7227c4b6a694c7575c0c665bd627e373b408b9d1806e0dc876e664289`
+- Kept unmodified and bundled locally for plugin and parser identification.
+
+The original project retains its branding rights.

package/dist/_assets/icon.svg

@@ -0,0 +1,3 @@
+<svg width="200" height="284" viewBox="0 0 200 284" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M166.862 90.7716C155.812 94.0514 147.483 101.471 141.383 109.53C140.073 111.26 137.343 109.96 137.863 107.841C149.543 59.8136 134.113 19.896 86.0157 0.247269C83.5758 -0.752669 81.0359 1.43719 81.6759 3.99704C103.555 91.8416 11.5294 84.432 23.1588 184.016C23.3588 185.726 21.4389 186.896 20.039 185.896C15.6792 182.766 10.8095 176.236 7.46963 171.647C6.48968 170.297 4.36978 170.677 3.9198 172.287C1.25994 181.906 0 190.965 0 199.965C0 234.963 17.9891 265.771 45.2177 283.63C46.7777 284.65 48.7776 283.19 48.2476 281.4C46.8477 276.7 46.0577 271.74 45.9977 266.611C45.9977 263.461 46.1977 260.241 46.6877 257.241C47.8276 249.702 50.4475 242.522 54.8473 235.983C69.9365 213.334 100.185 191.455 95.3552 161.747C95.0453 159.867 97.2651 158.627 98.6651 159.917C119.974 179.386 124.194 205.575 120.694 229.063C120.394 231.103 122.954 232.193 124.244 230.593C127.504 226.513 131.483 222.933 135.813 220.244C136.893 219.574 138.333 220.084 138.743 221.284C141.153 228.293 144.733 234.873 148.113 241.452C152.152 249.362 154.302 258.391 153.962 267.951C153.792 272.6 153.022 277.1 151.732 281.38C151.182 283.19 153.162 284.7 154.752 283.66C182.001 265.801 200 234.993 200 199.975C200 187.806 197.87 175.876 193.84 164.697C185.391 141.248 163.952 123.64 169.372 93.0815C169.632 91.6216 168.282 90.3517 166.862 90.7716Z" fill="#FA5D19" style="fill:#FA5D19;fill:color(display-p3 0.9816 0.3634 0.0984);fill-opacity:1;"/>
+</svg>

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 { AnyDocPluginModule } 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: 'anydoc',
+        category: 'integration',
+        displayName: 'AnyDoc',
+        description: 'Offline knowledge document parsing through platform-managed Sandbox Jobs.',
+        icon: Icon,
+        keywords: ['document', 'parser', 'pdf', 'anydoc'],
+        author: 'XpertAI Team'
+    },
+    config: { schema: ConfigSchema, formSchema: { type: 'object', properties: {} } },
+    register() {
+        return { module: AnyDocPluginModule, global: true };
+    },
+    onStart(ctx) {
+        ctx.logger.log('AnyDoc parser started');
+    },
+    onStop(ctx) {
+        ctx.logger.log('AnyDoc parser stopped');
+    }
+};
+export default plugin;

package/dist/lib/convert.d.ts

@@ -0,0 +1,36 @@
+import { type AgentMiddlewareRuntimeCapabilityRegistry, type WorkspaceFileScope } from '@xpert-ai/plugin-sdk';
+export type AnyDocFileScope = WorkspaceFileScope & {
+    organizationId?: string | null;
+};
+export declare class AnyDocSandboxConverter {
+    private readonly capabilities?;
+    constructor(capabilities?: Pick<AgentMiddlewareRuntimeCapabilityRegistry, 'get'>);
+    checkHealth(): Promise<import("@xpert-ai/plugin-sdk").SandboxJobActionHealth>;
+    convert(filePath: string, extension: string, options: {
+        fileScope?: AnyDocFileScope;
+        documentId?: string;
+        stage: 'test' | 'prod';
+        signal?: AbortSignal;
+    }): Promise<{
+        sandboxJobId: string;
+        runtimeProfile: string;
+        ok?: true;
+        pages?: {
+            status?: "text" | "needs-ocr";
+            markdown?: string;
+            page?: number;
+        }[];
+        markdown?: string;
+        assets?: {
+            page?: number;
+            name?: string;
+            mimeType?: string;
+            data?: string;
+            size?: number;
+            sha256?: string;
+            sourceType?: "pdf_page";
+        }[];
+    }>;
+    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;AAI7B,MAAM,MAAM,eAAe,GAAG,kBAAkB,GAAG;IAAE,cAAc,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,CAAA;AAgDrF,qBACa,sBAAsB;IAI/B,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;QACP,SAAS,CAAC,EAAE,eAAe,CAAA;QAC3B,UAAU,CAAC,EAAE,MAAM,CAAA;QACnB,KAAK,EAAE,MAAM,GAAG,MAAM,CAAA;QACtB,MAAM,CAAC,EAAE,WAAW,CAAA;KACrB;;;;;;;;;;;;;;;;;;;;IAiIH,OAAO,CAAC,OAAO;CAShB"}

package/dist/lib/convert.js

@@ -0,0 +1,241 @@
+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 } 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',
+        'UNSUPPORTED_ENCODING',
+        'NEEDS_OCR',
+        'INCOMPLETE_PAGES',
+        'RESOURCE_LIMIT',
+        'RUNTIME_INVALID'
+    ]),
+    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(), status: z.enum(['text', 'needs-ocr']) }))
+            .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(),
+            sourceType: z.literal('pdf_page').optional()
+        }))
+            .max(1000)
+    })
+]);
+let AnyDocSandboxConverter = class AnyDocSandboxConverter {
+    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'
+                ? 'AnyDoc Sandbox Action is missing (ACTION_MISSING). Install AnyDoc as a system plugin, then restart the API.'
+                : `AnyDoc Sandbox Runtime is unavailable (${health.reason ?? 'RUNTIME_UNBOUND'}). ${health.message ?? 'Check the platform Sandbox Runtime configuration.'}`);
+        return health;
+    }
+    async convert(filePath, extension, options) {
+        if (!FILE_TYPES.includes(extension))
+            throw new Error(`AnyDoc does not support this file type: ${extension}`);
+        const scope = options.fileScope;
+        if (!scope?.tenantId || scope.catalog !== 'knowledges' || !scope.scopeId) {
+            throw new Error('AnyDoc 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('ANYDOC_EMPTY_FILE');
+        if (source.buffer.length > 100 * 1024 * 1024)
+            throw new Error('ANYDOC_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
+        ]));
+        // A retry reattaches Core's existing Job; cancellation must target that same ID.
+        const jobId = jobIdFromIdentity(identity);
+        const folder = `anydoc/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: `anydoc:${identity}`,
+                scope: {
+                    tenantId: scope.tenantId,
+                    organizationId: scope.organizationId,
+                    userId: scope.userId,
+                    pluginName: PACKAGE_NAME,
+                    businessResourceType: 'knowledge-document',
+                    businessResourceId: options.documentId ?? identity
+                },
+                payload: { extension },
+                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('AnyDoc 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('ANYDOC_OUTPUT_TOO_LARGE');
+            if (content.buffer.length !== output.size || sha256(content.buffer) !== output.sha256) {
+                throw new Error('AnyDoc Sandbox output integrity check failed');
+            }
+            const converted = resultSchema.parse(JSON.parse(content.buffer.toString('utf8')));
+            if (converted.ok === false)
+                throw Object.assign(new Error(`ANYDOC_${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('ANYDOC_INVALID_DOCUMENT');
+                names.add(asset.name);
+                decodedSize += data.length;
+                if (decodedSize > 128 * 1024 * 1024)
+                    throw new Error('ANYDOC_OUTPUT_TOO_LARGE');
+            }
+            if (converted.pages) {
+                for (const [index, page] of converted.pages.entries()) {
+                    const images = converted.assets.filter((asset) => asset.sourceType === 'pdf_page' && asset.page === page.page);
+                    if (page.page !== index + 1 ||
+                        !page.markdown.trim() ||
+                        (page.status === 'needs-ocr' &&
+                            (images.length !== 1 || !page.markdown.includes(`xpert-asset://${images[0].name}`)))) {
+                        throw new Error('ANYDOC_INCOMPLETE_PAGES');
+                    }
+                }
+            }
+            if (!converted.markdown.trim())
+                throw new Error('ANYDOC_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('AnyDoc requires platform Sandbox Jobs and Workspace Files. Update and restart the API.');
+        return { jobs, files };
+    }
+};
+AnyDocSandboxConverter = __decorate([
+    Injectable(),
+    __param(0, Optional()),
+    __param(0, Inject(XPERT_RUNTIME_CAPABILITIES_TOKEN)),
+    __metadata("design:paramtypes", [Object])
+], AnyDocSandboxConverter);
+export { AnyDocSandboxConverter };
+/** 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(/^ANYDOC_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(`ANYDOC_${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-anydoc.d.ts

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

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

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

package/dist/lib/plugin-anydoc.js

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

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

@@ -0,0 +1,3 @@
+export declare class AnyDocPluginModule {
+}
+//# 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,kBAAkB;CAAG"}

package/dist/lib/plugin.module.js

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

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

@@ -0,0 +1,38 @@
+import { type IDocumentTransformerStrategy, type Permissions, type TDocumentTransformerConfig, type WorkspaceFileScope } from '@xpert-ai/plugin-sdk';
+import { AnyDocSandboxConverter } from './convert.js';
+type Config = TDocumentTransformerConfig & {
+    signal?: AbortSignal;
+    fileScope?: WorkspaceFileScope;
+};
+type Documents = Parameters<IDocumentTransformerStrategy['transformDocuments']>[0];
+type Results = Awaited<ReturnType<IDocumentTransformerStrategy['transformDocuments']>>;
+export declare class AnyDocTransformerStrategy implements IDocumentTransformerStrategy<Config> {
+    private readonly converter;
+    constructor(converter: AnyDocSandboxConverter);
+    readonly permissions: Permissions;
+    readonly meta: {
+        name: string;
+        label: {
+            en_US: string;
+            zh_Hans: string;
+        };
+        description: {
+            en_US: string;
+            zh_Hans: string;
+        };
+        icon: {
+            type: "svg";
+            value: string;
+        };
+        supportedFileTypes: string[];
+        providesImageText: boolean;
+        configSchema: {
+            type: string;
+            properties: {};
+        };
+    };
+    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,sBAAsB,EAAE,MAAM,cAAc,CAAA;AAGrD,KAAK,MAAM,GAAG,0BAA0B,GAAG;IAAE,MAAM,CAAC,EAAE,WAAW,CAAC;IAAC,SAAS,CAAC,EAAE,kBAAkB,CAAA;CAAE,CAAA;AACnG,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,yBAA0B,YAAW,4BAA4B,CAAC,MAAM,CAAC;IACxE,OAAO,CAAC,QAAQ,CAAC,SAAS;gBAAT,SAAS,EAAE,sBAAsB;IAC9D,QAAQ,CAAC,WAAW,EAAE,WAAW,CAAqE;IACtG,QAAQ,CAAC,IAAI;;;;;;;;;;;;;;;;;;;;MAWZ;IACK,cAAc,CAAC,MAAM,EAAE,MAAM;IAI7B,kBAAkB,CAAC,SAAS,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;CA2EjF"}

package/dist/lib/transformer.strategy.js

@@ -0,0 +1,110 @@
+import { __decorate, __metadata } from "tslib";
+import { Injectable } from '@nestjs/common';
+import { DocumentTransformerStrategy } from '@xpert-ai/plugin-sdk';
+import { randomUUID } from 'node:crypto';
+import { AnyDocSandboxConverter } from './convert.js';
+import { FILE_TYPES, Icon, documentExtension } from './types.js';
+let AnyDocTransformerStrategy = class AnyDocTransformerStrategy {
+    constructor(converter) {
+        this.converter = converter;
+        this.permissions = [{ type: 'filesystem', operations: ['read', 'write'], scope: [] }];
+        this.meta = {
+            name: 'anydoc',
+            label: { en_US: 'AnyDoc', zh_Hans: 'AnyDoc' },
+            description: {
+                en_US: 'Local document conversion using Sandbox Jobs. Scanned PDF pages use the configured image-understanding model.',
+                zh_Hans: '通过平台沙箱本地转换文档；PDF 扫描页需开启图像理解并配置视觉模型。'
+            },
+            icon: Icon,
+            supportedFileTypes: FILE_TYPES,
+            providesImageText: false,
+            configSchema: { type: 'object', properties: {} }
+        };
+    }
+    async validateConfig(config) {
+        config.signal?.throwIfAborted();
+        await this.converter.checkHealth();
+    }
+    async transformDocuments(documents, config) {
+        const fs = config.permissions?.fileSystem;
+        if (!fs)
+            throw new Error('AnyDoc 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('ANYDOC_UNSUPPORTED_FORMAT');
+            const result = await this.converter.convert(document.filePath, extension, {
+                signal: config.signal,
+                fileScope: config.fileScope,
+                documentId: document.id,
+                stage: config.stage
+            });
+            const folder = 'anydoc/' + 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.sourceType ? { sourceType: asset.sourceType } : {}),
+                    ...(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, status: 'text' }];
+            const chunks = pages
+                .filter((page) => page.markdown.trim())
+                .map((page, index) => ({
+                pageContent: replaceReferences(page.markdown),
+                metadata: {
+                    chunkId: randomUUID(),
+                    chunkIndex: index,
+                    parser: 'anydoc',
+                    mediaType: page.status === 'needs-ocr' ? 'image' : '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: 'anydoc',
+                    sandboxJobId: result.sandboxJobId,
+                    runtimeProfile: result.runtimeProfile,
+                    ...(result.pages ? {
+                        parserDiagnostics: {
+                            schemaVersion: 1,
+                            pages: result.pages.map((page) => ({
+                                page: page.page, status: page.status,
+                                imagePaths: assets.filter((asset) => asset.sourceType === 'pdf_page' && asset.page === page.page)
+                                    .map((asset) => asset.filePath)
+                            }))
+                        }
+                    } : {}),
+                    assets
+                }
+            });
+        }
+        return output;
+    }
+};
+AnyDocTransformerStrategy = __decorate([
+    Injectable(),
+    DocumentTransformerStrategy('anydoc'),
+    __metadata("design:paramtypes", [AnyDocSandboxConverter])
+], AnyDocTransformerStrategy);
+export { AnyDocTransformerStrategy };

package/dist/lib/types.d.ts

@@ -0,0 +1,15 @@
+import { z } from 'zod';
+export declare const PACKAGE_NAME = "@xpert-ai/plugin-anydoc";
+export declare const PARSER_NAME = "anydoc";
+export declare const FILE_TYPES: string[];
+export declare const ACTION = "anydoc.convert";
+export declare const ACTION_VERSION = "1.0.3";
+export declare const PROFILE = "document/node-20/v1";
+export declare const ConfigSchema: z.ZodObject<{}, "strict", z.ZodTypeAny, {}, {}>;
+export declare const Icon: {
+    type: "svg";
+    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,4BAA4B,CAAA;AACrD,eAAO,MAAM,WAAW,WAAW,CAAA;AACnC,eAAO,MAAM,UAAU,UActB,CAAA;AACD,eAAO,MAAM,MAAM,mBAAmB,CAAA;AACtC,eAAO,MAAM,cAAc,UAAU,CAAA;AACrC,eAAO,MAAM,OAAO,wBAAwB,CAAA;AAC5C,eAAO,MAAM,YAAY,iDAAwB,CAAA;AACjD,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,50 @@
+import { z } from 'zod';
+import { readFileSync } from 'node:fs';
+export const PACKAGE_NAME = '@xpert-ai/plugin-anydoc';
+export const PARSER_NAME = 'anydoc';
+export const FILE_TYPES = [
+    'doc',
+    'docx',
+    'ppt',
+    'pptx',
+    'xls',
+    'xlsx',
+    'csv',
+    'odt',
+    'ods',
+    'odp',
+    'rtf',
+    'epub',
+    'pdf'
+];
+export const ACTION = 'anydoc.convert';
+export const ACTION_VERSION = '1.0.3';
+export const PROFILE = 'document/node-20/v1';
+export const ConfigSchema = z.object({}).strict();
+export const Icon = {
+    type: 'svg',
+    value: readFileSync(new URL('../_assets/icon.svg', import.meta.url), 'utf8')
+};
+/** 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": "anydoc.convert",
+  "version": "1.0.3",
+  "runtimeProfile": "document/node-20/v1",
+  "runtimeContractVersion": "1",
+  "bundle": "./bundle",
+  "entrypoint": "runner.mjs",
+  "bundleSha256": "3c9193c6992c0a22ae42bb26ccf96be5c54df6014126069c5e1beac99e64afe1"
+}

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

@@ -0,0 +1,80 @@
+import { createRequire } from 'node:module'
+import path from 'node:path'
+import { INPUT_LIMIT, ASSET_LIMIT, asset, fail, finish, readBounded } from './result.mjs'
+import { convertPdfPages } from './pdf.mjs'
+
+export const FORMATS = ['doc', 'docx', 'ppt', 'pptx', 'xls', 'xlsx', 'csv', 'odt', 'ods', 'odp', 'rtf', 'epub', 'pdf']
+
+export async function convert(file, extension, output, suppliedApi) {
+  if (!FORMATS.includes(extension)) 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')
+  let api = suppliedApi
+  if (!api) {
+    const root = process.env.XPERT_SANDBOX_DOCUMENT_DEPENDENCY_ROOT
+    if (!root || !path.isAbsolute(root)) fail('RUNTIME_INVALID')
+    try {
+      api = createRequire(path.join(root, 'package.json'))('@firecrawl/anydoc')
+    } catch {
+      fail('RUNTIME_INVALID')
+    }
+  }
+  try {
+    const format = api.formatFromExtension(extension)
+    const detected = api.formatFromBytes(bytes)
+    if (!format || (detected && detected !== format)) fail('INVALID_DOCUMENT')
+    if (!detected && extension !== 'csv') fail('INVALID_DOCUMENT')
+    if (extension === 'csv') {
+      if (bytes.includes(0)) fail('INVALID_DOCUMENT')
+      let text
+      try {
+        text = new TextDecoder('utf-8', { fatal: true }).decode(bytes)
+      } catch {
+        fail('UNSUPPORTED_ENCODING')
+      }
+      if (!text.trim()) fail('EMPTY_TEXT')
+    }
+    // Never delegate to Firecrawl hosted OCR, even when the host has a Firecrawl API key.
+    let markdown
+    try {
+      markdown = await api.toMarkdownBytes(bytes, format, { ocr: 'reject' })
+    } catch (error) {
+      if (extension !== 'pdf' || error?.code !== 'needsOcr') throw error
+      return await convertPdfPages(bytes, api)
+    }
+    const assets = []
+    if (extension !== 'pdf') {
+      const document = await api.toDocument(bytes, format)
+      if (document.assets.length > ASSET_LIMIT) fail('OUTPUT_TOO_LARGE')
+      for (const source of document.assets) {
+        const suffix =
+          { 'image/png': 'png', 'image/jpeg': 'jpg', 'image/gif': 'gif', 'image/webp': 'webp', 'image/svg+xml': 'svg' }[
+            source.mediaType
+          ] ?? 'bin'
+        const name = `asset-${assets.length + 1}.${suffix}`
+        assets.push(asset(name, source.mediaType, Buffer.from(source.data)))
+        // Native Markdown omits embedded images. Export them explicitly without inventing page/position data.
+        if (['png', 'jpg', 'gif', 'webp'].includes(suffix))
+          markdown += `\n\n![Embedded image ${assets.length}](xpert-asset://${name})\n`
+      }
+    }
+    return finish({ markdown, assets })
+  } catch (error) {
+    const code = {
+      needsOcr: 'NEEDS_OCR',
+      encrypted: 'ENCRYPTED',
+      unsupported: 'UNSUPPORTED_FORMAT',
+      malformed: 'INVALID_DOCUMENT',
+      missingPart: 'INVALID_DOCUMENT',
+      resourceLimit: 'RESOURCE_LIMIT'
+    }[error?.code]
+    if (code) fail(code, error.pages)
+    throw error
+  }
+}

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

@@ -0,0 +1,66 @@
+import { createRequire } from 'node:module'
+import path from 'node:path'
+import { asset, fail, finish, OUTPUT_LIMIT } from './result.mjs'
+
+/** AnyDoc rejects a whole mixed PDF. Isolate pages so its native text extraction is retained. */
+export async function convertPdfPages(bytes, api) {
+  const root = process.env.XPERT_SANDBOX_DOCUMENT_DEPENDENCY_ROOT
+  if (!root || !path.isAbsolute(root)) fail('RUNTIME_INVALID')
+  let PDFDocument, PDFiumLibrary, PNG
+  try {
+    const require = createRequire(path.join(root, 'package.json'))
+    ;({ PDFDocument } = require('pdf-lib'))
+    ;({ PDFiumLibrary } = require('@hyzyla/pdfium'))
+    ;({ PNG } = require('pngjs'))
+  } catch {
+    fail('RUNTIME_INVALID')
+  }
+  const source = await PDFDocument.load(bytes)
+  const count = source.getPageCount()
+  if (count < 1 || count > 500) fail('RESOURCE_LIMIT')
+  const pdfium = await PDFiumLibrary.init()
+  try {
+    const pdf = await pdfium.loadDocument(Uint8Array.from(bytes))
+    try {
+      if (pdf.getPageCount() !== count) fail('INCOMPLETE_PAGES')
+      const pages = []
+      const assets = []
+      let size = 0
+      for (let index = 0; index < count; index++) {
+        const pageNumber = index + 1
+        const single = await PDFDocument.create()
+        const [copied] = await single.copyPages(source, [index])
+        single.addPage(copied)
+        let markdown
+        try {
+          markdown = await api.toMarkdownBytes(await single.save(), api.formatFromExtension('pdf'), { ocr: 'reject' })
+        } catch (error) {
+          if (error?.code !== 'needsOcr') throw error
+        }
+        if (markdown?.trim()) {
+          pages.push({ page: pageNumber, markdown, status: 'text' })
+          size += Buffer.byteLength(markdown)
+        } else {
+          const page = pdf.getPage(index)
+          const dimensions = page.getSize()
+          if (![dimensions.width, dimensions.height].every((n) => Number.isFinite(n) && n > 0))
+            fail('INVALID_DOCUMENT')
+          const scale = Math.min(2, 2200 / Math.max(dimensions.width, dimensions.height))
+          const bitmap = await page.render({ scale, render: 'bitmap' })
+          const png = new PNG({ width: bitmap.width, height: bitmap.height })
+          png.data = Buffer.from(bitmap.data)
+          const image = asset(`page-${pageNumber}.png`, 'image/png', PNG.sync.write(png), pageNumber)
+          assets.push({ ...image, sourceType: 'pdf_page' })
+          size += image.size
+          pages.push({ page: pageNumber, status: 'needs-ocr', markdown: `![Page ${pageNumber}](xpert-asset://${image.name})` })
+        }
+        if (size > OUTPUT_LIMIT) fail('OUTPUT_TOO_LARGE')
+      }
+      return finish({ markdown: pages.map((page) => page.markdown).join('\n\n'), pages, assets })
+    } finally {
+      pdf.destroy()
+    }
+  } finally {
+    pdfium.destroy()
+  }
+}

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,51 @@
+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 !== 'anydoc.convert' || request.actionVersion !== '1.0.3')
+    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)
+  } catch (error) {
+    const codes = [
+      'EMPTY_FILE',
+      'EMPTY_TEXT',
+      'INPUT_TOO_LARGE',
+      'OUTPUT_TOO_LARGE',
+      'INVALID_DOCUMENT',
+      'ENCRYPTED',
+      'UNSUPPORTED_FORMAT',
+      'UNSUPPORTED_ENCODING',
+      'NEEDS_OCR',
+      'INCOMPLETE_PAGES',
+      'RESOURCE_LIMIT',
+      'RUNTIME_INVALID'
+    ]
+    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(`ANYDOC_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-anydoc",
+  "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": "AnyDoc 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": "anydoc"
+    }
+  },
+  "scripts": {
+    "test:runtime": "node --test tests/*.test.mjs"
+  }
+}