dsh-file-convert 0.4.0

package/lib/core/converters/media.js

@@ -0,0 +1,135 @@
+import fs from 'node:fs/promises';
+import { ExecError, execTool } from '../utils/exec.js';
+import { convertError } from '../errors.js';
+export const FFMPEG = {
+    name: 'ffmpeg',
+    commands: ['ffmpeg'],
+    configKey: 'ffmpegPath',
+    installHint: {
+        win32: 'winget install Gyan.FFmpeg (or scoop install ffmpeg)',
+        darwin: 'brew install ffmpeg',
+        linux: 'sudo apt install ffmpeg',
+    },
+};
+export const FFPROBE = {
+    name: 'ffprobe',
+    commands: ['ffprobe'],
+    configKey: 'ffprobePath',
+    installHint: FFMPEG.installHint, // always ships together
+};
+/** Options that ffmpeg must never prompt or decorate about. */
+const GLOBAL = ['-hide_banner', '-nostdin', '-y'];
+/**
+ * Audio/video conversions, delegated to a locally installed FFmpeg.
+ * The converter declares its dependencies; the router refuses to run (and
+ * list_conversions reports what is missing) until the binaries resolve.
+ */
+export class MediaConverter {
+    resolve;
+    id = 'media';
+    concurrency = 2;
+    binaryDeps = [FFMPEG, FFPROBE];
+    capabilities = [
+        { from: 'mp4', to: 'gif' },
+        { from: 'mp4', to: 'mp3' },
+        { from: 'mov', to: 'mp4' },
+        { from: 'wav', to: 'mp3' },
+    ];
+    constructor(resolve) {
+        this.resolve = resolve;
+    }
+    async convert(req, ctx) {
+        const started = Date.now();
+        try {
+            const bytesIn = (await fs.stat(req.input)).size;
+            const ffmpeg = await this.required(FFMPEG);
+            switch (`${req.from}->${req.to}`) {
+                case 'mp4->gif':
+                    await execTool(ffmpeg, gifArgs(req), this.execOpts(ctx));
+                    break;
+                case 'mp4->mp3':
+                case 'wav->mp3':
+                    await execTool(ffmpeg, audioArgs(req), this.execOpts(ctx));
+                    break;
+                case 'mov->mp4':
+                    await this.movToMp4(req, ctx, ffmpeg);
+                    break;
+                default:
+                    return fail(req, convertError('unsupported_conversion', `MediaConverter cannot handle ${req.from} -> ${req.to}.`));
+            }
+            const bytesOut = (await fs.stat(req.output)).size;
+            return {
+                ok: true,
+                input: req.input,
+                output: req.output,
+                from: req.from,
+                to: req.to,
+                bytesIn,
+                bytesOut,
+                durationMs: Date.now() - started,
+                warnings: [],
+            };
+        }
+        catch (err) {
+            if (err instanceof BinaryMissingError) {
+                return fail(req, convertError('missing_dependency', `Missing dependency: ${err.dep.name}.`, {
+                    missing: [err.dep],
+                    hint: `Install hint (${process.platform}): ${err.dep.installHint[platformKey()]}`,
+                }));
+            }
+            if (err instanceof ExecError) {
+                const code = err.code === 'timeout' ? 'timeout' : err.code === 'cancelled' ? 'cancelled' : 'conversion_failed';
+                return fail(req, convertError(code, `Failed to convert ${req.from} → ${req.to} (ffmpeg).`, { detail: err.stderr }));
+            }
+            return fail(req, convertError('conversion_failed', `Failed to convert ${req.from} → ${req.to}`, {
+                detail: err instanceof Error ? err.message : String(err),
+            }));
+        }
+    }
+    /** MOV→MP4: try a lossless container swap first, fall back to re-encoding. */
+    async movToMp4(req, ctx, ffmpeg) {
+        try {
+            await execTool(ffmpeg, [...GLOBAL, '-i', req.input, '-c', 'copy', '-movflags', '+faststart', req.output], this.execOpts(ctx));
+        }
+        catch {
+            await execTool(ffmpeg, [...GLOBAL, '-i', req.input, '-c:v', 'libx264', '-preset', 'veryfast', '-crf', '23', '-c:a', 'aac', '-b:a', '128k', '-movflags', '+faststart', req.output], this.execOpts(ctx));
+        }
+    }
+    async required(dep) {
+        const resolved = await this.resolve(dep);
+        if (!resolved) {
+            throw new BinaryMissingError(dep);
+        }
+        return resolved;
+    }
+    execOpts(ctx) {
+        return { timeoutMs: ctx.timeoutMs, signal: ctx.signal };
+    }
+}
+class BinaryMissingError extends Error {
+    dep;
+    constructor(dep) {
+        super(`Missing dependency: ${dep.name}`);
+        this.dep = dep;
+    }
+}
+function platformKey() {
+    return process.platform === 'win32' ? 'win32' : process.platform === 'darwin' ? 'darwin' : 'linux';
+}
+function gifArgs(req) {
+    // Two-pass palette in one filter graph: split -> palettegen + paletteuse.
+    return [
+        ...GLOBAL,
+        '-i', req.input,
+        '-filter_complex', '[0:v] fps=12,scale=480:-2:flags=lanczos,split [a][b];[a] palettegen [p];[b][p] paletteuse',
+        req.output,
+    ];
+}
+function audioArgs(req) {
+    const quality = req.options.quality ?? 85;
+    const kbps = Math.round(64 + (Math.min(100, Math.max(1, quality)) / 100) * (320 - 64));
+    return [...GLOBAL, '-i', req.input, '-vn', '-codec:a', 'libmp3lame', '-b:a', `${kbps}k`, req.output];
+}
+function fail(req, error) {
+    return { ok: false, input: req.input, from: req.from, to: req.to, error };
+}

package/lib/core/converters/office.d.ts

@@ -0,0 +1,33 @@
+import type { BinaryDependency, ConvertContext, ConvertRequest, ConvertResult, Converter, ConversionCapability } from '../types.js';
+export declare const SOFFICE: BinaryDependency;
+export declare const PYTHON_PDF2DOCX: BinaryDependency;
+/**
+ * Office documents to PDF via LibreOffice headless. LibreOffice is a
+ * single-instance application, so this converter serializes (concurrency 1)
+ * and always runs against its own UserInstallation profile — a document the
+ * user has open in LibreOffice GUI must never block or break a conversion.
+ */
+export declare class OfficeConverter implements Converter {
+    private readonly resolve;
+    readonly id = "office";
+    readonly concurrency = 1;
+    readonly binaryDeps: BinaryDependency[];
+    readonly capabilities: ConversionCapability[];
+    constructor(resolve: (dep: BinaryDependency) => Promise<string | null>);
+    convert(req: ConvertRequest, ctx: ConvertContext): Promise<ConvertResult>;
+    private required;
+}
+/**
+ * PDF → DOCX (EXPERIMENTAL): layout reconstruction via the Python pdf2docx
+ * package. Works well on text PDFs; scanned PDFs need OCR (not implemented).
+ * The dependency probe checks that python can actually import pdf2docx.
+ */
+export declare class PdfToDocxConverter implements Converter {
+    private readonly resolve;
+    readonly id = "pdf-docx";
+    readonly concurrency = 1;
+    readonly binaryDeps: BinaryDependency[];
+    readonly capabilities: ConversionCapability[];
+    constructor(resolve: (dep: BinaryDependency) => Promise<string | null>);
+    convert(req: ConvertRequest, ctx: ConvertContext): Promise<ConvertResult>;
+}

package/lib/core/converters/office.js

@@ -0,0 +1,206 @@
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { ExecError, execTool } from '../utils/exec.js';
+import { convertError } from '../errors.js';
+export const SOFFICE = {
+    name: 'soffice',
+    displayName: 'LibreOffice',
+    commands: ['soffice'],
+    configKey: 'sofficePath',
+    extraPaths: {
+        win32: [
+            'C:\\Program Files\\LibreOffice\\program\\soffice.exe',
+            'C:\\Program Files (x86)\\LibreOffice\\program\\soffice.exe',
+        ],
+        darwin: ['/Applications/LibreOffice.app/Contents/MacOS/soffice'],
+        linux: ['/usr/lib/libreoffice/program/soffice', '/opt/libreoffice/program/soffice'],
+    },
+    installHint: {
+        win32: 'winget install TheDocumentFoundation.LibreOffice',
+        darwin: 'brew install --cask libreoffice',
+        linux: 'sudo apt install libreoffice-writer libreoffice-calc libreoffice-impress',
+    },
+};
+export const PYTHON_PDF2DOCX = {
+    name: 'python',
+    displayName: 'python with the pdf2docx package',
+    commands: ['python', 'python3', 'py'],
+    configKey: 'pythonPath',
+    probe: async (pythonPath) => {
+        try {
+            await execTool(pythonPath, ['-c', 'import pdf2docx'], { timeoutMs: 30_000 });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    },
+    installHint: {
+        win32: 'install Python from python.org, then: pip install pdf2docx',
+        darwin: 'brew install python && pip3 install pdf2docx',
+        linux: 'sudo apt install python3-pip && pip3 install pdf2docx',
+    },
+};
+async function exists(p) {
+    try {
+        await fs.access(p);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function fail(req, error) {
+    return { ok: false, input: req.input, from: req.from, to: req.to, error };
+}
+/**
+ * Office documents to PDF via LibreOffice headless. LibreOffice is a
+ * single-instance application, so this converter serializes (concurrency 1)
+ * and always runs against its own UserInstallation profile — a document the
+ * user has open in LibreOffice GUI must never block or break a conversion.
+ */
+export class OfficeConverter {
+    resolve;
+    id = 'office';
+    concurrency = 1;
+    binaryDeps = [SOFFICE];
+    capabilities = [
+        { from: 'docx', to: 'pdf' },
+        { from: 'pptx', to: 'pdf' },
+        { from: 'xlsx', to: 'pdf' },
+    ];
+    constructor(resolve) {
+        this.resolve = resolve;
+    }
+    async convert(req, ctx) {
+        const started = Date.now();
+        try {
+            const soffice = await this.required(SOFFICE, req, ctx);
+            const bytesIn = (await fs.stat(req.input)).size;
+            // A stable private profile: created once, reused across conversions.
+            const profile = path.join(os.homedir(), '.dsh-file-convert', 'lo-profile');
+            await fs.mkdir(profile, { recursive: true });
+            const outDir = await fs.mkdtemp(path.join(os.tmpdir(), 'dsh-office-'));
+            try {
+                await execTool(soffice, [
+                    '--headless', '--norestore', '--nolockcheck',
+                    `-env:UserInstallation=${pathToFileURL(profile).href}`,
+                    '--convert-to', 'pdf', '--outdir', outDir,
+                    req.input,
+                ], { timeoutMs: ctx.timeoutMs, signal: ctx.signal });
+                const produced = path.join(outDir, path.basename(req.input, path.extname(req.input)) + '.pdf');
+                if (!(await exists(produced))) {
+                    return fail(req, convertError('conversion_failed', `LibreOffice did not produce a PDF for ${req.input}.`, {
+                        hint: 'The document may be corrupt or password-protected; open it once in LibreOffice to check.',
+                    }));
+                }
+                await fs.copyFile(produced, req.output);
+                return {
+                    ok: true,
+                    input: req.input,
+                    output: req.output,
+                    from: req.from,
+                    to: req.to,
+                    bytesIn,
+                    bytesOut: (await fs.stat(req.output)).size,
+                    durationMs: Date.now() - started,
+                    warnings: [],
+                };
+            }
+            finally {
+                await fs.rm(outDir, { recursive: true, force: true }).catch(() => undefined);
+            }
+        }
+        catch (err) {
+            if (err instanceof OfficeDependencyError) {
+                return fail(req, convertError('missing_dependency', `Missing external dependency: ${err.dep.displayName ?? err.dep.name}.`, {
+                    missing: [err.dep],
+                    hint: `Install hint (${process.platform}): ${err.dep.installHint[platformKey()]}`,
+                }));
+            }
+            if (err instanceof ExecError) {
+                const code = err.code === 'timeout' ? 'timeout' : err.code === 'cancelled' ? 'cancelled' : 'conversion_failed';
+                return fail(req, convertError(code, `Failed to convert ${req.from} → ${req.to} (LibreOffice).`, { detail: err.stderr }));
+            }
+            return fail(req, convertError('conversion_failed', `Failed to convert ${req.from} → ${req.to}`, {
+                detail: err instanceof Error ? err.message : String(err),
+            }));
+        }
+    }
+    async required(dep, req, ctx) {
+        const resolved = await this.resolve(dep);
+        if (!resolved)
+            throw new OfficeDependencyError(dep);
+        void ctx;
+        return resolved;
+    }
+}
+class OfficeDependencyError extends Error {
+    dep;
+    constructor(dep) {
+        super(`Missing dependency: ${dep.name}`);
+        this.dep = dep;
+    }
+}
+function platformKey() {
+    return process.platform === 'win32' ? 'win32' : process.platform === 'darwin' ? 'darwin' : 'linux';
+}
+/**
+ * PDF → DOCX (EXPERIMENTAL): layout reconstruction via the Python pdf2docx
+ * package. Works well on text PDFs; scanned PDFs need OCR (not implemented).
+ * The dependency probe checks that python can actually import pdf2docx.
+ */
+export class PdfToDocxConverter {
+    resolve;
+    id = 'pdf-docx';
+    concurrency = 1;
+    binaryDeps = [PYTHON_PDF2DOCX];
+    capabilities = [{ from: 'pdf', to: 'docx', experimental: true }];
+    constructor(resolve) {
+        this.resolve = resolve;
+    }
+    async convert(req, ctx) {
+        const started = Date.now();
+        try {
+            const python = await this.resolve(PYTHON_PDF2DOCX);
+            if (!python) {
+                return fail(req, convertError('missing_dependency', 'Missing external dependency: python with the pdf2docx package.', {
+                    missing: [PYTHON_PDF2DOCX],
+                    hint: `Install hint (${process.platform}): ${PYTHON_PDF2DOCX.installHint[platformKey()]}`,
+                }));
+            }
+            const bytesIn = (await fs.stat(req.input)).size;
+            // pdf2docx has no __main__ module and its console script may not be on
+            // PATH - drive the library API directly through the resolved interpreter.
+            await execTool(python, [
+                '-c', 'import sys; from pdf2docx import parse; parse(sys.argv[1], sys.argv[2])',
+                req.input, req.output,
+            ], { timeoutMs: ctx.timeoutMs, signal: ctx.signal });
+            if (!(await exists(req.output))) {
+                return fail(req, convertError('conversion_failed', 'pdf2docx reported success but produced no file.'));
+            }
+            return {
+                ok: true,
+                input: req.input,
+                output: req.output,
+                from: req.from,
+                to: req.to,
+                bytesIn,
+                bytesOut: (await fs.stat(req.output)).size,
+                durationMs: Date.now() - started,
+                warnings: ['PDF → DOCX is experimental: complex layouts may shift; check the result.'],
+            };
+        }
+        catch (err) {
+            if (err instanceof ExecError) {
+                const code = err.code === 'timeout' ? 'timeout' : err.code === 'cancelled' ? 'cancelled' : 'conversion_failed';
+                return fail(req, convertError(code, `Failed to convert ${req.from} → ${req.to} (pdf2docx).`, { detail: err.stderr }));
+            }
+            return fail(req, convertError('conversion_failed', `Failed to convert ${req.from} → ${req.to}`, {
+                detail: err instanceof Error ? err.message : String(err),
+            }));
+        }
+    }
+}

package/lib/core/converters/pdf-env.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/core/converters/pdf-env.js

@@ -0,0 +1,8 @@
+// pdfjs-dist expects browser globals (DOMMatrix, Path2D, ImageData) that Node
+// does not provide. @napi-rs/canvas ships compatible implementations.
+// IMPORTANT: import this module before any pdfjs-dist import.
+import { DOMMatrix, ImageData, Path2D } from '@napi-rs/canvas';
+const globals = globalThis;
+globals.DOMMatrix ??= DOMMatrix;
+globals.Path2D ??= Path2D;
+globals.ImageData ??= ImageData;

package/lib/core/converters/pdf.d.ts

@@ -0,0 +1,22 @@
+import './pdf-env.js';
+import type { BinaryDependency, ConvertContext, ConvertRequest, ConvertResult, Converter, ConversionCapability } from '../types.js';
+/**
+ * PDF conversions, fully local: rasterization via pdfjs-dist + @napi-rs/canvas
+ * (prebuilt npm binaries), text extraction via pdfjs-dist. No Poppler needed.
+ */
+export declare class PdfConverter implements Converter {
+    private readonly resolve?;
+    readonly id = "pdf";
+    readonly concurrency = 2;
+    readonly binaryDeps: never[];
+    readonly capabilities: ConversionCapability[];
+    /** Optional binary resolver, needed only for OCR (Tesseract). */
+    constructor(resolve?: ((dep: BinaryDependency) => Promise<string | null>) | undefined);
+    convert(req: ConvertRequest, ctx: ConvertContext): Promise<ConvertResult>;
+    /**
+     * Multi-page PDFs produce `<base>-<n>.<ext>` files named after the REAL page
+     * number; converting a single page (or a one-page PDF) writes exactly `output`.
+     */
+    private toImages;
+    private toText;
+}