@docverse-pdf/server 1.0.0 → 1.0.1

package/dist/index.d.ts

@@ -1,4 +1,5 @@
 export { PDFDocument } from './PDFDocument.js';
 export type { PageSize, TextBlock, SearchResult, AnnotationInfo, PageObjectInfo, FormField, Bookmark, RenderOptions, ImageInfo, TextObjectStyle, } from './PDFDocument.js';
 export { flattenXFDF, mergeXFDFIntoPDF } from './flattenXFDF.js';
-export { wordToPDF } from './wordToPDF.js';
+export { wordToPDF, LibreOfficePool } from './wordToPDF.js';
+export type { ConvertOptions, PoolOptions } from './wordToPDF.js';

package/dist/index.js

@@ -1,3 +1,3 @@
 export { PDFDocument } from './PDFDocument.js';
 export { flattenXFDF, mergeXFDFIntoPDF } from './flattenXFDF.js';
-export { wordToPDF } from './wordToPDF.js';
+export { wordToPDF, LibreOfficePool } from './wordToPDF.js';

package/dist/wordToPDF.d.ts

@@ -1,20 +1,34 @@
-/**
- * Convert a Word document (.docx/.doc) to PDF.
- *
- * Requires LibreOffice installed on the system.
- * Install: `apt-get install libreoffice-core` (Ubuntu) or `brew install libreoffice` (macOS)
- *
- * @param wordBuffer - The Word document as a Buffer
- * @param format - Output format (default: 'pdf')
- * @returns The PDF as a Buffer
- *
- * @example
- * ```ts
- * import { wordToPDF } from '@docverse/server';
- *
- * const docx = fs.readFileSync('document.docx');
- * const pdf = await wordToPDF(docx);
- * fs.writeFileSync('document.pdf', pdf);
- * ```
- */
-export declare function wordToPDF(wordBuffer: Buffer | Uint8Array, format?: string): Promise<Buffer>;
+export interface ConvertOptions {
+    format?: string;
+    mode?: 'process' | 'socket' | 'pool';
+    socketUrl?: string;
+    timeout?: number;
+}
+export interface PoolOptions {
+    workers?: number;
+    libreOfficePath?: string;
+    tempDir?: string;
+    startTimeout?: number;
+    convertTimeout?: number;
+}
+export declare function wordToPDF(wordBuffer: Buffer | Uint8Array, optionsOrFormat?: string | ConvertOptions): Promise<Buffer>;
+export declare class LibreOfficePool {
+    private workers;
+    private queue;
+    private opts;
+    private running;
+    private tempDir;
+    constructor(options?: PoolOptions);
+    private findLibreOffice;
+    start(): Promise<void>;
+    private waitForWorkers;
+    convert(wordBuffer: Buffer | Uint8Array, format?: string): Promise<Buffer>;
+    private executeConvert;
+    stop(): Promise<void>;
+    getStats(): {
+        workers: number;
+        busy: number;
+        queued: number;
+        ready: number;
+    };
+}

package/dist/wordToPDF.js

@@ -1,27 +1,260 @@
 import { promisify } from 'util';
-/**
- * Convert a Word document (.docx/.doc) to PDF.
- *
- * Requires LibreOffice installed on the system.
- * Install: `apt-get install libreoffice-core` (Ubuntu) or `brew install libreoffice` (macOS)
- *
- * @param wordBuffer - The Word document as a Buffer
- * @param format - Output format (default: 'pdf')
- * @returns The PDF as a Buffer
- *
- * @example
- * ```ts
- * import { wordToPDF } from '@docverse/server';
- *
- * const docx = fs.readFileSync('document.docx');
- * const pdf = await wordToPDF(docx);
- * fs.writeFileSync('document.pdf', pdf);
- * ```
- */
-export async function wordToPDF(wordBuffer, format = 'pdf') {
+import { spawn, execSync } from 'child_process';
+import { writeFileSync, readFileSync, unlinkSync, mkdirSync, existsSync } from 'fs';
+import { join } from 'path';
+import { tmpdir } from 'os';
+import { randomBytes } from 'crypto';
+// ═══════════════════════════════════════════════
+// SIMPLE CONVERT (backward compatible)
+// ═══════════════════════════════════════════════
+export async function wordToPDF(wordBuffer, optionsOrFormat = 'pdf') {
+    const opts = typeof optionsOrFormat === 'string'
+        ? { format: optionsOrFormat }
+        : optionsOrFormat;
+    const format = opts.format ?? 'pdf';
+    const mode = opts.mode ?? 'process';
+    const timeout = opts.timeout ?? 30000;
+    if (mode === 'socket' && opts.socketUrl) {
+        return convertViaSocket(wordBuffer, format, opts.socketUrl, timeout);
+    }
+    return convertViaProcess(wordBuffer, format, timeout);
+}
+// ═══════════════════════════════════════════════
+// PROCESS MODE (original, 3-5s)
+// ═══════════════════════════════════════════════
+async function convertViaProcess(wordBuffer, format, timeout) {
     const libre = await import('libreoffice-convert');
     const convert = promisify(libre.convert);
     const inputBuffer = Buffer.from(wordBuffer);
     const result = await convert(inputBuffer, format, undefined);
     return result;
 }
+// ═══════════════════════════════════════════════
+// SOCKET MODE (0.2-0.5s, needs running LO instance)
+// ═══════════════════════════════════════════════
+async function convertViaSocket(wordBuffer, format, socketUrl, timeout) {
+    const tmp = tmpdir();
+    const id = randomBytes(8).toString('hex');
+    const inputPath = join(tmp, `docverse_in_${id}.docx`);
+    const outputPath = join(tmp, `docverse_in_${id}.pdf`);
+    try {
+        writeFileSync(inputPath, Buffer.from(wordBuffer));
+        // Parse socket URL for connection string
+        const connStr = socketUrl.includes('socket,')
+            ? socketUrl
+            : `socket,host=127.0.0.1,port=${socketUrl};urp;`;
+        await new Promise((resolve, reject) => {
+            const timer = setTimeout(() => reject(new Error('Socket convert timeout')), timeout);
+            const proc = spawn('soffice', [
+                `--accept="${connStr}"`,
+                '--norestore',
+                '--headless',
+                '--convert-to', format,
+                '--outdir', tmp,
+                inputPath,
+            ], { shell: true, timeout });
+            proc.on('close', (code) => {
+                clearTimeout(timer);
+                if (code === 0)
+                    resolve();
+                else
+                    reject(new Error(`LibreOffice exited with code ${code}`));
+            });
+            proc.on('error', (err) => {
+                clearTimeout(timer);
+                reject(err);
+            });
+        });
+        if (!existsSync(outputPath)) {
+            throw new Error('Conversion failed: output file not created');
+        }
+        return readFileSync(outputPath);
+    }
+    finally {
+        try {
+            unlinkSync(inputPath);
+        }
+        catch { }
+        try {
+            unlinkSync(outputPath);
+        }
+        catch { }
+    }
+}
+// ═══════════════════════════════════════════════
+// LIBREOFFICE POOL (fastest: warm instances)
+// ═══════════════════════════════════════════════
+export class LibreOfficePool {
+    workers = [];
+    queue = [];
+    opts;
+    running = false;
+    tempDir;
+    constructor(options = {}) {
+        this.opts = {
+            workers: options.workers ?? 2,
+            libreOfficePath: options.libreOfficePath ?? this.findLibreOffice(),
+            tempDir: options.tempDir ?? join(tmpdir(), 'docverse_pool'),
+            startTimeout: options.startTimeout ?? 15000,
+            convertTimeout: options.convertTimeout ?? 30000,
+        };
+        this.tempDir = this.opts.tempDir;
+    }
+    findLibreOffice() {
+        const paths = [
+            '/usr/bin/soffice',
+            '/usr/bin/libreoffice',
+            '/usr/local/bin/soffice',
+            '/Applications/LibreOffice.app/Contents/MacOS/soffice',
+            'soffice',
+        ];
+        for (const p of paths) {
+            try {
+                execSync(`${p} --version`, { stdio: 'ignore' });
+                return p;
+            }
+            catch { }
+        }
+        return 'soffice';
+    }
+    async start() {
+        if (this.running)
+            return;
+        if (!existsSync(this.tempDir)) {
+            mkdirSync(this.tempDir, { recursive: true });
+        }
+        const basePort = 2002 + Math.floor(Math.random() * 1000);
+        for (let i = 0; i < this.opts.workers; i++) {
+            const port = basePort + i;
+            const userDir = join(this.tempDir, `worker_${i}`);
+            if (!existsSync(userDir))
+                mkdirSync(userDir, { recursive: true });
+            const proc = spawn(this.opts.libreOfficePath, [
+                '--headless',
+                '--norestore',
+                '--nologo',
+                '--nodefault',
+                `--accept=socket,host=127.0.0.1,port=${port};urp;`,
+                `-env:UserInstallation=file://${userDir}`,
+            ], {
+                stdio: 'ignore',
+                detached: false,
+            });
+            this.workers.push({ process: proc, port, busy: false, ready: false });
+        }
+        // Wait for workers to start
+        await this.waitForWorkers();
+        this.running = true;
+    }
+    async waitForWorkers() {
+        const deadline = Date.now() + this.opts.startTimeout;
+        for (const worker of this.workers) {
+            while (Date.now() < deadline) {
+                try {
+                    // Test if port is listening
+                    const net = await import('net');
+                    await new Promise((resolve, reject) => {
+                        const sock = net.createConnection(worker.port, '127.0.0.1');
+                        sock.on('connect', () => { sock.destroy(); resolve(); });
+                        sock.on('error', () => { reject(); });
+                        setTimeout(() => { sock.destroy(); reject(); }, 500);
+                    });
+                    worker.ready = true;
+                    break;
+                }
+                catch {
+                    await new Promise(r => setTimeout(r, 300));
+                }
+            }
+        }
+    }
+    async convert(wordBuffer, format = 'pdf') {
+        if (!this.running)
+            throw new Error('Pool not started. Call pool.start() first.');
+        const buf = Buffer.from(wordBuffer);
+        return new Promise((resolve, reject) => {
+            // Find free worker
+            const worker = this.workers.find(w => !w.busy && w.ready);
+            if (worker) {
+                this.executeConvert(worker, buf, format, resolve, reject);
+            }
+            else {
+                // Queue the request
+                this.queue.push({ buffer: buf, format, resolve, reject });
+            }
+        });
+    }
+    async executeConvert(worker, buffer, format, resolve, reject) {
+        worker.busy = true;
+        const id = randomBytes(8).toString('hex');
+        const inputPath = join(this.tempDir, `in_${id}.docx`);
+        const outputPath = join(this.tempDir, `in_${id}.${format}`);
+        try {
+            writeFileSync(inputPath, buffer);
+            await new Promise((res, rej) => {
+                const timer = setTimeout(() => rej(new Error('Convert timeout')), this.opts.convertTimeout);
+                const proc = spawn(this.opts.libreOfficePath, [
+                    '--headless',
+                    '--norestore',
+                    '--nologo',
+                    '--convert-to', format,
+                    '--outdir', this.tempDir,
+                    inputPath,
+                ], { stdio: 'ignore', timeout: this.opts.convertTimeout });
+                proc.on('close', (code) => {
+                    clearTimeout(timer);
+                    if (code === 0)
+                        res();
+                    else
+                        rej(new Error(`LibreOffice exit code ${code}`));
+                });
+                proc.on('error', (err) => {
+                    clearTimeout(timer);
+                    rej(err);
+                });
+            });
+            if (!existsSync(outputPath)) {
+                throw new Error('Output file not created');
+            }
+            resolve(readFileSync(outputPath));
+        }
+        catch (err) {
+            reject(err);
+        }
+        finally {
+            worker.busy = false;
+            try {
+                unlinkSync(inputPath);
+            }
+            catch { }
+            try {
+                unlinkSync(outputPath);
+            }
+            catch { }
+            // Process queue
+            if (this.queue.length > 0) {
+                const next = this.queue.shift();
+                this.executeConvert(worker, next.buffer, next.format, next.resolve, next.reject);
+            }
+        }
+    }
+    async stop() {
+        this.running = false;
+        for (const worker of this.workers) {
+            try {
+                worker.process.kill('SIGTERM');
+            }
+            catch { }
+        }
+        this.workers = [];
+        this.queue = [];
+    }
+    getStats() {
+        return {
+            workers: this.workers.length,
+            busy: this.workers.filter(w => w.busy).length,
+            queued: this.queue.length,
+            ready: this.workers.filter(w => w.ready).length,
+        };
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@docverse-pdf/server",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "DocVerse Server SDK — server-side PDF processing, XFDF merge, Word to PDF, image extraction",
   "type": "module",
   "main": "dist/index.js",