mirror of https://github.com/VERT-sh/VERT.git
feat: add MCP server for file conversion via Claude Code
Standalone stdio MCP server exposing VERT's conversion capabilities. 140+ image formats (ImageMagick WASM), 28+ audio (system ffmpeg), 11 document formats (system pandoc). Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
This commit is contained in:
rmakestrash-jpg
parent
897ae56702
commit
97cfba2acb
|
|
@ -0,0 +1,2 @@
|
||||||
|
node_modules/
|
||||||
|
dist/
|
||||||
File diff suppressed because it is too large
Load Diff
|
|
@ -0,0 +1,38 @@
|
||||||
|
{
|
||||||
|
"name": "@vert-sh/mcp-server",
|
||||||
|
"version": "0.1.0",
|
||||||
|
"type": "module",
|
||||||
|
"bin": "./dist/index.js",
|
||||||
|
"files": [
|
||||||
|
"dist/"
|
||||||
|
],
|
||||||
|
"license": "AGPL-3.0-only",
|
||||||
|
"repository": {
|
||||||
|
"type": "git",
|
||||||
|
"url": "https://github.com/VERT-sh/VERT",
|
||||||
|
"directory": "mcp"
|
||||||
|
},
|
||||||
|
"scripts": {
|
||||||
|
"build": "tsc",
|
||||||
|
"start": "node dist/index.js",
|
||||||
|
"prepublishOnly": "tsc"
|
||||||
|
},
|
||||||
|
"dependencies": {
|
||||||
|
"@imagemagick/magick-wasm": "0.0.38",
|
||||||
|
"@modelcontextprotocol/sdk": "1.27.0",
|
||||||
|
"byte-data": "19.0.1",
|
||||||
|
"riff-file": "1.0.3",
|
||||||
|
"which": "^3.0.0",
|
||||||
|
"yazl": "3.3.1",
|
||||||
|
"zod": "^3.25.0"
|
||||||
|
},
|
||||||
|
"devDependencies": {
|
||||||
|
"@types/node": "^22",
|
||||||
|
"@types/which": "^3",
|
||||||
|
"@types/yazl": "^2",
|
||||||
|
"typescript": "^5.9.3"
|
||||||
|
},
|
||||||
|
"engines": {
|
||||||
|
"node": ">=18.0.0"
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
@ -0,0 +1,355 @@
|
||||||
|
import { execFile } from "node:child_process";
|
||||||
|
import { stat } from "node:fs/promises";
|
||||||
|
import path from "node:path";
|
||||||
|
import which from "which";
|
||||||
|
import { FormatInfo } from "./types.js";
|
||||||
|
import type { ConvertOptions, ConvertResult, NodeConverter } from "./types.js";
|
||||||
|
|
||||||
|
/** Conversion timeout in milliseconds. */
|
||||||
|
const TIMEOUT_MS = 120_000;
|
||||||
|
|
||||||
|
/** Maximum number of concurrent ffmpeg processes. */
|
||||||
|
const MAX_CONCURRENT = 3;
|
||||||
|
|
||||||
|
// ── Audio format definitions (from VERT ffmpeg.svelte.ts lines 43-74) ──
|
||||||
|
|
||||||
|
const AUDIO_FORMATS: FormatInfo[] = [
|
||||||
|
new FormatInfo("mp3"),
|
||||||
|
new FormatInfo("wav"),
|
||||||
|
new FormatInfo("flac"),
|
||||||
|
new FormatInfo("ogg"),
|
||||||
|
new FormatInfo("mogg", true, false), // from only
|
||||||
|
new FormatInfo("oga"),
|
||||||
|
new FormatInfo("opus"),
|
||||||
|
new FormatInfo("aac"),
|
||||||
|
new FormatInfo("alac"), // output extension becomes .m4a
|
||||||
|
new FormatInfo("m4a"),
|
||||||
|
new FormatInfo("caf", true, false), // from only
|
||||||
|
new FormatInfo("wma"),
|
||||||
|
new FormatInfo("amr"),
|
||||||
|
new FormatInfo("ac3"),
|
||||||
|
new FormatInfo("aiff"),
|
||||||
|
new FormatInfo("aifc"),
|
||||||
|
new FormatInfo("aif"),
|
||||||
|
new FormatInfo("mp1", true, false), // from only
|
||||||
|
new FormatInfo("mp2"),
|
||||||
|
new FormatInfo("mpc", true, false), // from only
|
||||||
|
new FormatInfo("dsd", true, false), // from only
|
||||||
|
new FormatInfo("dsf", true, false), // from only
|
||||||
|
new FormatInfo("dff", true, false), // from only
|
||||||
|
new FormatInfo("mqa", true, false), // from only
|
||||||
|
new FormatInfo("au"),
|
||||||
|
new FormatInfo("m4b"),
|
||||||
|
new FormatInfo("voc"),
|
||||||
|
new FormatInfo("weba"),
|
||||||
|
];
|
||||||
|
|
||||||
|
// ── Video format definitions (input only for audio extraction) ──
|
||||||
|
|
||||||
|
const VIDEO_FORMATS: FormatInfo[] = [
|
||||||
|
new FormatInfo("mkv", true, false, false),
|
||||||
|
new FormatInfo("mp4", true, false, false),
|
||||||
|
new FormatInfo("avi", true, false, false),
|
||||||
|
new FormatInfo("mov", true, false, false),
|
||||||
|
new FormatInfo("webm", true, false, false),
|
||||||
|
new FormatInfo("ts", true, false, false),
|
||||||
|
new FormatInfo("mts", true, false, false),
|
||||||
|
new FormatInfo("m2ts", true, false, false),
|
||||||
|
new FormatInfo("wmv", true, false, false),
|
||||||
|
new FormatInfo("mpg", true, false, false),
|
||||||
|
new FormatInfo("mpeg", true, false, false),
|
||||||
|
new FormatInfo("flv", true, false, false),
|
||||||
|
new FormatInfo("f4v", true, false, false),
|
||||||
|
new FormatInfo("vob", true, false, false),
|
||||||
|
new FormatInfo("m4v", true, false, false),
|
||||||
|
new FormatInfo("3gp", true, false, false),
|
||||||
|
new FormatInfo("3g2", true, false, false),
|
||||||
|
new FormatInfo("mxf", true, false, false),
|
||||||
|
new FormatInfo("ogv", true, false, false),
|
||||||
|
new FormatInfo("rm", true, false, false),
|
||||||
|
new FormatInfo("rmvb", true, false, false),
|
||||||
|
new FormatInfo("divx", true, false, false),
|
||||||
|
];
|
||||||
|
|
||||||
|
/** Set of video extensions (undotted, lowercase) for detecting video input. */
|
||||||
|
const VIDEO_EXTENSIONS = new Set(
|
||||||
|
VIDEO_FORMATS.map((f) => f.name.slice(1).toLowerCase()),
|
||||||
|
);
|
||||||
|
|
||||||
|
// ── Codec mappings (from VERT ffmpeg.svelte.ts lines 636-699 + additions) ──
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Get the FFmpeg codec string for a given output format extension.
|
||||||
|
* Adapted from VERT's getCodecs() with additions for missing codecs.
|
||||||
|
*/
|
||||||
|
function getCodec(ext: string): string {
|
||||||
|
switch (ext) {
|
||||||
|
case "mp3":
|
||||||
|
return "libmp3lame";
|
||||||
|
case "wav":
|
||||||
|
return "pcm_s16le";
|
||||||
|
case "flac":
|
||||||
|
return "flac";
|
||||||
|
case "ogg":
|
||||||
|
case "oga":
|
||||||
|
return "libvorbis";
|
||||||
|
case "opus":
|
||||||
|
return "libopus";
|
||||||
|
case "aac":
|
||||||
|
return "aac";
|
||||||
|
case "alac":
|
||||||
|
return "alac";
|
||||||
|
case "m4a":
|
||||||
|
return "aac";
|
||||||
|
case "m4b":
|
||||||
|
return "aac";
|
||||||
|
case "wma":
|
||||||
|
return "wmav2";
|
||||||
|
case "amr":
|
||||||
|
return "libopencore_amrnb";
|
||||||
|
case "ac3":
|
||||||
|
return "ac3";
|
||||||
|
case "aiff":
|
||||||
|
case "aifc":
|
||||||
|
case "aif":
|
||||||
|
return "pcm_s16be";
|
||||||
|
case "mp2":
|
||||||
|
return "mp2";
|
||||||
|
case "au":
|
||||||
|
return "pcm_mulaw";
|
||||||
|
case "voc":
|
||||||
|
return "pcm_u8";
|
||||||
|
case "weba":
|
||||||
|
return "libopus";
|
||||||
|
case "caf":
|
||||||
|
return "pcm_s16le";
|
||||||
|
default:
|
||||||
|
return "copy";
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Check if the given extension is a video format we recognize as input.
|
||||||
|
*/
|
||||||
|
function isVideoInput(ext: string): boolean {
|
||||||
|
return VIDEO_EXTENSIONS.has(ext.toLowerCase());
|
||||||
|
}
|
||||||
|
|
||||||
|
// ── Concurrency limiter ──
|
||||||
|
|
||||||
|
let activeProcesses = 0;
|
||||||
|
const waitQueue: Array<() => void> = [];
|
||||||
|
|
||||||
|
function acquireSlot(): Promise<void> {
|
||||||
|
if (activeProcesses < MAX_CONCURRENT) {
|
||||||
|
activeProcesses++;
|
||||||
|
return Promise.resolve();
|
||||||
|
}
|
||||||
|
return new Promise<void>((resolve) => {
|
||||||
|
waitQueue.push(() => {
|
||||||
|
activeProcesses++;
|
||||||
|
resolve();
|
||||||
|
});
|
||||||
|
});
|
||||||
|
}
|
||||||
|
|
||||||
|
function releaseSlot(): void {
|
||||||
|
activeProcesses--;
|
||||||
|
const next = waitQueue.shift();
|
||||||
|
if (next) {
|
||||||
|
next();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// ── Helpers ──
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Run ffmpeg with the given arguments via execFile (no shell).
|
||||||
|
* Returns a promise that resolves on success or rejects on failure.
|
||||||
|
*/
|
||||||
|
function runFFmpeg(ffmpegPath: string, args: string[]): Promise<{ stdout: string; stderr: string }> {
|
||||||
|
return new Promise((resolve, reject) => {
|
||||||
|
execFile(
|
||||||
|
ffmpegPath,
|
||||||
|
args,
|
||||||
|
{
|
||||||
|
timeout: TIMEOUT_MS,
|
||||||
|
maxBuffer: 10 * 1024 * 1024,
|
||||||
|
windowsHide: true,
|
||||||
|
},
|
||||||
|
(error, stdout, stderr) => {
|
||||||
|
if (error) {
|
||||||
|
reject(new Error(
|
||||||
|
`ffmpeg failed: ${error.message}\n${stderr}`,
|
||||||
|
));
|
||||||
|
} else {
|
||||||
|
resolve({ stdout, stderr });
|
||||||
|
}
|
||||||
|
},
|
||||||
|
);
|
||||||
|
});
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Build the FFmpeg conversion command arguments.
|
||||||
|
* Adapted from VERT's buildConversionCommand() (ffmpeg.svelte.ts lines 315-527).
|
||||||
|
*/
|
||||||
|
function buildConversionArgs(options: ConvertOptions, inputExt: string): string[] {
|
||||||
|
const {
|
||||||
|
inputPath,
|
||||||
|
outputPath,
|
||||||
|
outputFormat,
|
||||||
|
audioBitrate,
|
||||||
|
sampleRate,
|
||||||
|
keepMetadata,
|
||||||
|
} = options;
|
||||||
|
|
||||||
|
// Determine the actual output format and codec
|
||||||
|
let actualOutputFormat = outputFormat.toLowerCase();
|
||||||
|
let actualOutputPath = outputPath;
|
||||||
|
|
||||||
|
// ALAC: output_format="alac" -> actual file ext .m4a, codec alac
|
||||||
|
if (actualOutputFormat === "alac") {
|
||||||
|
// The output path should already have .m4a extension (handled by caller),
|
||||||
|
// but the codec is "alac"
|
||||||
|
actualOutputFormat = "alac";
|
||||||
|
}
|
||||||
|
|
||||||
|
const codec = getCodec(actualOutputFormat);
|
||||||
|
const isVideoSource = isVideoInput(inputExt);
|
||||||
|
|
||||||
|
const args: string[] = [];
|
||||||
|
|
||||||
|
// Security: restrict protocols to prevent SSRF
|
||||||
|
args.push("-protocol_whitelist", "file,pipe");
|
||||||
|
|
||||||
|
// Overwrite output without asking (we handle uniqueness ourselves)
|
||||||
|
args.push("-y");
|
||||||
|
|
||||||
|
// Input file
|
||||||
|
// -i takes its argument directly; no -- between flag and value.
|
||||||
|
args.push("-i", inputPath);
|
||||||
|
|
||||||
|
// If extracting audio from video, map only the first audio stream
|
||||||
|
if (isVideoSource) {
|
||||||
|
args.push("-map", "0:a:0");
|
||||||
|
}
|
||||||
|
|
||||||
|
// Audio codec
|
||||||
|
if (codec !== "copy") {
|
||||||
|
args.push("-c:a", codec);
|
||||||
|
}
|
||||||
|
|
||||||
|
// Metadata handling
|
||||||
|
if (keepMetadata === false) {
|
||||||
|
args.push("-map_metadata", "-1");
|
||||||
|
args.push("-map_chapters", "-1");
|
||||||
|
if (!isVideoSource) {
|
||||||
|
args.push("-map", "a");
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// Audio bitrate
|
||||||
|
if (audioBitrate) {
|
||||||
|
args.push("-b:a", audioBitrate);
|
||||||
|
}
|
||||||
|
|
||||||
|
// Sample rate handling
|
||||||
|
if (sampleRate) {
|
||||||
|
// Opus 44100 -> 48000 auto-adjustment
|
||||||
|
if ((actualOutputFormat === "opus" || actualOutputFormat === "weba") && sampleRate === 44100) {
|
||||||
|
args.push("-ar", "48000");
|
||||||
|
} else {
|
||||||
|
args.push("-ar", String(sampleRate));
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
// If no sample rate specified and output is opus, default to 48000
|
||||||
|
// (Opus doesn't support 44100Hz)
|
||||||
|
if (actualOutputFormat === "opus" || actualOutputFormat === "weba") {
|
||||||
|
args.push("-ar", "48000");
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// End of options separator, then output file path
|
||||||
|
// -- prevents output paths starting with "-" from being interpreted as flags
|
||||||
|
args.push("--", actualOutputPath);
|
||||||
|
|
||||||
|
return args;
|
||||||
|
}
|
||||||
|
|
||||||
|
// ── FFmpeg Node Converter ──
|
||||||
|
|
||||||
|
/**
|
||||||
|
* FFmpeg-based audio converter using the system ffmpeg binary.
|
||||||
|
* Gracefully unavailable if ffmpeg is not installed.
|
||||||
|
*/
|
||||||
|
export class FFmpegNodeConverter implements NodeConverter {
|
||||||
|
readonly name = "ffmpeg";
|
||||||
|
readonly supportedFormats: FormatInfo[] = [...AUDIO_FORMATS, ...VIDEO_FORMATS];
|
||||||
|
|
||||||
|
private ffmpegPath: string | null = null;
|
||||||
|
private available: boolean | null = null;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Check if ffmpeg is available on the system.
|
||||||
|
* Caches the result after the first check.
|
||||||
|
*/
|
||||||
|
async isAvailable(): Promise<boolean> {
|
||||||
|
if (this.available !== null) {
|
||||||
|
return this.available;
|
||||||
|
}
|
||||||
|
|
||||||
|
try {
|
||||||
|
this.ffmpegPath = await which("ffmpeg");
|
||||||
|
this.available = true;
|
||||||
|
} catch {
|
||||||
|
this.ffmpegPath = null;
|
||||||
|
this.available = false;
|
||||||
|
}
|
||||||
|
|
||||||
|
return this.available;
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Convert an audio file using system ffmpeg.
|
||||||
|
* Supports audio-to-audio conversion and video-to-audio extraction.
|
||||||
|
*/
|
||||||
|
async convert(options: ConvertOptions): Promise<ConvertResult> {
|
||||||
|
if (!(await this.isAvailable()) || !this.ffmpegPath) {
|
||||||
|
throw new Error("ffmpeg is not installed on this system");
|
||||||
|
}
|
||||||
|
|
||||||
|
const inputExt = path.extname(options.inputPath).slice(1).toLowerCase();
|
||||||
|
|
||||||
|
// Determine actual output path (ALAC uses .m4a extension)
|
||||||
|
let actualOutputPath = options.outputPath;
|
||||||
|
if (options.outputFormat.toLowerCase() === "alac") {
|
||||||
|
const dir = path.dirname(options.outputPath);
|
||||||
|
const base = path.basename(options.outputPath, path.extname(options.outputPath));
|
||||||
|
actualOutputPath = path.join(dir, `${base}.m4a`);
|
||||||
|
}
|
||||||
|
|
||||||
|
const effectiveOptions: ConvertOptions = {
|
||||||
|
...options,
|
||||||
|
outputPath: actualOutputPath,
|
||||||
|
};
|
||||||
|
|
||||||
|
const args = buildConversionArgs(effectiveOptions, inputExt);
|
||||||
|
|
||||||
|
await acquireSlot();
|
||||||
|
try {
|
||||||
|
await runFFmpeg(this.ffmpegPath, args);
|
||||||
|
} finally {
|
||||||
|
releaseSlot();
|
||||||
|
}
|
||||||
|
|
||||||
|
// Verify output exists and get size
|
||||||
|
const stats = await stat(actualOutputPath);
|
||||||
|
|
||||||
|
return {
|
||||||
|
outputPath: actualOutputPath,
|
||||||
|
format: options.outputFormat.toLowerCase(),
|
||||||
|
sizeBytes: stats.size,
|
||||||
|
};
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
@ -0,0 +1,620 @@
|
||||||
|
import { createRequire } from "node:module";
|
||||||
|
import { readFileSync, writeFileSync, statSync } from "node:fs";
|
||||||
|
import { basename, extname } from "node:path";
|
||||||
|
import {
|
||||||
|
initializeImageMagick,
|
||||||
|
ImageMagick,
|
||||||
|
MagickFormat,
|
||||||
|
MagickReadSettings,
|
||||||
|
} from "@imagemagick/magick-wasm";
|
||||||
|
import yazl from "yazl";
|
||||||
|
import { parseAni } from "../util/parse-ani.js";
|
||||||
|
import { FormatInfo, type ConvertOptions, type ConvertResult, type NodeConverter } from "./types.js";
|
||||||
|
|
||||||
|
/** Maximum number of frames to extract from ICO/ANI files. */
|
||||||
|
const MAX_FRAMES = 256;
|
||||||
|
|
||||||
|
/** Conversion timeout in milliseconds. */
|
||||||
|
const CONVERSION_TIMEOUT_MS = 120_000;
|
||||||
|
|
||||||
|
// ---------------------------------------------------------------------------
|
||||||
|
// Format lists
|
||||||
|
// ---------------------------------------------------------------------------
|
||||||
|
|
||||||
|
// Blocked formats that lack WASM delegates or are unsafe:
|
||||||
|
// svg, nef, cr2, arw, dng, rw2, raf, orf, pef, mos, raw, dcr, crw, cr3, 3fr,
|
||||||
|
// erf, mrw, mef, nrw, srw, sr2, srf, eps, icns, xcf
|
||||||
|
// ps, ps1, svgz, epdf, epi, eps2, eps3, epsf, epsi, ept, ept2, ept3
|
||||||
|
|
||||||
|
/** Manually tested image formats from VERT (magick.svelte.ts lines 19-78), blocked formats removed. */
|
||||||
|
const MANUAL_FORMATS: FormatInfo[] = [
|
||||||
|
new FormatInfo("png", true, true),
|
||||||
|
new FormatInfo("jpeg", true, true),
|
||||||
|
new FormatInfo("jpg", true, true),
|
||||||
|
new FormatInfo("webp", true, true),
|
||||||
|
new FormatInfo("gif", true, true),
|
||||||
|
// svg blocked (no WASM delegate)
|
||||||
|
new FormatInfo("jxl", true, true),
|
||||||
|
new FormatInfo("avif", true, true),
|
||||||
|
new FormatInfo("heic", true, false),
|
||||||
|
new FormatInfo("heif", true, false),
|
||||||
|
new FormatInfo("ico", true, true),
|
||||||
|
new FormatInfo("bmp", true, true),
|
||||||
|
new FormatInfo("cur", true, true),
|
||||||
|
new FormatInfo("ani", true, false),
|
||||||
|
// icns blocked (needs vert-wasm)
|
||||||
|
// nef blocked (needs libraw)
|
||||||
|
// cr2 blocked (needs libraw)
|
||||||
|
new FormatInfo("hdr", true, true),
|
||||||
|
new FormatInfo("jpe", true, true),
|
||||||
|
new FormatInfo("mat", true, true),
|
||||||
|
new FormatInfo("pbm", true, true),
|
||||||
|
new FormatInfo("pfm", true, true),
|
||||||
|
new FormatInfo("pgm", true, true),
|
||||||
|
new FormatInfo("pnm", true, true),
|
||||||
|
new FormatInfo("ppm", true, true),
|
||||||
|
new FormatInfo("tiff", true, true),
|
||||||
|
new FormatInfo("jfif", true, true),
|
||||||
|
// eps blocked (needs Ghostscript)
|
||||||
|
new FormatInfo("psd", true, true),
|
||||||
|
new FormatInfo("svg", false, true),
|
||||||
|
new FormatInfo("svgz", false, true),
|
||||||
|
// arw blocked (needs libraw)
|
||||||
|
new FormatInfo("tif", true, true),
|
||||||
|
// dng blocked (needs libraw)
|
||||||
|
// xcf blocked
|
||||||
|
// rw2 blocked (needs libraw)
|
||||||
|
// raf blocked (needs libraw)
|
||||||
|
// orf blocked (needs libraw)
|
||||||
|
// pef blocked (needs libraw)
|
||||||
|
// mos blocked (needs libraw)
|
||||||
|
// raw blocked (needs libraw)
|
||||||
|
// dcr blocked (needs libraw)
|
||||||
|
// crw blocked (needs libraw)
|
||||||
|
// cr3 blocked (needs libraw)
|
||||||
|
// 3fr blocked (needs libraw)
|
||||||
|
// erf blocked (needs libraw)
|
||||||
|
// mrw blocked (needs libraw)
|
||||||
|
// mef blocked (needs libraw)
|
||||||
|
// nrw blocked (needs libraw)
|
||||||
|
// srw blocked (needs libraw)
|
||||||
|
// sr2 blocked (needs libraw)
|
||||||
|
// srf blocked (needs libraw)
|
||||||
|
];
|
||||||
|
|
||||||
|
/** Automated formats from VERT (magick-automated.ts), blocked formats removed. */
|
||||||
|
const AUTOMATED_FORMATS: FormatInfo[] = [
|
||||||
|
new FormatInfo("a", false, true),
|
||||||
|
new FormatInfo("aai", true, true),
|
||||||
|
new FormatInfo("ai", false, true),
|
||||||
|
new FormatInfo("art", false, true),
|
||||||
|
new FormatInfo("avs", true, true),
|
||||||
|
new FormatInfo("b", false, true),
|
||||||
|
new FormatInfo("bgr", false, true),
|
||||||
|
new FormatInfo("bgra", false, true),
|
||||||
|
new FormatInfo("bgro", false, true),
|
||||||
|
new FormatInfo("bmp2", true, true),
|
||||||
|
new FormatInfo("bmp3", true, true),
|
||||||
|
new FormatInfo("brf", false, true),
|
||||||
|
new FormatInfo("cal", false, true),
|
||||||
|
new FormatInfo("cals", false, true),
|
||||||
|
new FormatInfo("cin", true, true),
|
||||||
|
new FormatInfo("cip", false, true),
|
||||||
|
new FormatInfo("cmyk", false, true),
|
||||||
|
new FormatInfo("cmyka", false, true),
|
||||||
|
new FormatInfo("dcx", true, true),
|
||||||
|
new FormatInfo("dds", true, true),
|
||||||
|
new FormatInfo("dpx", true, true),
|
||||||
|
new FormatInfo("dxt1", true, true),
|
||||||
|
new FormatInfo("dxt5", true, true),
|
||||||
|
// epdf blocked
|
||||||
|
// epi blocked
|
||||||
|
// eps2 blocked
|
||||||
|
// eps3 blocked
|
||||||
|
// epsf blocked
|
||||||
|
// epsi blocked
|
||||||
|
// ept blocked
|
||||||
|
// ept2 blocked
|
||||||
|
// ept3 blocked
|
||||||
|
new FormatInfo("exr", true, true),
|
||||||
|
new FormatInfo("farbfeld", true, true),
|
||||||
|
new FormatInfo("fax", true, true),
|
||||||
|
new FormatInfo("ff", true, true),
|
||||||
|
new FormatInfo("fit", true, true),
|
||||||
|
new FormatInfo("fits", true, true),
|
||||||
|
new FormatInfo("fl32", true, true),
|
||||||
|
new FormatInfo("fts", true, true),
|
||||||
|
new FormatInfo("ftxt", false, true),
|
||||||
|
new FormatInfo("g", false, true),
|
||||||
|
new FormatInfo("g3", true, true),
|
||||||
|
new FormatInfo("g4", false, true),
|
||||||
|
new FormatInfo("gif87", true, true),
|
||||||
|
new FormatInfo("gray", false, true),
|
||||||
|
new FormatInfo("graya", false, true),
|
||||||
|
new FormatInfo("group4", false, true),
|
||||||
|
new FormatInfo("hrz", true, true),
|
||||||
|
new FormatInfo("icb", true, true),
|
||||||
|
new FormatInfo("icon", true, true),
|
||||||
|
new FormatInfo("info", false, true),
|
||||||
|
new FormatInfo("ipl", true, true),
|
||||||
|
new FormatInfo("isobrl", false, true),
|
||||||
|
new FormatInfo("isobrl6", false, true),
|
||||||
|
new FormatInfo("j2c", true, true),
|
||||||
|
new FormatInfo("j2k", true, true),
|
||||||
|
new FormatInfo("jng", true, true),
|
||||||
|
new FormatInfo("jp2", true, true),
|
||||||
|
new FormatInfo("jpc", true, true),
|
||||||
|
new FormatInfo("jpm", true, true),
|
||||||
|
new FormatInfo("jps", true, true),
|
||||||
|
new FormatInfo("map", false, true),
|
||||||
|
new FormatInfo("miff", true, true),
|
||||||
|
new FormatInfo("mng", true, true),
|
||||||
|
new FormatInfo("mono", false, true),
|
||||||
|
new FormatInfo("mtv", true, true),
|
||||||
|
new FormatInfo("o", false, true),
|
||||||
|
new FormatInfo("otb", true, true),
|
||||||
|
new FormatInfo("pal", false, true),
|
||||||
|
new FormatInfo("palm", true, true),
|
||||||
|
new FormatInfo("pam", true, true),
|
||||||
|
new FormatInfo("pcd", true, true),
|
||||||
|
new FormatInfo("pcds", true, true),
|
||||||
|
new FormatInfo("pcl", false, true),
|
||||||
|
new FormatInfo("pct", true, true),
|
||||||
|
new FormatInfo("pcx", true, true),
|
||||||
|
new FormatInfo("pdb", true, true),
|
||||||
|
new FormatInfo("pgx", true, true),
|
||||||
|
new FormatInfo("phm", true, true),
|
||||||
|
new FormatInfo("picon", true, true),
|
||||||
|
new FormatInfo("pict", true, true),
|
||||||
|
new FormatInfo("pjpeg", true, true),
|
||||||
|
new FormatInfo("png00", true, true),
|
||||||
|
new FormatInfo("png24", true, true),
|
||||||
|
new FormatInfo("png32", true, true),
|
||||||
|
new FormatInfo("png48", true, true),
|
||||||
|
new FormatInfo("png64", true, true),
|
||||||
|
new FormatInfo("png8", true, true),
|
||||||
|
// ps blocked
|
||||||
|
// ps1 blocked
|
||||||
|
new FormatInfo("ps2", false, true),
|
||||||
|
new FormatInfo("ps3", false, true),
|
||||||
|
new FormatInfo("psb", true, true),
|
||||||
|
new FormatInfo("ptif", true, true),
|
||||||
|
new FormatInfo("qoi", true, true),
|
||||||
|
new FormatInfo("r", false, true),
|
||||||
|
new FormatInfo("ras", true, true),
|
||||||
|
new FormatInfo("rgb", false, true),
|
||||||
|
new FormatInfo("rgba", false, true),
|
||||||
|
new FormatInfo("rgbo", false, true),
|
||||||
|
new FormatInfo("rgf", true, true),
|
||||||
|
new FormatInfo("sgi", true, true),
|
||||||
|
new FormatInfo("six", true, true),
|
||||||
|
new FormatInfo("sixel", true, true),
|
||||||
|
new FormatInfo("sparse-color", false, true),
|
||||||
|
new FormatInfo("strimg", false, true),
|
||||||
|
new FormatInfo("sun", true, true),
|
||||||
|
// svgz blocked
|
||||||
|
new FormatInfo("tga", true, true),
|
||||||
|
new FormatInfo("tiff64", true, true),
|
||||||
|
new FormatInfo("ubrl", false, true),
|
||||||
|
new FormatInfo("ubrl6", false, true),
|
||||||
|
new FormatInfo("uil", false, true),
|
||||||
|
new FormatInfo("uyvy", false, true),
|
||||||
|
new FormatInfo("vda", true, true),
|
||||||
|
new FormatInfo("vicar", true, true),
|
||||||
|
new FormatInfo("viff", true, true),
|
||||||
|
new FormatInfo("vips", true, true),
|
||||||
|
new FormatInfo("vst", true, true),
|
||||||
|
new FormatInfo("wbmp", true, true),
|
||||||
|
new FormatInfo("wpg", true, true),
|
||||||
|
new FormatInfo("xbm", true, true),
|
||||||
|
new FormatInfo("xpm", true, true),
|
||||||
|
new FormatInfo("xv", true, true),
|
||||||
|
new FormatInfo("ycbcr", false, true),
|
||||||
|
new FormatInfo("ycbcra", false, true),
|
||||||
|
new FormatInfo("yuv", false, true),
|
||||||
|
];
|
||||||
|
|
||||||
|
// ---------------------------------------------------------------------------
|
||||||
|
// Format normalization helpers
|
||||||
|
// ---------------------------------------------------------------------------
|
||||||
|
|
||||||
|
/** Normalize input extension: .jfif->.jpeg, .fit->.fits (bidirectional). */
|
||||||
|
function normalizeInputExt(ext: string): string {
|
||||||
|
const lower = ext.toLowerCase();
|
||||||
|
if (lower === ".jfif") return ".jpeg";
|
||||||
|
if (lower === ".fit") return ".fits";
|
||||||
|
return lower;
|
||||||
|
}
|
||||||
|
|
||||||
|
/** Normalize output extension: .jfif->.jpeg, .fit->.fits (bidirectional). */
|
||||||
|
function normalizeOutputExt(ext: string): string {
|
||||||
|
const lower = ext.toLowerCase();
|
||||||
|
if (lower === ".jfif") return ".jpeg";
|
||||||
|
if (lower === ".fit") return ".fits";
|
||||||
|
return lower;
|
||||||
|
}
|
||||||
|
|
||||||
|
/** Convert an extension (without dot) to a MagickFormat enum value. */
|
||||||
|
function extToMagickFormat(ext: string): MagickFormat {
|
||||||
|
return ext.toUpperCase() as unknown as MagickFormat;
|
||||||
|
}
|
||||||
|
|
||||||
|
// ---------------------------------------------------------------------------
|
||||||
|
// Serialization queue
|
||||||
|
// ---------------------------------------------------------------------------
|
||||||
|
|
||||||
|
/** Simple serialization queue — ensures one conversion at a time for the single WASM instance. */
|
||||||
|
class SerialQueue {
|
||||||
|
private queue: Array<{ run: () => Promise<void>; }> = [];
|
||||||
|
private running = false;
|
||||||
|
|
||||||
|
enqueue<T>(fn: () => Promise<T>): Promise<T> {
|
||||||
|
return new Promise<T>((resolve, reject) => {
|
||||||
|
this.queue.push({
|
||||||
|
run: async () => {
|
||||||
|
try {
|
||||||
|
resolve(await fn());
|
||||||
|
} catch (err) {
|
||||||
|
reject(err);
|
||||||
|
}
|
||||||
|
},
|
||||||
|
});
|
||||||
|
this.drain();
|
||||||
|
});
|
||||||
|
}
|
||||||
|
|
||||||
|
private async drain(): Promise<void> {
|
||||||
|
if (this.running) return;
|
||||||
|
this.running = true;
|
||||||
|
while (this.queue.length > 0) {
|
||||||
|
const item = this.queue.shift()!;
|
||||||
|
await item.run();
|
||||||
|
}
|
||||||
|
this.running = false;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// ---------------------------------------------------------------------------
|
||||||
|
// ZIP helper using yazl
|
||||||
|
// ---------------------------------------------------------------------------
|
||||||
|
|
||||||
|
/** Create a ZIP buffer from an array of named buffers. */
|
||||||
|
function createZip(entries: Array<{ name: string; data: Buffer }>): Promise<Buffer> {
|
||||||
|
return new Promise<Buffer>((resolve, reject) => {
|
||||||
|
const zipFile = new yazl.ZipFile();
|
||||||
|
for (const entry of entries) {
|
||||||
|
zipFile.addBuffer(entry.data, entry.name);
|
||||||
|
}
|
||||||
|
zipFile.end();
|
||||||
|
|
||||||
|
const chunks: Buffer[] = [];
|
||||||
|
zipFile.outputStream.on("data", (chunk: Buffer) => {
|
||||||
|
chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
|
||||||
|
});
|
||||||
|
zipFile.outputStream.on("end", () => {
|
||||||
|
resolve(Buffer.concat(chunks));
|
||||||
|
});
|
||||||
|
zipFile.outputStream.on("error", (err: Error) => {
|
||||||
|
reject(err);
|
||||||
|
});
|
||||||
|
});
|
||||||
|
}
|
||||||
|
|
||||||
|
// ---------------------------------------------------------------------------
|
||||||
|
// Timeout helper
|
||||||
|
// ---------------------------------------------------------------------------
|
||||||
|
|
||||||
|
function withTimeout<T>(promise: Promise<T>, ms: number, label: string): Promise<T> {
|
||||||
|
return new Promise<T>((resolve, reject) => {
|
||||||
|
const timer = setTimeout(() => {
|
||||||
|
reject(new Error(`Conversion timed out after ${ms / 1000} seconds: ${label}`));
|
||||||
|
}, ms);
|
||||||
|
promise.then(
|
||||||
|
(val) => { clearTimeout(timer); resolve(val); },
|
||||||
|
(err) => { clearTimeout(timer); reject(err); },
|
||||||
|
);
|
||||||
|
});
|
||||||
|
}
|
||||||
|
|
||||||
|
// ---------------------------------------------------------------------------
|
||||||
|
// MagickNodeConverter
|
||||||
|
// ---------------------------------------------------------------------------
|
||||||
|
|
||||||
|
/**
|
||||||
|
* ImageMagick WASM converter for Node.js.
|
||||||
|
* Uses @imagemagick/magick-wasm with lazy initialization, serialized queue,
|
||||||
|
* and callback-based auto-disposal.
|
||||||
|
*/
|
||||||
|
export class MagickNodeConverter implements NodeConverter {
|
||||||
|
readonly name = "imagemagick";
|
||||||
|
readonly supportedFormats: FormatInfo[] = [...MANUAL_FORMATS, ...AUTOMATED_FORMATS];
|
||||||
|
|
||||||
|
private initialized = false;
|
||||||
|
private initPromise: Promise<void> | null = null;
|
||||||
|
private readonly queue = new SerialQueue();
|
||||||
|
|
||||||
|
/** Lazy-initialize the WASM module on first call. */
|
||||||
|
private async ensureInitialized(): Promise<void> {
|
||||||
|
if (this.initialized) return;
|
||||||
|
if (this.initPromise) {
|
||||||
|
await this.initPromise;
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
this.initPromise = (async () => {
|
||||||
|
const require = createRequire(import.meta.url);
|
||||||
|
const wasmPath = require.resolve("@imagemagick/magick-wasm/magick.wasm");
|
||||||
|
const wasmBytes = readFileSync(wasmPath);
|
||||||
|
await initializeImageMagick(wasmBytes);
|
||||||
|
this.initialized = true;
|
||||||
|
})();
|
||||||
|
await this.initPromise;
|
||||||
|
}
|
||||||
|
|
||||||
|
/** ImageMagick WASM is always available (bundled). */
|
||||||
|
async isAvailable(): Promise<boolean> {
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
|
||||||
|
/** Convert an image file. */
|
||||||
|
async convert(options: ConvertOptions): Promise<ConvertResult> {
|
||||||
|
await this.ensureInitialized();
|
||||||
|
|
||||||
|
return withTimeout(
|
||||||
|
this.queue.enqueue(() => this.doConvert(options)),
|
||||||
|
CONVERSION_TIMEOUT_MS,
|
||||||
|
`${basename(options.inputPath)} -> ${options.outputFormat}`,
|
||||||
|
);
|
||||||
|
}
|
||||||
|
|
||||||
|
/** Internal conversion dispatched inside the serialized queue. */
|
||||||
|
private async doConvert(options: ConvertOptions): Promise<ConvertResult> {
|
||||||
|
const { inputPath, outputPath, quality, keepMetadata = true } = options;
|
||||||
|
const inputBytes = new Uint8Array(readFileSync(inputPath));
|
||||||
|
|
||||||
|
const rawInputExt = extname(inputPath).toLowerCase();
|
||||||
|
const from = normalizeInputExt(rawInputExt);
|
||||||
|
|
||||||
|
let outputExt = options.outputFormat.startsWith(".")
|
||||||
|
? options.outputFormat.toLowerCase()
|
||||||
|
: `.${options.outputFormat.toLowerCase()}`;
|
||||||
|
outputExt = normalizeOutputExt(outputExt);
|
||||||
|
|
||||||
|
// -----------------------------------------------------------------
|
||||||
|
// ICO input: extract individual frames → ZIP
|
||||||
|
// -----------------------------------------------------------------
|
||||||
|
if (from === ".ico") {
|
||||||
|
return this.convertIco(inputBytes, outputExt, outputPath, keepMetadata, quality);
|
||||||
|
}
|
||||||
|
|
||||||
|
// -----------------------------------------------------------------
|
||||||
|
// ANI input: parse frames → convert each → ZIP
|
||||||
|
// -----------------------------------------------------------------
|
||||||
|
if (from === ".ani") {
|
||||||
|
return this.convertAni(inputBytes, outputExt, outputPath, keepMetadata, quality);
|
||||||
|
}
|
||||||
|
|
||||||
|
// -----------------------------------------------------------------
|
||||||
|
// Animated GIF/WebP input → GIF/WebP output: use readCollection
|
||||||
|
// -----------------------------------------------------------------
|
||||||
|
if (
|
||||||
|
(from === ".gif" || from === ".webp") &&
|
||||||
|
(outputExt === ".gif" || outputExt === ".webp")
|
||||||
|
) {
|
||||||
|
return this.convertAnimated(inputBytes, from, outputExt, outputPath, keepMetadata, quality);
|
||||||
|
}
|
||||||
|
|
||||||
|
// -----------------------------------------------------------------
|
||||||
|
// Standard single-image conversion
|
||||||
|
// -----------------------------------------------------------------
|
||||||
|
const outputFmt = extToMagickFormat(outputExt.slice(1));
|
||||||
|
const inputFmt = extToMagickFormat(from.slice(1));
|
||||||
|
|
||||||
|
const result = ImageMagick.read(inputBytes, new MagickReadSettings({ format: inputFmt }), (img) => {
|
||||||
|
// ICO output: clamp to 256x256 max
|
||||||
|
if (outputExt === ".ico") {
|
||||||
|
this.clampForIco(img);
|
||||||
|
}
|
||||||
|
|
||||||
|
if (quality !== undefined) {
|
||||||
|
img.quality = quality;
|
||||||
|
}
|
||||||
|
if (!keepMetadata) {
|
||||||
|
img.strip();
|
||||||
|
}
|
||||||
|
|
||||||
|
let outputBuffer: Buffer = Buffer.alloc(0);
|
||||||
|
img.write(outputFmt, (data) => {
|
||||||
|
outputBuffer = Buffer.from(data);
|
||||||
|
});
|
||||||
|
return outputBuffer;
|
||||||
|
});
|
||||||
|
|
||||||
|
writeFileSync(outputPath, result);
|
||||||
|
|
||||||
|
const stat = statSync(outputPath);
|
||||||
|
return {
|
||||||
|
outputPath,
|
||||||
|
format: outputExt.slice(1),
|
||||||
|
sizeBytes: stat.size,
|
||||||
|
};
|
||||||
|
}
|
||||||
|
|
||||||
|
/** Convert ICO: read individual frames, convert each, ZIP output. */
|
||||||
|
private async convertIco(
|
||||||
|
inputBytes: Uint8Array,
|
||||||
|
outputExt: string,
|
||||||
|
outputPath: string,
|
||||||
|
keepMetadata: boolean,
|
||||||
|
quality?: number,
|
||||||
|
): Promise<ConvertResult> {
|
||||||
|
const outputFmt = extToMagickFormat(outputExt.slice(1));
|
||||||
|
const entries: Array<{ name: string; data: Buffer }> = [];
|
||||||
|
|
||||||
|
for (let i = 0; i < MAX_FRAMES; i++) {
|
||||||
|
try {
|
||||||
|
const frameBuffer = ImageMagick.read(
|
||||||
|
inputBytes,
|
||||||
|
new MagickReadSettings({
|
||||||
|
format: MagickFormat.Ico,
|
||||||
|
frameIndex: i,
|
||||||
|
}),
|
||||||
|
(img) => {
|
||||||
|
if (outputExt === ".ico") {
|
||||||
|
this.clampForIco(img);
|
||||||
|
}
|
||||||
|
if (quality !== undefined) {
|
||||||
|
img.quality = quality;
|
||||||
|
}
|
||||||
|
if (!keepMetadata) {
|
||||||
|
img.strip();
|
||||||
|
}
|
||||||
|
|
||||||
|
let buf: Buffer = Buffer.alloc(0);
|
||||||
|
img.write(outputFmt, (data) => {
|
||||||
|
buf = Buffer.from(data);
|
||||||
|
});
|
||||||
|
return buf;
|
||||||
|
},
|
||||||
|
);
|
||||||
|
entries.push({
|
||||||
|
name: `image${i}${outputExt}`,
|
||||||
|
data: frameBuffer,
|
||||||
|
});
|
||||||
|
} catch {
|
||||||
|
// No more frames
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
if (entries.length === 0) {
|
||||||
|
throw new Error("Failed to read ICO — no images found");
|
||||||
|
}
|
||||||
|
|
||||||
|
const zipPath = outputPath.replace(/\.[^.]+$/, ".zip");
|
||||||
|
const zipBuffer = await createZip(entries);
|
||||||
|
writeFileSync(zipPath, zipBuffer);
|
||||||
|
|
||||||
|
const stat = statSync(zipPath);
|
||||||
|
return {
|
||||||
|
outputPath: zipPath,
|
||||||
|
format: "zip",
|
||||||
|
sizeBytes: stat.size,
|
||||||
|
};
|
||||||
|
}
|
||||||
|
|
||||||
|
/** Convert ANI: parse with parseAni(), convert each frame, ZIP output. */
|
||||||
|
private async convertAni(
|
||||||
|
inputBytes: Uint8Array,
|
||||||
|
outputExt: string,
|
||||||
|
outputPath: string,
|
||||||
|
keepMetadata: boolean,
|
||||||
|
quality?: number,
|
||||||
|
): Promise<ConvertResult> {
|
||||||
|
let parsedAni;
|
||||||
|
try {
|
||||||
|
parsedAni = parseAni(inputBytes);
|
||||||
|
} catch (err) {
|
||||||
|
throw new Error(`Failed to parse ANI file: ${(err as Error).message}`);
|
||||||
|
}
|
||||||
|
|
||||||
|
const outputFmt = extToMagickFormat(outputExt.slice(1));
|
||||||
|
const frames = parsedAni.images.slice(0, MAX_FRAMES);
|
||||||
|
|
||||||
|
if (frames.length === 0) {
|
||||||
|
throw new Error("Failed to parse ANI — no frames found");
|
||||||
|
}
|
||||||
|
|
||||||
|
const entries: Array<{ name: string; data: Buffer }> = [];
|
||||||
|
|
||||||
|
for (let i = 0; i < frames.length; i++) {
|
||||||
|
const frameData = frames[i];
|
||||||
|
const frameBuffer = ImageMagick.read(
|
||||||
|
frameData,
|
||||||
|
new MagickReadSettings({ format: MagickFormat.Ico }),
|
||||||
|
(img) => {
|
||||||
|
if (outputExt === ".ico") {
|
||||||
|
this.clampForIco(img);
|
||||||
|
}
|
||||||
|
if (quality !== undefined) {
|
||||||
|
img.quality = quality;
|
||||||
|
}
|
||||||
|
if (!keepMetadata) {
|
||||||
|
img.strip();
|
||||||
|
}
|
||||||
|
|
||||||
|
let buf: Buffer = Buffer.alloc(0);
|
||||||
|
img.write(outputFmt, (data) => {
|
||||||
|
buf = Buffer.from(data);
|
||||||
|
});
|
||||||
|
return buf;
|
||||||
|
},
|
||||||
|
);
|
||||||
|
entries.push({
|
||||||
|
name: `image${i}${outputExt}`,
|
||||||
|
data: frameBuffer,
|
||||||
|
});
|
||||||
|
}
|
||||||
|
|
||||||
|
const zipPath = outputPath.replace(/\.[^.]+$/, ".zip");
|
||||||
|
const zipBuffer = await createZip(entries);
|
||||||
|
writeFileSync(zipPath, zipBuffer);
|
||||||
|
|
||||||
|
const stat = statSync(zipPath);
|
||||||
|
return {
|
||||||
|
outputPath: zipPath,
|
||||||
|
format: "zip",
|
||||||
|
sizeBytes: stat.size,
|
||||||
|
};
|
||||||
|
}
|
||||||
|
|
||||||
|
/** Convert animated GIF/WebP → GIF/WebP using readCollection. */
|
||||||
|
private async convertAnimated(
|
||||||
|
inputBytes: Uint8Array,
|
||||||
|
_from: string,
|
||||||
|
outputExt: string,
|
||||||
|
outputPath: string,
|
||||||
|
keepMetadata: boolean,
|
||||||
|
quality?: number,
|
||||||
|
): Promise<ConvertResult> {
|
||||||
|
const outputFmt = outputExt === ".gif" ? MagickFormat.Gif : MagickFormat.WebP;
|
||||||
|
|
||||||
|
const result = ImageMagick.readCollection(inputBytes, (imgs) => {
|
||||||
|
for (const img of imgs) {
|
||||||
|
if (quality !== undefined) {
|
||||||
|
img.quality = quality;
|
||||||
|
}
|
||||||
|
if (!keepMetadata) {
|
||||||
|
img.strip();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
let outputBuffer: Buffer = Buffer.alloc(0);
|
||||||
|
imgs.write(outputFmt, (data) => {
|
||||||
|
outputBuffer = Buffer.from(data);
|
||||||
|
});
|
||||||
|
return outputBuffer;
|
||||||
|
});
|
||||||
|
|
||||||
|
writeFileSync(outputPath, result);
|
||||||
|
|
||||||
|
const stat = statSync(outputPath);
|
||||||
|
return {
|
||||||
|
outputPath,
|
||||||
|
format: outputExt.slice(1),
|
||||||
|
sizeBytes: stat.size,
|
||||||
|
};
|
||||||
|
}
|
||||||
|
|
||||||
|
/** Clamp image dimensions to 256x256 for ICO output. */
|
||||||
|
private clampForIco(img: { width: number; height: number; resize: (w: number, h: number) => void }): void {
|
||||||
|
const max = 256;
|
||||||
|
const w = img.width;
|
||||||
|
const h = img.height;
|
||||||
|
if (w > max || h > max) {
|
||||||
|
const scale = max / Math.max(w, h);
|
||||||
|
const newW = Math.max(1, Math.round(w * scale));
|
||||||
|
const newH = Math.max(1, Math.round(h * scale));
|
||||||
|
img.resize(newW, newH);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
@ -0,0 +1,194 @@
|
||||||
|
import { execFile } from "node:child_process";
|
||||||
|
import { promisify } from "node:util";
|
||||||
|
import { stat, rm, mkdtemp } from "node:fs/promises";
|
||||||
|
import { tmpdir } from "node:os";
|
||||||
|
import path from "node:path";
|
||||||
|
import which from "which";
|
||||||
|
import { FormatInfo, type ConvertOptions, type ConvertResult, type NodeConverter } from "./types.js";
|
||||||
|
|
||||||
|
const execFileAsync = promisify(execFile);
|
||||||
|
|
||||||
|
/** Conversion timeout in milliseconds. */
|
||||||
|
const TIMEOUT_MS = 120_000;
|
||||||
|
|
||||||
|
/** Max concurrent pandoc processes. */
|
||||||
|
const MAX_CONCURRENT = 3;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Map file extension (without dot) to pandoc reader name.
|
||||||
|
*/
|
||||||
|
function formatToReader(ext: string): string {
|
||||||
|
switch (ext) {
|
||||||
|
case "md":
|
||||||
|
case "markdown":
|
||||||
|
return "markdown";
|
||||||
|
case "docx":
|
||||||
|
return "docx";
|
||||||
|
case "csv":
|
||||||
|
return "csv";
|
||||||
|
case "tsv":
|
||||||
|
return "tsv";
|
||||||
|
case "docbook":
|
||||||
|
return "docbook";
|
||||||
|
case "epub":
|
||||||
|
return "epub";
|
||||||
|
case "html":
|
||||||
|
return "html";
|
||||||
|
case "json":
|
||||||
|
return "json";
|
||||||
|
case "odt":
|
||||||
|
return "odt";
|
||||||
|
case "rtf":
|
||||||
|
return "rtf";
|
||||||
|
case "rst":
|
||||||
|
return "rst";
|
||||||
|
default:
|
||||||
|
throw new Error(`Unsupported pandoc input format: ${ext}`);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Map file extension (without dot) to pandoc writer name.
|
||||||
|
* Separate from reader because some writer names differ.
|
||||||
|
*/
|
||||||
|
function formatToWriter(ext: string): string {
|
||||||
|
switch (ext) {
|
||||||
|
case "md":
|
||||||
|
case "markdown":
|
||||||
|
return "markdown";
|
||||||
|
case "docx":
|
||||||
|
return "docx";
|
||||||
|
case "csv":
|
||||||
|
return "csv";
|
||||||
|
case "tsv":
|
||||||
|
return "tsv";
|
||||||
|
case "docbook":
|
||||||
|
return "docbook5";
|
||||||
|
case "epub":
|
||||||
|
return "epub3";
|
||||||
|
case "html":
|
||||||
|
return "html5";
|
||||||
|
case "json":
|
||||||
|
return "json";
|
||||||
|
case "odt":
|
||||||
|
return "odt";
|
||||||
|
case "rst":
|
||||||
|
return "rst";
|
||||||
|
default:
|
||||||
|
throw new Error(`Unsupported pandoc output format: ${ext}`);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Normalize format aliases to canonical extension names.
|
||||||
|
*/
|
||||||
|
function normalizeFormat(ext: string): string {
|
||||||
|
if (ext === "markdown") return "md";
|
||||||
|
return ext;
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Pandoc-based document converter.
|
||||||
|
*
|
||||||
|
* Uses system `pandoc` via `child_process.execFile`.
|
||||||
|
* Gracefully unavailable if pandoc is not installed.
|
||||||
|
*/
|
||||||
|
export class PandocNodeConverter implements NodeConverter {
|
||||||
|
readonly name = "pandoc";
|
||||||
|
|
||||||
|
readonly supportedFormats: FormatInfo[] = [
|
||||||
|
new FormatInfo("docx", true, true),
|
||||||
|
// .doc is NOT supported — pandoc docx reader can't handle binary .doc
|
||||||
|
new FormatInfo("md", true, true),
|
||||||
|
new FormatInfo("html", true, true),
|
||||||
|
new FormatInfo("rtf", true, false), // read only — RTF output is blocked
|
||||||
|
new FormatInfo("csv", true, true),
|
||||||
|
new FormatInfo("tsv", true, true),
|
||||||
|
new FormatInfo("json", true, true), // pandoc-converted JSON only
|
||||||
|
new FormatInfo("rst", true, true),
|
||||||
|
new FormatInfo("epub", true, true),
|
||||||
|
new FormatInfo("odt", true, true),
|
||||||
|
new FormatInfo("docbook", true, true),
|
||||||
|
];
|
||||||
|
|
||||||
|
private pandocPath: string | null = null;
|
||||||
|
private available: boolean | null = null;
|
||||||
|
private activeCount = 0;
|
||||||
|
|
||||||
|
/** Detect if pandoc is installed on the system. */
|
||||||
|
async isAvailable(): Promise<boolean> {
|
||||||
|
if (this.available !== null) return this.available;
|
||||||
|
|
||||||
|
try {
|
||||||
|
this.pandocPath = await which("pandoc");
|
||||||
|
this.available = true;
|
||||||
|
} catch {
|
||||||
|
this.available = false;
|
||||||
|
console.error("[pandoc] pandoc not found on system PATH");
|
||||||
|
}
|
||||||
|
|
||||||
|
return this.available;
|
||||||
|
}
|
||||||
|
|
||||||
|
/** Convert a document file using pandoc. */
|
||||||
|
async convert(options: ConvertOptions): Promise<ConvertResult> {
|
||||||
|
if (!(await this.isAvailable()) || !this.pandocPath) {
|
||||||
|
throw new Error("pandoc is not available on this system");
|
||||||
|
}
|
||||||
|
|
||||||
|
if (this.activeCount >= MAX_CONCURRENT) {
|
||||||
|
throw new Error(
|
||||||
|
`Too many concurrent pandoc conversions (max ${MAX_CONCURRENT}). Try again later.`,
|
||||||
|
);
|
||||||
|
}
|
||||||
|
|
||||||
|
const inputExt = path.extname(options.inputPath).slice(1).toLowerCase();
|
||||||
|
const outputExt = normalizeFormat(options.outputFormat.toLowerCase());
|
||||||
|
|
||||||
|
// Block RTF output
|
||||||
|
if (outputExt === "rtf") {
|
||||||
|
throw new Error("Converting to RTF is not supported.");
|
||||||
|
}
|
||||||
|
|
||||||
|
const reader = formatToReader(normalizeFormat(inputExt));
|
||||||
|
const writer = formatToWriter(outputExt);
|
||||||
|
|
||||||
|
// Create temp dir for --extract-media (cleaned in finally)
|
||||||
|
const mediaTmpDir = await mkdtemp(path.join(tmpdir(), "pandoc-media-"));
|
||||||
|
|
||||||
|
this.activeCount++;
|
||||||
|
try {
|
||||||
|
const args: string[] = [
|
||||||
|
"--sandbox",
|
||||||
|
"-f", reader,
|
||||||
|
"-t", writer,
|
||||||
|
"--extract-media", mediaTmpDir,
|
||||||
|
"-o", options.outputPath,
|
||||||
|
"--", options.inputPath,
|
||||||
|
];
|
||||||
|
|
||||||
|
await execFileAsync(this.pandocPath, args, {
|
||||||
|
timeout: TIMEOUT_MS,
|
||||||
|
maxBuffer: 50 * 1024 * 1024, // 50 MB stdout/stderr buffer
|
||||||
|
windowsHide: true,
|
||||||
|
});
|
||||||
|
|
||||||
|
const outputStats = await stat(options.outputPath);
|
||||||
|
|
||||||
|
return {
|
||||||
|
outputPath: options.outputPath,
|
||||||
|
format: outputExt,
|
||||||
|
sizeBytes: outputStats.size,
|
||||||
|
};
|
||||||
|
} finally {
|
||||||
|
this.activeCount--;
|
||||||
|
// Clean up extracted media temp dir
|
||||||
|
try {
|
||||||
|
await rm(mediaTmpDir, { recursive: true, force: true });
|
||||||
|
} catch {
|
||||||
|
// Best-effort cleanup — don't throw from finally
|
||||||
|
console.error(`[pandoc] Failed to clean up temp dir: ${mediaTmpDir}`);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
@ -0,0 +1,176 @@
|
||||||
|
import type { FormatInfo, NodeConverter } from "./types.js";
|
||||||
|
import { MIME_TYPES } from "./types.js";
|
||||||
|
import { MagickNodeConverter } from "./magick.js";
|
||||||
|
import { FFmpegNodeConverter } from "./ffmpeg.js";
|
||||||
|
import { PandocNodeConverter } from "./pandoc.js";
|
||||||
|
|
||||||
|
/** All converter instances, in priority order. */
|
||||||
|
const converters: NodeConverter[] = [
|
||||||
|
new MagickNodeConverter(),
|
||||||
|
new FFmpegNodeConverter(),
|
||||||
|
new PandocNodeConverter(),
|
||||||
|
];
|
||||||
|
|
||||||
|
/** Category definitions. */
|
||||||
|
export type Category = "image" | "audio" | "doc";
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Build the format allowlist (undotted format names) from all converters.
|
||||||
|
*/
|
||||||
|
export function buildFormatAllowlist(): Set<string> {
|
||||||
|
const allowlist = new Set<string>();
|
||||||
|
for (const converter of converters) {
|
||||||
|
for (const fmt of converter.supportedFormats) {
|
||||||
|
// Store undotted names
|
||||||
|
const name = fmt.name.startsWith(".") ? fmt.name.slice(1) : fmt.name;
|
||||||
|
allowlist.add(name);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return allowlist;
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Find the appropriate converter for a given input and output format.
|
||||||
|
* Converter priority: magick -> ffmpeg -> pandoc (array order).
|
||||||
|
*/
|
||||||
|
export function getConverter(
|
||||||
|
inputFormat: string,
|
||||||
|
outputFormat: string,
|
||||||
|
): NodeConverter | null {
|
||||||
|
const inputDotted = inputFormat.startsWith(".") ? inputFormat : `.${inputFormat}`;
|
||||||
|
const outputDotted = outputFormat.startsWith(".") ? outputFormat : `.${outputFormat}`;
|
||||||
|
|
||||||
|
for (const converter of converters) {
|
||||||
|
const supportsInput = converter.supportedFormats.some(
|
||||||
|
(f) => f.name === inputDotted && f.fromSupported,
|
||||||
|
);
|
||||||
|
const supportsOutput = converter.supportedFormats.some(
|
||||||
|
(f) => f.name === outputDotted && f.toSupported,
|
||||||
|
);
|
||||||
|
if (supportsInput && supportsOutput) {
|
||||||
|
return converter;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// Fallback: find any converter that handles the output format
|
||||||
|
// (e.g., video input with audio output — ffmpeg handles video input)
|
||||||
|
for (const converter of converters) {
|
||||||
|
const supportsInput = converter.supportedFormats.some(
|
||||||
|
(f) => f.name === inputDotted && f.fromSupported,
|
||||||
|
);
|
||||||
|
if (supportsInput) {
|
||||||
|
// Check if any other converter can handle the output
|
||||||
|
for (const outConverter of converters) {
|
||||||
|
const supportsOutput = outConverter.supportedFormats.some(
|
||||||
|
(f) => f.name === outputDotted && f.toSupported,
|
||||||
|
);
|
||||||
|
if (supportsOutput && converter === outConverter) {
|
||||||
|
return converter;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
return null;
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Get format info by extension (undotted).
|
||||||
|
*/
|
||||||
|
export function getFormatInfo(format: string): {
|
||||||
|
name: string;
|
||||||
|
fromSupported: boolean;
|
||||||
|
toSupported: boolean;
|
||||||
|
category: Category | null;
|
||||||
|
mimeType: string | null;
|
||||||
|
converter: string | null;
|
||||||
|
} | null {
|
||||||
|
const dotted = format.startsWith(".") ? format : `.${format}`;
|
||||||
|
const undotted = format.startsWith(".") ? format.slice(1) : format;
|
||||||
|
|
||||||
|
for (const converter of converters) {
|
||||||
|
const fmt = converter.supportedFormats.find((f) => f.name === dotted);
|
||||||
|
if (fmt) {
|
||||||
|
return {
|
||||||
|
name: undotted,
|
||||||
|
fromSupported: fmt.fromSupported,
|
||||||
|
toSupported: fmt.toSupported,
|
||||||
|
category: getCategory(converter.name),
|
||||||
|
mimeType: MIME_TYPES[undotted] ?? null,
|
||||||
|
converter: converter.name,
|
||||||
|
};
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
return null;
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* List formats, optionally filtered by category.
|
||||||
|
*/
|
||||||
|
export function listFormats(category?: Category): {
|
||||||
|
name: string;
|
||||||
|
fromSupported: boolean;
|
||||||
|
toSupported: boolean;
|
||||||
|
category: Category;
|
||||||
|
mimeType: string | null;
|
||||||
|
}[] {
|
||||||
|
const results: {
|
||||||
|
name: string;
|
||||||
|
fromSupported: boolean;
|
||||||
|
toSupported: boolean;
|
||||||
|
category: Category;
|
||||||
|
mimeType: string | null;
|
||||||
|
}[] = [];
|
||||||
|
|
||||||
|
const seen = new Set<string>();
|
||||||
|
|
||||||
|
for (const converter of converters) {
|
||||||
|
const cat = getCategory(converter.name);
|
||||||
|
if (category && cat !== category) continue;
|
||||||
|
|
||||||
|
for (const fmt of converter.supportedFormats) {
|
||||||
|
// Skip video formats (input-only, not shown in list_formats)
|
||||||
|
if (!fmt.isNative && !fmt.toSupported) continue;
|
||||||
|
|
||||||
|
const undotted = fmt.name.startsWith(".") ? fmt.name.slice(1) : fmt.name;
|
||||||
|
if (seen.has(undotted)) continue;
|
||||||
|
seen.add(undotted);
|
||||||
|
|
||||||
|
results.push({
|
||||||
|
name: undotted,
|
||||||
|
fromSupported: fmt.fromSupported,
|
||||||
|
toSupported: fmt.toSupported,
|
||||||
|
category: cat,
|
||||||
|
mimeType: MIME_TYPES[undotted] ?? null,
|
||||||
|
});
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
return results.sort((a, b) => a.name.localeCompare(b.name));
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Check which converters are available on this system.
|
||||||
|
*/
|
||||||
|
export async function checkAvailability(): Promise<Record<string, boolean>> {
|
||||||
|
const results: Record<string, boolean> = {};
|
||||||
|
for (const converter of converters) {
|
||||||
|
results[converter.name] = await converter.isAvailable();
|
||||||
|
}
|
||||||
|
return results;
|
||||||
|
}
|
||||||
|
|
||||||
|
/** Map converter name to category. */
|
||||||
|
function getCategory(converterName: string): Category {
|
||||||
|
switch (converterName) {
|
||||||
|
case "imagemagick":
|
||||||
|
return "image";
|
||||||
|
case "ffmpeg":
|
||||||
|
return "audio";
|
||||||
|
case "pandoc":
|
||||||
|
return "doc";
|
||||||
|
default:
|
||||||
|
return "image";
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
@ -0,0 +1,139 @@
|
||||||
|
/**
|
||||||
|
* Format metadata for a single file format.
|
||||||
|
* Adapted from VERT's FormatInfo class (converter.svelte.ts).
|
||||||
|
*/
|
||||||
|
export class FormatInfo {
|
||||||
|
public name: string;
|
||||||
|
|
||||||
|
constructor(
|
||||||
|
name: string,
|
||||||
|
public fromSupported = true,
|
||||||
|
public toSupported = true,
|
||||||
|
public isNative = true,
|
||||||
|
) {
|
||||||
|
this.name = name;
|
||||||
|
if (!this.name.startsWith(".")) {
|
||||||
|
this.name = `.${this.name}`;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (!this.fromSupported && !this.toSupported) {
|
||||||
|
throw new Error("Format must support at least one direction");
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/** Options passed to a converter's convert method. */
|
||||||
|
export interface ConvertOptions {
|
||||||
|
inputPath: string;
|
||||||
|
outputPath: string;
|
||||||
|
outputFormat: string;
|
||||||
|
quality?: number;
|
||||||
|
keepMetadata?: boolean;
|
||||||
|
audioBitrate?: string;
|
||||||
|
sampleRate?: number;
|
||||||
|
}
|
||||||
|
|
||||||
|
/** Result returned from a successful conversion. */
|
||||||
|
export interface ConvertResult {
|
||||||
|
outputPath: string;
|
||||||
|
format: string;
|
||||||
|
sizeBytes: number;
|
||||||
|
}
|
||||||
|
|
||||||
|
/** Base interface for all converters. */
|
||||||
|
export interface NodeConverter {
|
||||||
|
/** Converter name (e.g. "imagemagick", "ffmpeg", "pandoc"). */
|
||||||
|
readonly name: string;
|
||||||
|
/** Supported formats. */
|
||||||
|
readonly supportedFormats: FormatInfo[];
|
||||||
|
/** Whether this converter is available on the system. */
|
||||||
|
isAvailable(): Promise<boolean>;
|
||||||
|
/** Convert a file. */
|
||||||
|
convert(options: ConvertOptions): Promise<ConvertResult>;
|
||||||
|
}
|
||||||
|
|
||||||
|
/** Common MIME types by extension (undotted). */
|
||||||
|
export const MIME_TYPES: Record<string, string> = {
|
||||||
|
// Common image formats
|
||||||
|
png: "image/png",
|
||||||
|
jpg: "image/jpeg",
|
||||||
|
jpeg: "image/jpeg",
|
||||||
|
jpe: "image/jpeg",
|
||||||
|
jfif: "image/jpeg",
|
||||||
|
gif: "image/gif",
|
||||||
|
webp: "image/webp",
|
||||||
|
svg: "image/svg+xml",
|
||||||
|
svgz: "image/svg+xml",
|
||||||
|
bmp: "image/bmp",
|
||||||
|
ico: "image/x-icon",
|
||||||
|
cur: "image/x-icon",
|
||||||
|
tiff: "image/tiff",
|
||||||
|
tif: "image/tiff",
|
||||||
|
avif: "image/avif",
|
||||||
|
heic: "image/heic",
|
||||||
|
heif: "image/heif",
|
||||||
|
jxl: "image/jxl",
|
||||||
|
psd: "image/vnd.adobe.photoshop",
|
||||||
|
hdr: "image/vnd.radiance",
|
||||||
|
exr: "image/x-exr",
|
||||||
|
dds: "image/vnd.ms-dds",
|
||||||
|
pbm: "image/x-portable-bitmap",
|
||||||
|
pgm: "image/x-portable-graymap",
|
||||||
|
ppm: "image/x-portable-pixmap",
|
||||||
|
pnm: "image/x-portable-anymap",
|
||||||
|
pam: "image/x-portable-arbitrarymap",
|
||||||
|
pcx: "image/x-pcx",
|
||||||
|
tga: "image/x-tga",
|
||||||
|
qoi: "image/x-qoi",
|
||||||
|
ani: "application/x-navi-animation",
|
||||||
|
icns: "image/x-icns",
|
||||||
|
|
||||||
|
// Audio formats
|
||||||
|
mp3: "audio/mpeg",
|
||||||
|
wav: "audio/wav",
|
||||||
|
flac: "audio/flac",
|
||||||
|
ogg: "audio/ogg",
|
||||||
|
oga: "audio/ogg",
|
||||||
|
opus: "audio/opus",
|
||||||
|
aac: "audio/aac",
|
||||||
|
m4a: "audio/mp4",
|
||||||
|
m4b: "audio/mp4",
|
||||||
|
wma: "audio/x-ms-wma",
|
||||||
|
amr: "audio/amr",
|
||||||
|
ac3: "audio/ac3",
|
||||||
|
aiff: "audio/aiff",
|
||||||
|
aif: "audio/aiff",
|
||||||
|
aifc: "audio/aiff",
|
||||||
|
au: "audio/basic",
|
||||||
|
mp2: "audio/mpeg",
|
||||||
|
caf: "audio/x-caf",
|
||||||
|
voc: "audio/x-voc",
|
||||||
|
weba: "audio/webm",
|
||||||
|
|
||||||
|
// Document formats
|
||||||
|
docx: "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
|
||||||
|
md: "text/markdown",
|
||||||
|
html: "text/html",
|
||||||
|
rtf: "application/rtf",
|
||||||
|
csv: "text/csv",
|
||||||
|
tsv: "text/tab-separated-values",
|
||||||
|
json: "application/json",
|
||||||
|
rst: "text/x-rst",
|
||||||
|
epub: "application/epub+zip",
|
||||||
|
odt: "application/vnd.oasis.opendocument.text",
|
||||||
|
docbook: "application/docbook+xml",
|
||||||
|
|
||||||
|
// Video formats (input only for audio extraction)
|
||||||
|
mp4: "video/mp4",
|
||||||
|
mkv: "video/x-matroska",
|
||||||
|
avi: "video/x-msvideo",
|
||||||
|
mov: "video/quicktime",
|
||||||
|
webm: "video/webm",
|
||||||
|
wmv: "video/x-ms-wmv",
|
||||||
|
flv: "video/x-flv",
|
||||||
|
mpg: "video/mpeg",
|
||||||
|
mpeg: "video/mpeg",
|
||||||
|
m4v: "video/mp4",
|
||||||
|
"3gp": "video/3gpp",
|
||||||
|
ogv: "video/ogg",
|
||||||
|
};
|
||||||
|
|
@ -0,0 +1,223 @@
|
||||||
|
#!/usr/bin/env node
|
||||||
|
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
|
||||||
|
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
|
||||||
|
import { z } from "zod";
|
||||||
|
import path from "node:path";
|
||||||
|
|
||||||
|
import {
|
||||||
|
validateInputPath,
|
||||||
|
validateOutputPath,
|
||||||
|
validateFormat,
|
||||||
|
validateAudioBitrate,
|
||||||
|
validateSampleRate,
|
||||||
|
} from "./security.js";
|
||||||
|
import {
|
||||||
|
buildFormatAllowlist,
|
||||||
|
getConverter,
|
||||||
|
getFormatInfo,
|
||||||
|
listFormats,
|
||||||
|
checkAvailability,
|
||||||
|
} from "./converters/registry.js";
|
||||||
|
|
||||||
|
// Build format allowlist once at startup
|
||||||
|
const FORMAT_ALLOWLIST = buildFormatAllowlist();
|
||||||
|
|
||||||
|
const server = new McpServer({
|
||||||
|
name: "vert",
|
||||||
|
version: "0.1.0",
|
||||||
|
});
|
||||||
|
|
||||||
|
// ── convert_file ──────────────────────────────────────────────────────────
|
||||||
|
|
||||||
|
server.tool(
|
||||||
|
"convert_file",
|
||||||
|
"Convert a file between formats. Supports 140+ image formats (via ImageMagick WASM), 28+ audio formats (via system ffmpeg), and 11 document formats (via system pandoc). Video input is supported for audio extraction (e.g., MP4 to MP3).",
|
||||||
|
{
|
||||||
|
input_path: z.string().describe("Absolute path to the input file"),
|
||||||
|
output_format: z.string().describe("Target format extension (e.g. \"webp\", \"mp3\", \"docx\")"),
|
||||||
|
output_path: z.string().optional().describe("Output file path. Defaults to input directory with new extension"),
|
||||||
|
quality: z.number().min(1).max(100).optional().describe("Compression quality for lossy image formats (1-100)"),
|
||||||
|
keep_metadata: z.boolean().optional().describe("Preserve file metadata. Defaults to true"),
|
||||||
|
audio_bitrate: z.string().optional().describe("Audio bitrate (e.g. \"128k\", \"320k\")"),
|
||||||
|
sample_rate: z.number().optional().describe("Audio sample rate in Hz (e.g. 44100, 48000)"),
|
||||||
|
},
|
||||||
|
async (params) => {
|
||||||
|
try {
|
||||||
|
// Validate input path
|
||||||
|
const resolvedInput = await validateInputPath(params.input_path);
|
||||||
|
|
||||||
|
// Validate output format
|
||||||
|
const outputFormat = validateFormat(params.output_format, FORMAT_ALLOWLIST);
|
||||||
|
|
||||||
|
// Validate input format
|
||||||
|
const inputExt = path.extname(resolvedInput).slice(1).toLowerCase();
|
||||||
|
if (!inputExt) {
|
||||||
|
return {
|
||||||
|
content: [{ type: "text", text: "Input file has no extension. Cannot determine format." }],
|
||||||
|
isError: true,
|
||||||
|
};
|
||||||
|
}
|
||||||
|
// Input format validation: check it's a known format (but don't block unsupported WASM
|
||||||
|
// formats for input — they may be handled by ffmpeg/pandoc)
|
||||||
|
if (!FORMAT_ALLOWLIST.has(inputExt)) {
|
||||||
|
return {
|
||||||
|
content: [{ type: "text", text: `Unknown input format: ${inputExt}` }],
|
||||||
|
isError: true,
|
||||||
|
};
|
||||||
|
}
|
||||||
|
|
||||||
|
// Determine output path
|
||||||
|
let outputPath: string;
|
||||||
|
if (params.output_path) {
|
||||||
|
outputPath = params.output_path;
|
||||||
|
} else {
|
||||||
|
const dir = path.dirname(resolvedInput);
|
||||||
|
const base = path.basename(resolvedInput, path.extname(resolvedInput));
|
||||||
|
outputPath = path.join(dir, `${base}.${outputFormat}`);
|
||||||
|
}
|
||||||
|
|
||||||
|
// Validate output path
|
||||||
|
const resolvedOutput = await validateOutputPath(outputPath, resolvedInput);
|
||||||
|
|
||||||
|
// Validate optional params
|
||||||
|
if (params.audio_bitrate !== undefined) {
|
||||||
|
validateAudioBitrate(params.audio_bitrate);
|
||||||
|
}
|
||||||
|
if (params.sample_rate !== undefined) {
|
||||||
|
validateSampleRate(params.sample_rate);
|
||||||
|
}
|
||||||
|
|
||||||
|
// Find a converter
|
||||||
|
const converter = getConverter(inputExt, outputFormat);
|
||||||
|
if (!converter) {
|
||||||
|
return {
|
||||||
|
content: [{ type: "text", text: `No converter available for ${inputExt} → ${outputFormat}` }],
|
||||||
|
isError: true,
|
||||||
|
};
|
||||||
|
}
|
||||||
|
|
||||||
|
// Check if the converter is available on this system
|
||||||
|
const available = await converter.isAvailable();
|
||||||
|
if (!available) {
|
||||||
|
return {
|
||||||
|
content: [{
|
||||||
|
type: "text",
|
||||||
|
text: `Converter "${converter.name}" is not available on this system. ${converter.name === "ffmpeg" ? "Install ffmpeg to convert audio files." : converter.name === "pandoc" ? "Install pandoc to convert documents." : ""}`,
|
||||||
|
}],
|
||||||
|
isError: true,
|
||||||
|
};
|
||||||
|
}
|
||||||
|
|
||||||
|
// Run conversion
|
||||||
|
const result = await converter.convert({
|
||||||
|
inputPath: resolvedInput,
|
||||||
|
outputPath: resolvedOutput,
|
||||||
|
outputFormat,
|
||||||
|
quality: params.quality,
|
||||||
|
keepMetadata: params.keep_metadata,
|
||||||
|
audioBitrate: params.audio_bitrate,
|
||||||
|
sampleRate: params.sample_rate,
|
||||||
|
});
|
||||||
|
|
||||||
|
return {
|
||||||
|
content: [{
|
||||||
|
type: "text",
|
||||||
|
text: JSON.stringify({
|
||||||
|
output_path: result.outputPath,
|
||||||
|
format: result.format,
|
||||||
|
size_bytes: result.sizeBytes,
|
||||||
|
}, null, 2),
|
||||||
|
}],
|
||||||
|
};
|
||||||
|
} catch (err) {
|
||||||
|
return {
|
||||||
|
content: [{ type: "text", text: `Conversion failed: ${(err as Error).message}` }],
|
||||||
|
isError: true,
|
||||||
|
};
|
||||||
|
}
|
||||||
|
},
|
||||||
|
);
|
||||||
|
|
||||||
|
// ── list_formats ──────────────────────────────────────────────────────────
|
||||||
|
|
||||||
|
server.tool(
|
||||||
|
"list_formats",
|
||||||
|
"List supported file formats, optionally filtered by category. Returns format name, supported directions, category, and MIME type.",
|
||||||
|
{
|
||||||
|
category: z.enum(["image", "audio", "doc"]).optional().describe(
|
||||||
|
"Filter by category: \"image\", \"audio\", or \"doc\""
|
||||||
|
),
|
||||||
|
},
|
||||||
|
async (params) => {
|
||||||
|
try {
|
||||||
|
const formats = listFormats(params.category);
|
||||||
|
const availability = await checkAvailability();
|
||||||
|
|
||||||
|
return {
|
||||||
|
content: [{
|
||||||
|
type: "text",
|
||||||
|
text: JSON.stringify({
|
||||||
|
converters: availability,
|
||||||
|
formats,
|
||||||
|
total: formats.length,
|
||||||
|
}, null, 2),
|
||||||
|
}],
|
||||||
|
};
|
||||||
|
} catch (err) {
|
||||||
|
return {
|
||||||
|
content: [{ type: "text", text: `Failed to list formats: ${(err as Error).message}` }],
|
||||||
|
isError: true,
|
||||||
|
};
|
||||||
|
}
|
||||||
|
},
|
||||||
|
);
|
||||||
|
|
||||||
|
// ── get_format_info ───────────────────────────────────────────────────────
|
||||||
|
|
||||||
|
server.tool(
|
||||||
|
"get_format_info",
|
||||||
|
"Get detailed information about a specific file format, including supported conversion directions, category, MIME type, and which converter handles it.",
|
||||||
|
{
|
||||||
|
format: z.string().describe("File extension without dot (e.g. \"png\", \"mp3\", \"docx\")"),
|
||||||
|
},
|
||||||
|
async (params) => {
|
||||||
|
try {
|
||||||
|
const normalized = params.format.startsWith(".")
|
||||||
|
? params.format.slice(1).toLowerCase()
|
||||||
|
: params.format.toLowerCase();
|
||||||
|
|
||||||
|
const info = getFormatInfo(normalized);
|
||||||
|
if (!info) {
|
||||||
|
return {
|
||||||
|
content: [{ type: "text", text: `Unknown format: ${normalized}` }],
|
||||||
|
isError: true,
|
||||||
|
};
|
||||||
|
}
|
||||||
|
|
||||||
|
return {
|
||||||
|
content: [{
|
||||||
|
type: "text",
|
||||||
|
text: JSON.stringify(info, null, 2),
|
||||||
|
}],
|
||||||
|
};
|
||||||
|
} catch (err) {
|
||||||
|
return {
|
||||||
|
content: [{ type: "text", text: `Failed to get format info: ${(err as Error).message}` }],
|
||||||
|
isError: true,
|
||||||
|
};
|
||||||
|
}
|
||||||
|
},
|
||||||
|
);
|
||||||
|
|
||||||
|
// ── Start server ──────────────────────────────────────────────────────────
|
||||||
|
|
||||||
|
async function main(): Promise<void> {
|
||||||
|
const transport = new StdioServerTransport();
|
||||||
|
await server.connect(transport);
|
||||||
|
console.error("[vert-mcp] Server started on stdio");
|
||||||
|
}
|
||||||
|
|
||||||
|
main().catch((err) => {
|
||||||
|
console.error("[vert-mcp] Fatal error:", err);
|
||||||
|
process.exit(1);
|
||||||
|
});
|
||||||
|
|
@ -0,0 +1,170 @@
|
||||||
|
import { stat, realpath, access, constants } from "node:fs/promises";
|
||||||
|
import path from "node:path";
|
||||||
|
|
||||||
|
/** Dangerous ImageMagick format names that could execute code or fetch URLs. */
|
||||||
|
const DANGEROUS_FORMATS = new Set([
|
||||||
|
"mvg", "msl", "ephemeral", "url", "http", "https",
|
||||||
|
"ftp", "text", "label", "caption",
|
||||||
|
]);
|
||||||
|
|
||||||
|
/** Formats that lack WASM delegates and will fail silently or produce garbage. */
|
||||||
|
const UNSUPPORTED_WASM_FORMATS = new Set([
|
||||||
|
"pdf", "pdfa", "eps", "ps", "ps1", "ps2", "ps3",
|
||||||
|
// SVG INPUT is unsupported (needs librsvg), but OUTPUT works via IM's internal writer.
|
||||||
|
// Blocked at the converter level (fromSupported=false) instead of here.
|
||||||
|
// RAW camera formats (need libraw)
|
||||||
|
"cr2", "nef", "arw", "dng", "cr3", "orf", "rw2", "pef",
|
||||||
|
"srf", "sr2", "raf", "mrw", "erf", "kdc", "dcr", "rwl",
|
||||||
|
"iiq", "3fr", "crw", "mef", "nrw", "srw", "mos", "raw",
|
||||||
|
// Old binary .doc (pandoc docx reader can't handle it)
|
||||||
|
"doc",
|
||||||
|
]);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Validate and resolve an input file path.
|
||||||
|
* Returns the resolved absolute path.
|
||||||
|
*/
|
||||||
|
export async function validateInputPath(inputPath: string): Promise<string> {
|
||||||
|
assertNoPathInjection(inputPath);
|
||||||
|
|
||||||
|
const resolved = path.resolve(inputPath);
|
||||||
|
const real = await realpath(resolved);
|
||||||
|
|
||||||
|
const stats = await stat(real);
|
||||||
|
if (!stats.isFile()) {
|
||||||
|
throw new Error(`Input path is not a regular file: ${inputPath}`);
|
||||||
|
}
|
||||||
|
|
||||||
|
// 100 MB limit
|
||||||
|
const MAX_SIZE = 100 * 1024 * 1024;
|
||||||
|
if (stats.size > MAX_SIZE) {
|
||||||
|
throw new Error(
|
||||||
|
`Input file exceeds 100 MB limit: ${(stats.size / 1024 / 1024).toFixed(1)} MB`,
|
||||||
|
);
|
||||||
|
}
|
||||||
|
|
||||||
|
return real;
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Validate and resolve an output file path.
|
||||||
|
* Returns the resolved absolute path, ensuring it won't overwrite existing files.
|
||||||
|
*/
|
||||||
|
export async function validateOutputPath(
|
||||||
|
outputPath: string,
|
||||||
|
inputPath: string,
|
||||||
|
): Promise<string> {
|
||||||
|
assertNoPathInjection(outputPath);
|
||||||
|
|
||||||
|
const resolved = path.resolve(outputPath);
|
||||||
|
|
||||||
|
// Verify output !== input after resolution
|
||||||
|
if (resolved === inputPath) {
|
||||||
|
throw new Error("Output path cannot be the same as input path");
|
||||||
|
}
|
||||||
|
|
||||||
|
// Verify parent directory exists and is writable
|
||||||
|
const parentDir = path.dirname(resolved);
|
||||||
|
try {
|
||||||
|
await access(parentDir, constants.W_OK);
|
||||||
|
} catch {
|
||||||
|
throw new Error(`Output directory is not writable: ${parentDir}`);
|
||||||
|
}
|
||||||
|
|
||||||
|
// Don't overwrite existing files — auto-suffix
|
||||||
|
return await findAvailablePath(resolved);
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Validate a format string against the allowlist.
|
||||||
|
* Returns the normalized undotted format string.
|
||||||
|
*/
|
||||||
|
export function validateFormat(format: string, allowlist: Set<string>): string {
|
||||||
|
// Strip leading dot if present
|
||||||
|
const normalized = format.startsWith(".") ? format.slice(1) : format;
|
||||||
|
const lower = normalized.toLowerCase();
|
||||||
|
|
||||||
|
if (DANGEROUS_FORMATS.has(lower)) {
|
||||||
|
throw new Error(`Blocked dangerous format: ${lower}`);
|
||||||
|
}
|
||||||
|
|
||||||
|
if (UNSUPPORTED_WASM_FORMATS.has(lower)) {
|
||||||
|
throw new Error(
|
||||||
|
`Unsupported format: ${lower} (requires system libraries not available in WASM)`,
|
||||||
|
);
|
||||||
|
}
|
||||||
|
|
||||||
|
if (!allowlist.has(lower)) {
|
||||||
|
throw new Error(`Unknown format: ${lower}`);
|
||||||
|
}
|
||||||
|
|
||||||
|
return lower;
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Validate audio bitrate parameter.
|
||||||
|
*/
|
||||||
|
export function validateAudioBitrate(bitrate: string): string {
|
||||||
|
if (!/^\d+k$/.test(bitrate)) {
|
||||||
|
throw new Error(
|
||||||
|
`Invalid audio bitrate: ${bitrate}. Expected format like "128k" or "320k".`,
|
||||||
|
);
|
||||||
|
}
|
||||||
|
return bitrate;
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Validate sample rate parameter.
|
||||||
|
*/
|
||||||
|
export function validateSampleRate(rate: number): number {
|
||||||
|
if (!Number.isInteger(rate) || rate < 8000 || rate > 192000) {
|
||||||
|
throw new Error(
|
||||||
|
`Invalid sample rate: ${rate}. Must be an integer between 8000 and 192000.`,
|
||||||
|
);
|
||||||
|
}
|
||||||
|
return rate;
|
||||||
|
}
|
||||||
|
|
||||||
|
/** Check for path injection attempts. */
|
||||||
|
function assertNoPathInjection(filePath: string): void {
|
||||||
|
// Block null bytes
|
||||||
|
if (filePath.includes("\0")) {
|
||||||
|
throw new Error("Path contains null bytes");
|
||||||
|
}
|
||||||
|
|
||||||
|
// Block Windows UNC paths
|
||||||
|
if (filePath.startsWith("\\\\")) {
|
||||||
|
throw new Error("UNC paths are not allowed");
|
||||||
|
}
|
||||||
|
|
||||||
|
// Block NTFS alternate data streams (colons after drive prefix)
|
||||||
|
// Allow the drive letter colon (e.g., C:\) but block file.txt:stream
|
||||||
|
const withoutDrive = filePath.replace(/^[A-Za-z]:/, "");
|
||||||
|
if (withoutDrive.includes(":")) {
|
||||||
|
throw new Error("NTFS alternate data streams are not allowed");
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/** Find an available path by appending _1, _2, etc. if the file exists. */
|
||||||
|
async function findAvailablePath(filePath: string): Promise<string> {
|
||||||
|
try {
|
||||||
|
await stat(filePath);
|
||||||
|
} catch {
|
||||||
|
// File doesn't exist, path is available
|
||||||
|
return filePath;
|
||||||
|
}
|
||||||
|
|
||||||
|
const ext = path.extname(filePath);
|
||||||
|
const base = filePath.slice(0, -ext.length || undefined);
|
||||||
|
|
||||||
|
for (let i = 1; i <= 1000; i++) {
|
||||||
|
const candidate = `${base}_${i}${ext}`;
|
||||||
|
try {
|
||||||
|
await stat(candidate);
|
||||||
|
} catch {
|
||||||
|
return candidate;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
throw new Error("Could not find available output path after 1000 attempts");
|
||||||
|
}
|
||||||
|
|
@ -0,0 +1,151 @@
|
||||||
|
// THIS CODE IS FROM https://github.com/captbaritone/webamp/blob/15b0312cb794973a0e615d894df942452e920c36/packages/ani-cursor/src/parser.ts
|
||||||
|
// LICENSED UNDER MIT. (c) Jordan Eldredge and Webamp contributors
|
||||||
|
|
||||||
|
// this code is ripped from their project because i didn't want to
|
||||||
|
// re-invent the wheel, BUT the library they provide (ani-cursor)
|
||||||
|
// doesn't expose the internals.
|
||||||
|
|
||||||
|
import riffFile from "riff-file";
|
||||||
|
const { RIFFFile } = riffFile;
|
||||||
|
import { unpackArray, unpackString } from "byte-data";
|
||||||
|
|
||||||
|
type Chunk = {
|
||||||
|
format: string;
|
||||||
|
chunkId: string;
|
||||||
|
chunkData: {
|
||||||
|
start: number;
|
||||||
|
end: number;
|
||||||
|
};
|
||||||
|
subChunks: Chunk[];
|
||||||
|
};
|
||||||
|
|
||||||
|
// https://www.informit.com/articles/article.aspx?p=1189080&seqNum=3
|
||||||
|
type AniMetadata = {
|
||||||
|
cbSize: number; // Data structure size (in bytes)
|
||||||
|
nFrames: number; // Number of images (also known as frames) stored in the file
|
||||||
|
nSteps: number; // Number of frames to be displayed before the animation repeats
|
||||||
|
iWidth: number; // Width of frame (in pixels)
|
||||||
|
iHeight: number; // Height of frame (in pixels)
|
||||||
|
iBitCount: number; // Number of bits per pixel
|
||||||
|
nPlanes: number; // Number of color planes
|
||||||
|
iDispRate: number; // Default frame display rate (measured in 1/60th-of-a-second units)
|
||||||
|
bfAttributes: number; // ANI attribute bit flags
|
||||||
|
};
|
||||||
|
|
||||||
|
type ParsedAni = {
|
||||||
|
rate: number[] | null;
|
||||||
|
seq: number[] | null;
|
||||||
|
images: Uint8Array[];
|
||||||
|
metadata: AniMetadata;
|
||||||
|
artist: string | null;
|
||||||
|
title: string | null;
|
||||||
|
};
|
||||||
|
|
||||||
|
const DWORD = { bits: 32, be: false, signed: false, fp: false };
|
||||||
|
|
||||||
|
export function parseAni(arr: Uint8Array): ParsedAni {
|
||||||
|
const riff = new RIFFFile();
|
||||||
|
|
||||||
|
riff.setSignature(arr);
|
||||||
|
|
||||||
|
const signature = riff.signature as Chunk;
|
||||||
|
if (signature.format !== "ACON") {
|
||||||
|
throw new Error(
|
||||||
|
`Expected format. Expected "ACON", got "${signature.format}"`,
|
||||||
|
);
|
||||||
|
}
|
||||||
|
|
||||||
|
// Helper function to get a chunk by chunkId and transform it if it's non-null.
|
||||||
|
function mapChunk<T>(
|
||||||
|
chunkId: string,
|
||||||
|
mapper: (chunk: Chunk) => T,
|
||||||
|
): T | null {
|
||||||
|
const chunk = riff.findChunk(chunkId) as Chunk | null;
|
||||||
|
return chunk == null ? null : mapper(chunk);
|
||||||
|
}
|
||||||
|
|
||||||
|
function readImages(chunk: Chunk, frameCount: number): Uint8Array[] {
|
||||||
|
return chunk.subChunks.slice(0, frameCount).map((c) => {
|
||||||
|
if (c.chunkId !== "icon") {
|
||||||
|
throw new Error(`Unexpected chunk type in fram: ${c.chunkId}`);
|
||||||
|
}
|
||||||
|
return arr.slice(c.chunkData.start, c.chunkData.end);
|
||||||
|
});
|
||||||
|
}
|
||||||
|
|
||||||
|
const metadata = mapChunk("anih", (c) => {
|
||||||
|
const words = unpackArray(
|
||||||
|
arr,
|
||||||
|
DWORD,
|
||||||
|
c.chunkData.start,
|
||||||
|
c.chunkData.end,
|
||||||
|
);
|
||||||
|
return {
|
||||||
|
cbSize: words[0],
|
||||||
|
nFrames: words[1],
|
||||||
|
nSteps: words[2],
|
||||||
|
iWidth: words[3],
|
||||||
|
iHeight: words[4],
|
||||||
|
iBitCount: words[5],
|
||||||
|
nPlanes: words[6],
|
||||||
|
iDispRate: words[7],
|
||||||
|
bfAttributes: words[8],
|
||||||
|
};
|
||||||
|
});
|
||||||
|
|
||||||
|
if (metadata == null) {
|
||||||
|
throw new Error("Did not find anih");
|
||||||
|
}
|
||||||
|
|
||||||
|
const rate = mapChunk("rate", (c) => {
|
||||||
|
return unpackArray(arr, DWORD, c.chunkData.start, c.chunkData.end);
|
||||||
|
});
|
||||||
|
// chunkIds are always four chars, hence the trailing space.
|
||||||
|
const seq = mapChunk("seq ", (c) => {
|
||||||
|
return unpackArray(arr, DWORD, c.chunkData.start, c.chunkData.end);
|
||||||
|
});
|
||||||
|
|
||||||
|
const lists = riff.findChunk("LIST", true) as Chunk[] | null;
|
||||||
|
const imageChunk = lists?.find((c) => c.format === "fram");
|
||||||
|
if (imageChunk == null) {
|
||||||
|
throw new Error("Did not find fram LIST");
|
||||||
|
}
|
||||||
|
|
||||||
|
let images = readImages(imageChunk, metadata.nFrames);
|
||||||
|
|
||||||
|
let title = null;
|
||||||
|
let artist = null;
|
||||||
|
|
||||||
|
const infoChunk = lists?.find((c) => c.format === "INFO");
|
||||||
|
if (infoChunk != null) {
|
||||||
|
infoChunk.subChunks.forEach((c) => {
|
||||||
|
switch (c.chunkId) {
|
||||||
|
case "INAM":
|
||||||
|
title = unpackString(
|
||||||
|
arr,
|
||||||
|
c.chunkData.start,
|
||||||
|
c.chunkData.end,
|
||||||
|
);
|
||||||
|
break;
|
||||||
|
case "IART":
|
||||||
|
artist = unpackString(
|
||||||
|
arr,
|
||||||
|
c.chunkData.start,
|
||||||
|
c.chunkData.end,
|
||||||
|
);
|
||||||
|
break;
|
||||||
|
case "LIST":
|
||||||
|
// Some cursors with an artist of "Created with Take ONE 3.5 (unregisterred version)" seem to have their frames here for some reason?
|
||||||
|
if (c.format === "fram") {
|
||||||
|
images = readImages(c, metadata.nFrames);
|
||||||
|
}
|
||||||
|
break;
|
||||||
|
|
||||||
|
default:
|
||||||
|
// Unexpected subchunk
|
||||||
|
}
|
||||||
|
});
|
||||||
|
}
|
||||||
|
|
||||||
|
return { images, rate, seq, metadata, artist, title };
|
||||||
|
}
|
||||||
|
|
@ -0,0 +1,15 @@
|
||||||
|
{
|
||||||
|
"compilerOptions": {
|
||||||
|
"target": "ES2022",
|
||||||
|
"module": "NodeNext",
|
||||||
|
"moduleResolution": "NodeNext",
|
||||||
|
"outDir": "./dist",
|
||||||
|
"rootDir": "./src",
|
||||||
|
"strict": true,
|
||||||
|
"esModuleInterop": true,
|
||||||
|
"declaration": true,
|
||||||
|
"resolveJsonModule": true,
|
||||||
|
"skipLibCheck": true
|
||||||
|
},
|
||||||
|
"include": ["src/**/*"]
|
||||||
|
}
|
||||||
Loading…
Reference in New Issue