@adhisang/minecraft-modding-mcp 1.0.0

package/dist/version-service.js

@@ -0,0 +1,411 @@
+import { existsSync } from "node:fs";
+import { mkdir, readFile, unlink, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { createError, ERROR_CODES } from "./errors.js";
+import { computeFileSha1 } from "./hash.js";
+import { defaultDownloadPath, downloadToCache } from "./repo-downloader.js";
+const DEFAULT_VERSION_MANIFEST_URL = "https://piston-meta.mojang.com/mc/game/version_manifest_v2.json";
+const MANIFEST_CACHE_TTL_MS = 60 * 60 * 1000;
+const VERSION_DETAIL_CACHE_TTL_MS = 60 * 60 * 1000;
+function clampLimit(limit, fallback, max) {
+    if (!Number.isFinite(limit) || limit == null) {
+        return fallback;
+    }
+    return Math.max(1, Math.min(max, Math.trunc(limit)));
+}
+function isVersionManifest(value) {
+    return typeof value === "object" && value !== null;
+}
+function ensureVersionDetail(value, version) {
+    if (typeof value !== "object" || value == null) {
+        throw createError({
+            code: ERROR_CODES.VERSION_NOT_FOUND,
+            message: `Version metadata for "${version}" is invalid.`,
+            details: { version }
+        });
+    }
+    return value;
+}
+export class VersionService {
+    config;
+    fetchFn;
+    manifestUrl;
+    manifestCache;
+    versionDetailCache = new Map();
+    resolveLocks = new Map();
+    constructor(config, fetchFn = globalThis.fetch) {
+        this.config = config;
+        this.fetchFn = fetchFn;
+        this.manifestUrl = process.env.MCP_VERSION_MANIFEST_URL ?? DEFAULT_VERSION_MANIFEST_URL;
+    }
+    async listVersions(input = {}) {
+        const manifest = await this.fetchManifest();
+        const includeSnapshots = input.includeSnapshots ?? false;
+        const limit = clampLimit(input.limit, 20, 200);
+        const versions = manifest.versions ?? [];
+        const releases = versions
+            .filter((entry) => entry.type === "release")
+            .map((entry) => ({ id: entry.id, unobfuscated: isUnobfuscatedVersion(entry.id) }))
+            .slice(0, limit);
+        const snapshots = versions
+            .filter((entry) => entry.type === "snapshot")
+            .map((entry) => ({ id: entry.id, unobfuscated: isUnobfuscatedVersion(entry.id) }))
+            .slice(0, limit);
+        const cached = (await this.loadCacheIndex()).entries.map((entry) => entry.version);
+        return {
+            latest: {
+                release: manifest.latest?.release,
+                snapshot: manifest.latest?.snapshot
+            },
+            releases,
+            snapshots: includeSnapshots ? snapshots : undefined,
+            cached: Array.from(new Set(cached)).sort((a, b) => a.localeCompare(b)),
+            totalAvailable: versions.length
+        };
+    }
+    async listVersionIds(input = {}) {
+        const manifest = await this.fetchManifest();
+        const includeSnapshots = input.includeSnapshots ?? false;
+        return (manifest.versions ?? [])
+            .filter((entry) => entry.type === "release" || (includeSnapshots && entry.type === "snapshot"))
+            .map((entry) => entry.id);
+    }
+    async resolveVersionJar(version) {
+        const normalizedVersion = version.trim();
+        if (!normalizedVersion) {
+            throw createError({
+                code: ERROR_CODES.INVALID_INPUT,
+                message: "version must be non-empty."
+            });
+        }
+        const existingLock = this.resolveLocks.get(normalizedVersion);
+        if (existingLock) {
+            return existingLock;
+        }
+        const resolvePromise = this.resolveVersionJarInternal(normalizedVersion);
+        this.resolveLocks.set(normalizedVersion, resolvePromise);
+        try {
+            return await resolvePromise;
+        }
+        finally {
+            this.resolveLocks.delete(normalizedVersion);
+        }
+    }
+    async resolveVersionMappings(version) {
+        const normalizedVersion = version.trim();
+        if (!normalizedVersion) {
+            throw createError({
+                code: ERROR_CODES.INVALID_INPUT,
+                message: "version must be non-empty."
+            });
+        }
+        const manifest = await this.fetchManifest();
+        const versionEntry = (manifest.versions ?? []).find((entry) => entry.id === normalizedVersion);
+        if (!versionEntry) {
+            throw createError({
+                code: ERROR_CODES.VERSION_NOT_FOUND,
+                message: `Minecraft version "${normalizedVersion}" was not found in version manifest.`,
+                details: { version: normalizedVersion }
+            });
+        }
+        const details = await this.fetchVersionDetails(versionEntry.url, normalizedVersion);
+        const clientMappingsUrl = details.downloads?.client_mappings?.url;
+        return {
+            version: normalizedVersion,
+            versionManifestUrl: this.manifestUrl,
+            versionDetailUrl: versionEntry.url,
+            clientMappingsUrl,
+            serverMappingsUrl: details.downloads?.server_mappings?.url,
+            mappingsUrl: clientMappingsUrl
+        };
+    }
+    async resolveServerJar(version) {
+        const normalizedVersion = version.trim();
+        if (!normalizedVersion) {
+            throw createError({
+                code: ERROR_CODES.INVALID_INPUT,
+                message: "version must be non-empty."
+            });
+        }
+        const manifest = await this.fetchManifest();
+        const versionEntry = (manifest.versions ?? []).find((entry) => entry.id === normalizedVersion);
+        if (!versionEntry) {
+            throw createError({
+                code: ERROR_CODES.VERSION_NOT_FOUND,
+                message: `Minecraft version "${normalizedVersion}" was not found in version manifest.`,
+                details: { version: normalizedVersion }
+            });
+        }
+        const details = await this.fetchVersionDetails(versionEntry.url, normalizedVersion);
+        const serverJarUrl = details.downloads?.server?.url;
+        if (!serverJarUrl) {
+            throw createError({
+                code: ERROR_CODES.VERSION_NOT_FOUND,
+                message: `Minecraft version "${normalizedVersion}" does not expose a server download URL.`,
+                details: { version: normalizedVersion }
+            });
+        }
+        const destinationPath = defaultDownloadPath(this.config.cacheDir, serverJarUrl);
+        if (existsSync(destinationPath)) {
+            return {
+                version: normalizedVersion,
+                jarPath: destinationPath,
+                source: "downloaded",
+                serverJarUrl
+            };
+        }
+        const downloaded = await downloadToCache(serverJarUrl, destinationPath, {
+            retries: this.config.fetchRetries,
+            timeoutMs: this.config.fetchTimeoutMs,
+            fetchFn: this.fetchFn
+        });
+        if (!downloaded.ok || !downloaded.path) {
+            throw createError({
+                code: ERROR_CODES.REPO_FETCH_FAILED,
+                message: `Failed to download Minecraft server jar for version "${normalizedVersion}".`,
+                details: {
+                    version: normalizedVersion,
+                    url: serverJarUrl,
+                    statusCode: downloaded.statusCode
+                }
+            });
+        }
+        const expectedSha1 = details.downloads?.server?.sha1;
+        if (expectedSha1) {
+            const actualSha1 = await computeFileSha1(downloaded.path);
+            if (actualSha1 !== expectedSha1) {
+                await unlink(downloaded.path).catch(() => { });
+                throw createError({
+                    code: ERROR_CODES.REPO_FETCH_FAILED,
+                    message: `SHA-1 mismatch for downloaded server jar of version "${normalizedVersion}".`,
+                    details: {
+                        version: normalizedVersion,
+                        url: serverJarUrl,
+                        expected: expectedSha1,
+                        actual: actualSha1
+                    }
+                });
+            }
+        }
+        return {
+            version: normalizedVersion,
+            jarPath: downloaded.path,
+            source: "downloaded",
+            serverJarUrl
+        };
+    }
+    async fetchManifest() {
+        const now = Date.now();
+        if (this.manifestCache && this.manifestCache.expiresAt > now) {
+            return this.manifestCache.value;
+        }
+        const manifest = await this.fetchJson(this.manifestUrl);
+        if (!isVersionManifest(manifest)) {
+            throw createError({
+                code: ERROR_CODES.REPO_FETCH_FAILED,
+                message: "Minecraft version manifest response is invalid.",
+                details: { manifestUrl: this.manifestUrl }
+            });
+        }
+        this.manifestCache = {
+            value: manifest,
+            expiresAt: now + MANIFEST_CACHE_TTL_MS
+        };
+        return manifest;
+    }
+    async resolveVersionJarInternal(normalizedVersion) {
+        const cachedIndex = await this.loadCacheIndex();
+        const cachedEntry = cachedIndex.entries.find((entry) => entry.version === normalizedVersion);
+        if (cachedEntry && existsSync(cachedEntry.jarPath)) {
+            return {
+                version: normalizedVersion,
+                jarPath: cachedEntry.jarPath,
+                source: "downloaded",
+                clientJarUrl: "cache:index"
+            };
+        }
+        const manifest = await this.fetchManifest();
+        const versionEntry = (manifest.versions ?? []).find((entry) => entry.id === normalizedVersion);
+        if (!versionEntry) {
+            throw createError({
+                code: ERROR_CODES.VERSION_NOT_FOUND,
+                message: `Minecraft version "${normalizedVersion}" was not found in version manifest.`,
+                details: { version: normalizedVersion }
+            });
+        }
+        const details = await this.fetchVersionDetails(versionEntry.url, normalizedVersion);
+        const clientJarUrl = details.downloads?.client?.url;
+        if (!clientJarUrl) {
+            throw createError({
+                code: ERROR_CODES.VERSION_NOT_FOUND,
+                message: `Minecraft version "${normalizedVersion}" does not expose a client download URL.`,
+                details: { version: normalizedVersion }
+            });
+        }
+        const destinationPath = defaultDownloadPath(this.config.cacheDir, clientJarUrl);
+        if (existsSync(destinationPath)) {
+            await this.recordCacheEntry({
+                version: normalizedVersion,
+                jarPath: destinationPath,
+                downloadedAt: new Date().toISOString()
+            });
+            return {
+                version: normalizedVersion,
+                jarPath: destinationPath,
+                source: "downloaded",
+                clientJarUrl
+            };
+        }
+        const downloaded = await downloadToCache(clientJarUrl, destinationPath, {
+            retries: this.config.fetchRetries,
+            timeoutMs: this.config.fetchTimeoutMs,
+            fetchFn: this.fetchFn
+        });
+        if (!downloaded.ok || !downloaded.path) {
+            throw createError({
+                code: ERROR_CODES.REPO_FETCH_FAILED,
+                message: `Failed to download Minecraft client jar for version "${normalizedVersion}".`,
+                details: {
+                    version: normalizedVersion,
+                    url: clientJarUrl,
+                    statusCode: downloaded.statusCode
+                }
+            });
+        }
+        const expectedSha1 = details.downloads?.client?.sha1;
+        if (expectedSha1) {
+            const actualSha1 = await computeFileSha1(downloaded.path);
+            if (actualSha1 !== expectedSha1) {
+                await unlink(downloaded.path).catch(() => { });
+                throw createError({
+                    code: ERROR_CODES.REPO_FETCH_FAILED,
+                    message: `SHA-1 mismatch for downloaded jar of version "${normalizedVersion}".`,
+                    details: {
+                        version: normalizedVersion,
+                        url: clientJarUrl,
+                        expected: expectedSha1,
+                        actual: actualSha1
+                    }
+                });
+            }
+        }
+        await this.recordCacheEntry({
+            version: normalizedVersion,
+            jarPath: downloaded.path,
+            downloadedAt: new Date().toISOString()
+        });
+        return {
+            version: normalizedVersion,
+            jarPath: downloaded.path,
+            source: "downloaded",
+            clientJarUrl
+        };
+    }
+    async fetchVersionDetails(versionUrl, version) {
+        const now = Date.now();
+        const cached = this.versionDetailCache.get(versionUrl);
+        if (cached && cached.expiresAt > now) {
+            this.versionDetailCache.delete(versionUrl);
+            this.versionDetailCache.set(versionUrl, cached);
+            return cached.value;
+        }
+        const detailRaw = await this.fetchJson(versionUrl);
+        const details = ensureVersionDetail(detailRaw, version);
+        this.versionDetailCache.set(versionUrl, {
+            value: details,
+            expiresAt: now + VERSION_DETAIL_CACHE_TTL_MS
+        });
+        this.trimVersionDetailCache();
+        return details;
+    }
+    async fetchJson(url) {
+        const response = await this.fetchFn(url);
+        if (!response.ok) {
+            throw createError({
+                code: ERROR_CODES.REPO_FETCH_FAILED,
+                message: `Request failed for "${url}" with status ${response.status}.`,
+                details: {
+                    url,
+                    statusCode: response.status
+                }
+            });
+        }
+        try {
+            return await response.json();
+        }
+        catch {
+            throw createError({
+                code: ERROR_CODES.REPO_FETCH_FAILED,
+                message: `Response from "${url}" is not valid JSON.`,
+                details: { url }
+            });
+        }
+    }
+    cacheIndexPath() {
+        return join(this.config.cacheDir, "versions", "index.json");
+    }
+    async loadCacheIndex() {
+        const indexPath = this.cacheIndexPath();
+        try {
+            const raw = await readFile(indexPath, "utf8");
+            const parsed = JSON.parse(raw);
+            if (!Array.isArray(parsed.entries)) {
+                return { entries: [] };
+            }
+            return {
+                entries: parsed.entries.filter((entry) => typeof entry === "object" &&
+                    entry != null &&
+                    typeof entry.version === "string" &&
+                    typeof entry.jarPath === "string" &&
+                    typeof entry.downloadedAt === "string")
+            };
+        }
+        catch {
+            return { entries: [] };
+        }
+    }
+    async recordCacheEntry(entry) {
+        const indexPath = this.cacheIndexPath();
+        const existing = await this.loadCacheIndex();
+        const deduped = existing.entries.filter((candidate) => candidate.version !== entry.version);
+        deduped.push(entry);
+        deduped.sort((left, right) => right.downloadedAt.localeCompare(left.downloadedAt));
+        await mkdir(dirname(indexPath), { recursive: true });
+        await writeFile(indexPath, `${JSON.stringify({
+            entries: deduped
+        }, null, 2)}\n`, "utf8");
+    }
+    trimVersionDetailCache() {
+        const maxEntries = Math.max(1, this.config.maxVersionDetailCache ?? 256);
+        while (this.versionDetailCache.size > maxEntries) {
+            const oldest = this.versionDetailCache.keys().next().value;
+            if (!oldest) {
+                return;
+            }
+            this.versionDetailCache.delete(oldest);
+        }
+    }
+}
+/**
+ * MC 26.1+ uses new YY.N version format and ships unobfuscated source.
+ * Legacy 1.x.y versions remain obfuscated.
+ * Snapshots: "26w01a" (year >= 26) → unobfuscated, "24w01a" → obfuscated.
+ */
+export function isUnobfuscatedVersion(version) {
+    if (!version)
+        return false;
+    // Snapshot format: YYwNNa (e.g. "26w01a")
+    const snapshotMatch = version.match(/^(\d{2})w\d{2}[a-z]$/);
+    if (snapshotMatch) {
+        return Number(snapshotMatch[1]) >= 26;
+    }
+    // New format: YY.N or YY.N.P, optionally with -preN/-rcN suffix.
+    // Examples: "26.1", "27.3.1", "26.1-pre1", "26.1-rc1"
+    const newFormatMatch = version.match(/^(\d{2,})\.\d+(?:\.\d+)?(?:-(?:pre|rc)\d+)?$/);
+    if (newFormatMatch) {
+        return Number(newFormatMatch[1]) >= 26;
+    }
+    // Legacy 1.x.y → obfuscated; unknown → false (safe default)
+    return false;
+}
+//# sourceMappingURL=version-service.js.map

package/dist/vineflower-resolver.d.ts

@@ -0,0 +1 @@
+export declare function resolveVineflowerJar(cacheDir: string, overridePath: string | undefined, fetchFn?: typeof fetch): Promise<string>;

package/dist/vineflower-resolver.js

@@ -0,0 +1,62 @@
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { createError, ERROR_CODES } from "./errors.js";
+import { log } from "./logger.js";
+import { downloadToCache } from "./repo-downloader.js";
+const DEFAULT_VERSION = "1.11.2";
+const DOWNLOAD_TIMEOUT_MS = 120_000;
+const inflightDownloads = new Map();
+function vineflowerCachePath(cacheDir, version) {
+    return join(cacheDir, "resources", `vineflower-${version}.jar`);
+}
+function vineflowerDownloadUrl(version) {
+    return `https://github.com/Vineflower/vineflower/releases/download/${version}/vineflower-${version}.jar`;
+}
+export async function resolveVineflowerJar(cacheDir, overridePath, fetchFn) {
+    // 1. Environment / config override
+    if (overridePath) {
+        return overridePath;
+    }
+    const version = process.env.MCP_VINEFLOWER_VERSION ?? DEFAULT_VERSION;
+    const cached = vineflowerCachePath(cacheDir, version);
+    // 2. Already cached
+    if (existsSync(cached)) {
+        return cached;
+    }
+    // 3. Download with per-target lock
+    const inflight = inflightDownloads.get(cached);
+    if (inflight) {
+        return inflight;
+    }
+    const downloadPromise = downloadVineflower(version, cached, fetchFn);
+    inflightDownloads.set(cached, downloadPromise);
+    try {
+        return await downloadPromise;
+    }
+    finally {
+        inflightDownloads.delete(cached);
+    }
+}
+async function downloadVineflower(version, destination, fetchFn) {
+    const url = vineflowerDownloadUrl(version);
+    log("info", "vineflower.download.start", { version, url });
+    const result = await downloadToCache(url, destination, {
+        timeoutMs: DOWNLOAD_TIMEOUT_MS,
+        retries: 2,
+        ...(fetchFn ? { fetchFn } : {})
+    });
+    if (!result.ok || !result.path) {
+        throw createError({
+            code: ERROR_CODES.DECOMPILER_UNAVAILABLE,
+            message: `Failed to download Vineflower ${version} from GitHub.`,
+            details: { version, url, statusCode: result.statusCode }
+        });
+    }
+    log("info", "vineflower.download.done", {
+        version,
+        path: result.path,
+        contentLength: result.contentLength
+    });
+    return result.path;
+}
+//# sourceMappingURL=vineflower-resolver.js.map

package/dist/workspace-mapping-service.d.ts

@@ -0,0 +1,18 @@
+import type { SourceMapping } from "./types.js";
+export type WorkspaceCompileMappingInput = {
+    projectPath: string;
+};
+export type WorkspaceMappingEvidence = {
+    filePath: string;
+    mapping: SourceMapping;
+    reason: string;
+};
+export type WorkspaceCompileMappingOutput = {
+    resolved: boolean;
+    mappingApplied?: SourceMapping;
+    evidence: WorkspaceMappingEvidence[];
+    warnings: string[];
+};
+export declare class WorkspaceMappingService {
+    detectCompileMapping(input: WorkspaceCompileMappingInput): Promise<WorkspaceCompileMappingOutput>;
+}

package/dist/workspace-mapping-service.js

@@ -0,0 +1,89 @@
+import { readFile } from "node:fs/promises";
+import { resolve } from "node:path";
+import fastGlob from "fast-glob";
+import { createError, ERROR_CODES } from "./errors.js";
+function detectMappingsFromContent(content) {
+    const detections = [];
+    if (/officialMojangMappings\s*\(/i.test(content)) {
+        detections.push({
+            mapping: "mojang",
+            reason: "officialMojangMappings()"
+        });
+    }
+    if (/\bmappings\s*(?:\(|)\s*["']net\.fabricmc:yarn:/i.test(content)) {
+        detections.push({
+            mapping: "yarn",
+            reason: "mappings net.fabricmc:yarn"
+        });
+    }
+    if (/\bmappings\s*(?:\(|)\s*["']net\.fabricmc:intermediary:/i.test(content)) {
+        detections.push({
+            mapping: "intermediary",
+            reason: "mappings net.fabricmc:intermediary"
+        });
+    }
+    return detections;
+}
+export class WorkspaceMappingService {
+    async detectCompileMapping(input) {
+        const projectPath = input.projectPath?.trim();
+        if (!projectPath) {
+            throw createError({
+                code: ERROR_CODES.INVALID_INPUT,
+                message: "projectPath must be a non-empty string.",
+                details: {
+                    projectPath: input.projectPath
+                }
+            });
+        }
+        const root = resolve(projectPath);
+        const files = fastGlob.sync(["build.gradle", "build.gradle.kts", "**/build.gradle", "**/build.gradle.kts"], {
+            cwd: root,
+            absolute: true,
+            onlyFiles: true,
+            ignore: ["**/.git/**", "**/.gradle/**", "**/build/**", "**/out/**", "**/node_modules/**"]
+        });
+        const evidence = [];
+        for (const filePath of files.sort((left, right) => left.localeCompare(right))) {
+            let content;
+            try {
+                content = await readFile(filePath, "utf8");
+            }
+            catch {
+                continue;
+            }
+            const detections = detectMappingsFromContent(content);
+            for (const detection of detections) {
+                evidence.push({
+                    filePath,
+                    mapping: detection.mapping,
+                    reason: detection.reason
+                });
+            }
+        }
+        if (evidence.length === 0) {
+            return {
+                resolved: false,
+                evidence,
+                warnings: ["No compile-time mapping declaration was detected in build.gradle(.kts) files."]
+            };
+        }
+        const mappingSet = new Set(evidence.map((entry) => entry.mapping));
+        if (mappingSet.size > 1) {
+            return {
+                resolved: false,
+                evidence,
+                warnings: [
+                    `Multiple compile mappings were detected across the workspace: ${[...mappingSet].join(", ")}.`
+                ]
+            };
+        }
+        return {
+            resolved: true,
+            mappingApplied: evidence[0].mapping,
+            evidence,
+            warnings: []
+        };
+    }
+}
+//# sourceMappingURL=workspace-mapping-service.js.map

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "@adhisang/minecraft-modding-mcp",
+  "version": "1.0.0",
+  "description": "MCP server with utilities for Minecraft modding workflows",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "bin": {
+    "minecraft-modding-mcp": "dist/cli.js"
+  },
+  "files": [
+    "dist/**/*.js",
+    "dist/**/*.d.ts",
+    "README.md",
+    "LICENSE",
+    "CHANGELOG.md"
+  ],
+  "scripts": {
+    "dev": "tsx src/cli.ts",
+    "clean": "node --input-type=module -e \"import { rmSync } from 'node:fs'; rmSync('dist', { recursive: true, force: true });\"",
+    "build": "npm run clean && tsc -p tsconfig.json",
+    "prepack": "npm run build",
+    "start": "node dist/cli.js",
+    "check": "tsc --noEmit -p tsconfig.json",
+    "test": "node --test --import tsx tests/*.test.ts",
+    "test:coverage": "node --test --import tsx --experimental-test-coverage --test-coverage-lines=80 --test-coverage-branches=70 --test-coverage-functions=80 tests/*.test.ts",
+    "test:coverage:lcov": "node --input-type=module -e \"import { mkdirSync } from 'node:fs'; mkdirSync('coverage', { recursive: true });\" && node --test --import tsx --experimental-test-coverage --test-reporter=lcov --test-reporter-destination=coverage/lcov.info --test-coverage-lines=80 --test-coverage-branches=70 --test-coverage-functions=80 tests/*.test.ts",
+    "test:perf": "node --test --test-concurrency=1 --import tsx tests/perf/*.perf.ts",
+    "test:perf:update-baseline": "UPDATE_PERF_BASELINE=1 node --test --test-concurrency=1 --import tsx tests/perf/*.perf.ts",
+    "test:perf:strict": "STRICT_PERF=1 node --test --test-concurrency=1 --import tsx tests/perf/*.perf.ts",
+    "test:manual:mcp-use-smoke": "node --import tsx tests/manual/mcp-use-client-smoke.manual.ts",
+    "test:manual:package-smoke": "node --import tsx tests/manual/package-distribution-smoke.manual.ts",
+    "validate": "npm run check && npm test && npm run test:coverage && npm run test:perf"
+  },
+  "keywords": [
+    "mcp",
+    "minecraft",
+    "modding"
+  ],
+  "author": "adhi-jp",
+  "license": "MIT",
+  "repository": "github:adhi-jp/minecraft-modding-mcp",
+  "bugs": "https://github.com/adhi-jp/minecraft-modding-mcp/issues",
+  "homepage": "https://github.com/adhi-jp/minecraft-modding-mcp#readme",
+  "engines": {
+    "node": ">=22"
+  },
+  "dependencies": {
+    "mcp-use": "^1.20.5",
+    "fast-glob": "^3.3.3",
+    "smol-toml": "^1.3.0",
+    "yauzl": "^3.2.0",
+    "zod": "^3.23.8"
+  },
+  "devDependencies": {
+    "@types/node": "^22.13.5",
+    "@types/yauzl": "^2.10.3",
+    "tsx": "^4.19.2",
+    "typescript": "^5.7.3"
+  }
+}