@iborymagic/aseprite-mcp 0.3.4 → 0.3.6

package/README.md

@@ -28,14 +28,14 @@ Adds deeper control using Aseprite Lua scripting, enabling safe AI-driven editin
 ## How to use
 1) Run directly with npx
 ```bash
-npx -y aseprite-mcp
+npx -y @iborymagic/aseprite-mcp
 ```
 
 2) Local Build & Run (for development)
 ```bash
 npm install
 npm run build
-npx aseprite-mcp
+npx @iborymagic/aseprite-mcp
 ```
 
 ### Using with Claude Desktop
@@ -45,7 +45,7 @@ Add the following to your claude_desktop_config.json
   "mcpServers": {
     "aseprite-mcp": {
       "command": "npx",
-      "args": ["-y", "aseprite-mcp"]
+      "args": ["-y", "@iborymagic/aseprite-mcp"]
     }
   }
 }
@@ -58,7 +58,7 @@ Add the following to your mcp.json
   "mcpServers": {
     "aseprite-mcp": {
       "command": "npx",
-      "args": ["-y", "aseprite-mcp"]
+      "args": ["-y", "@iborymagic/aseprite-mcp"]
     }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@iborymagic/aseprite-mcp",
-  "version": "0.3.4",
+  "version": "0.3.6",
   "description": "MCP server for using Aseprite API",
   "main": "index.js",
   "type": "module",

package/build/aseprite/steam.js

@@ -1,96 +0,0 @@
-import { existsSync, readFileSync } from "node:fs";
-import { exec } from "node:child_process";
-import { promisify } from "node:util";
-import * as os from "node:os";
-import * as path from "node:path";
-const execAsync = promisify(exec);
-const defaultCandidates = {
-    win32: [
-        "C:\\Program Files\\Aseprite\\aseprite.exe",
-        "C:\\Program Files (x86)\\Aseprite\\aseprite.exe"
-    ],
-    darwin: [
-        "/Applications/Aseprite.app/Contents/MacOS/aseprite",
-        "/usr/local/bin/aseprite",
-        "/opt/homebrew/bin/aseprite"
-    ],
-    linux: [
-        "/usr/bin/aseprite",
-        "/usr/local/bin/aseprite"
-    ]
-};
-function getSteamVdfPaths() {
-    switch (process.platform) {
-        case "win32":
-            return [
-                path.join(process.env.PROGRAMFILESX86 ??
-                    "C:\\Program Files (x86)", "Steam/steamapps/libraryfolders.vdf"),
-                path.join(process.env.PROGRAMFILES ??
-                    "C:\\Program Files", "Steam/steamapps/libraryfolders.vdf")
-            ];
-        case "darwin":
-            return [
-                path.join(os.homedir(), "Library/Application Support/Steam/steamapps/libraryfolders.vdf")
-            ];
-        default:
-            // linux
-            return [
-                path.join(os.homedir(), ".steam/steam/steamapps/libraryfolders.vdf"),
-                path.join(os.homedir(), ".local/share/Steam/steamapps/libraryfolders.vdf")
-            ];
-    }
-}
-function parseSteamLibraries(vdfContent) {
-    const lines = vdfContent.split("\n");
-    const paths = [];
-    for (const line of lines) {
-        const match = line.match(/"(\d+)"\s+"(.+?)"/);
-        if (match) {
-            let p = match[2];
-            if (process.platform === "win32") {
-                p = p.replace(/\\\\/g, "\\");
-            }
-            paths.push(p);
-        }
-        // libraryfolders 2.0
-        const kvMatch = line.match(/"path"\s+"(.+?)"/);
-        if (kvMatch) {
-            let p = kvMatch[1];
-            if (process.platform === "win32") {
-                p = p.replace(/\\\\/g, "\\");
-            }
-            paths.push(p);
-        }
-    }
-    return Array.from(new Set(paths));
-}
-export function getSteamAsepritePaths() {
-    const files = getSteamVdfPaths();
-    for (const file of files) {
-        if (!existsSync(file))
-            continue;
-        try {
-            const content = readFileSync(file, "utf8");
-            const libs = parseSteamLibraries(content);
-            const paths = [];
-            for (const lib of libs) {
-                switch (process.platform) {
-                    case "win32":
-                        paths.push(path.join(lib, "steamapps/common/Aseprite/aseprite.exe"));
-                        break;
-                    case "darwin":
-                        paths.push(path.join(lib, "steamapps/common/Aseprite/Aseprite.app/Contents/MacOS/aseprite"));
-                        break;
-                    default: // linux
-                        paths.push(path.join(lib, "steamapps/common/Aseprite/aseprite"));
-                        break;
-                }
-            }
-            return paths;
-        }
-        catch {
-            continue;
-        }
-    }
-    return [];
-}

package/build/generator/image-generator.js

@@ -1,55 +0,0 @@
-import path from "node:path";
-import fs from "node:fs/promises";
-import axios from "axios";
-export class StubImageGenerator {
-    async generate(params) {
-        throw new Error(`Image generator not configured. Tried to generate: "${params.prompt}" to ${params.outputPath}`);
-    }
-}
-export class StableDiffusionWebuiGenerator {
-    baseUrl;
-    constructor(baseUrl) {
-        this.baseUrl = baseUrl;
-    }
-    async generate(params) {
-        const url = `${this.baseUrl}/sdapi/v1/txt2img`;
-        const prompt = `${params.prompt}, ` +
-            `pixel art, retro 16-bit, clean outline, sharp edges, high contrast, game sprite`;
-        const negative = params.negativePrompt ??
-            "photo, realistic, blurry, lowres, smear, oil painting";
-        const body = {
-            prompt,
-            negative_prompt: negative,
-            width: params.width,
-            height: params.height,
-            steps: 28,
-            sampler_name: "DPM++ 2M",
-            cfg_scale: 7,
-            seed: params.seed ?? -1,
-            restore_faces: false,
-            tiling: false
-        };
-        const res = await axios.post(url, body, {
-            timeout: 1000 * 60 * 3
-        });
-        if (!res.data?.images?.length) {
-            throw new Error("Stable Diffusion returned no images");
-        }
-        const imgBase64 = res.data.images[0];
-        const buffer = Buffer.from(imgBase64, "base64");
-        const dir = path.dirname(params.outputPath);
-        await fs.mkdir(dir, { recursive: true });
-        await fs.writeFile(params.outputPath, buffer);
-        let seed = params.seed;
-        try {
-            const info = JSON.parse(res.data.info ?? "{}");
-            if (info.seed)
-                seed = info.seed;
-        }
-        catch { }
-        return {
-            imagePath: params.outputPath,
-            seed
-        };
-    }
-}

package/build/generator/tools.js

@@ -1,210 +0,0 @@
-import z from "zod";
-import { errorResult, successResult } from "../util.js";
-import { ensureSafePath } from "../aseprite/path.js";
-import path from "path";
-import fs from "node:fs/promises";
-import { runLuaScriptFile } from "../lua/cli.js";
-import { createToolHandlers as createPipelineToolHandlers } from "../pipeline/tools.js";
-import { fileURLToPath } from "node:url";
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-const toolSchemas = createToolSchemas();
-export function createToolHandlers() {
-    const character_generate_concept = async ({ params: { prompt, workspaceDir, fileName = "concept.png", width = 256, height = 256, seed, stylePreset = "pixel_art" } }, generator) => {
-        try {
-            const workspaceAbs = ensureSafePath(workspaceDir, { mustExist: false });
-            await fs.mkdir(workspaceAbs, { recursive: true });
-            const outputPath = path.join(workspaceAbs, fileName);
-            const result = await generator.generate({
-                prompt,
-                negativePrompt: undefined,
-                width,
-                height,
-                seed,
-                stylePreset,
-                outputPath
-            });
-            return successResult("character_generate_concept", {
-                prompt,
-                workspaceDir: workspaceAbs,
-                imagePath: result.imagePath,
-                seed: result.seed
-            });
-        }
-        catch (err) {
-            return errorResult("character_generate_concept", `Character generate concept failed: ${err instanceof Error ? err.message : String(err)}`);
-        }
-    };
-    const character_import_from_concept = async ({ params: { conceptImage, outputFile, spriteSize: spriteSizeParam = 0, animationSpec: animationSpecParam = "Idle:4" }, }) => {
-        try {
-            const conceptAbs = ensureSafePath(conceptImage, {
-                mustExist: true
-            });
-            const outputAbs = ensureSafePath(outputFile, {
-                mustExist: false
-            });
-            const spriteSize = spriteSizeParam ?? 0;
-            const animationSpec = animationSpecParam ?? "Idle:4";
-            // Lua templates are in the source directory, reference from project root
-            const luaScriptPath = path.join(process.cwd(), "src", "lua", "templates", "character_import_from_concept.lua");
-            const result = await runLuaScriptFile(luaScriptPath, {
-                conceptImage: conceptAbs,
-                outputFile: outputAbs,
-                spriteSize,
-                animationSpec
-            });
-            if (result.timedOut) {
-                return errorResult("character_import_from_concept", `Lua script timed out while importing from concept: ${luaScriptPath}`);
-            }
-            return successResult("character_import_from_concept", {
-                command: result.command,
-                conceptImage: conceptAbs,
-                outputFile: outputAbs,
-                spriteSize,
-                animationSpec
-            });
-        }
-        catch (err) {
-            return errorResult("character_import_from_concept", `Character import from concept failed: ${err instanceof Error ? err.message : String(err)}`);
-        }
-    };
-    const character_generate_full = async ({ params: { prompt, config, paths } }, generator) => {
-        try {
-            const spriteSize = config?.spriteSize ?? 32;
-            const animations = config?.animations ?? [
-                { name: "Idle", frames: 4 },
-                { name: "Walk", frames: 8 }
-            ];
-            const seed = config?.seed;
-            const charName = (paths.name ??
-                prompt
-                    .toLowerCase()
-                    .replace(/[^a-z0-9]+/g, "_")
-                    .replace(/^_+|_+$/g, "")
-                    .slice(0, 32)) ||
-                "character";
-            const workspaceBase = ensureSafePath(paths.workspaceDir, {
-                mustExist: false
-            });
-            const exportBase = ensureSafePath(paths.exportDir, {
-                mustExist: false
-            });
-            const workspaceDir = path.join(workspaceBase, charName);
-            const exportDir = path.join(exportBase, charName);
-            await fs.mkdir(workspaceDir, { recursive: true });
-            await fs.mkdir(exportDir, { recursive: true });
-            const conceptResult = await character_generate_concept({
-                params: {
-                    prompt,
-                    workspaceDir,
-                    fileName: "concept.png",
-                    width: spriteSize * 8,
-                    height: spriteSize * 8,
-                    seed,
-                    stylePreset: "pixel_art"
-                }
-            }, generator);
-            const conceptContent = conceptResult.content?.[0];
-            const conceptJson = conceptContent
-                ? JSON.parse(conceptContent.text)
-                : null;
-            if (!conceptJson || !conceptJson.success) {
-                return errorResult("character_generate_full", {
-                    stage: "generate_concept",
-                    error: conceptJson?.error ?? "Concept generation failed"
-                });
-            }
-            const conceptImage = conceptJson.result.imagePath;
-            const animationSpec = animations
-                .map((a) => `${a.name}:${a.frames}`)
-                .join(",");
-            const outputFile = path.join(workspaceDir, `${charName}.aseprite`);
-            const importResult = await character_import_from_concept({
-                params: {
-                    conceptImage,
-                    outputFile,
-                    spriteSize,
-                    animationSpec
-                }
-            }, {});
-            const importContent = importResult.content?.[0];
-            const importJson = importContent ? JSON.parse(importContent.text) : null;
-            if (!importJson || !importJson.success) {
-                return errorResult("character_generate_full", {
-                    stage: "import_sprite",
-                    error: importJson?.error ?? "Sprite import failed"
-                });
-            }
-            const asepriteFile = importJson.result.outputFile;
-            const pipelineToolHandlers = createPipelineToolHandlers();
-            const buildResult = await pipelineToolHandlers.character_pipeline_build({
-                inputFile: asepriteFile,
-                exportDir
-            }, {});
-            const buildContent = buildResult.content?.[0];
-            const buildJson = buildContent ? JSON.parse(buildContent.text) : null;
-            if (!buildJson || !buildJson.success) {
-                return errorResult("character_generate_full", {
-                    stage: "pipeline_build",
-                    error: buildJson?.error ?? "Character pipeline build failed"
-                });
-            }
-            return successResult("character_generate_full", {
-                name: charName,
-                prompt,
-                spriteSize,
-                workspaceDir,
-                exportDir,
-                concept: conceptJson.result,
-                asepriteFile,
-                pipeline: buildJson.result
-            });
-        }
-        catch (err) {
-            return errorResult("character_generate_full", err instanceof Error ? err : new Error(String(err)));
-        }
-    };
-    return {
-        character_generate_concept: async (params, generator) => character_generate_concept(params, generator),
-        character_import_from_concept,
-        character_generate_full: async (params, generator) => character_generate_full(params, generator),
-    };
-}
-export function createToolSchemas() {
-    return {
-        character_generate_concept: z.object({
-            params: z.object({
-                prompt: z.string(),
-                workspaceDir: z.string(),
-                fileName: z.string().optional(),
-                width: z.number().optional(),
-                height: z.number().optional(),
-                seed: z.number().optional(),
-                stylePreset: z.string().optional(),
-            }),
-        }),
-        character_import_from_concept: z.object({
-            params: z.object({
-                conceptImage: z.string(),
-                outputFile: z.string(),
-                spriteSize: z.number().optional(),
-                animationSpec: z.string().optional(),
-            }),
-        }),
-        character_generate_full: z.object({
-            params: z.object({
-                prompt: z.string(),
-                config: z.object({
-                    spriteSize: z.number().optional(),
-                    animations: z.array(z.object({ name: z.string(), frames: z.number() })).optional(),
-                    seed: z.number().optional(),
-                }),
-                paths: z.object({
-                    workspaceDir: z.string(),
-                    exportDir: z.string(),
-                    name: z.string().optional(),
-                }),
-            }),
-        }),
-    };
-}

package/build/localtest.js

@@ -1,16 +0,0 @@
-import { resolveAsepritePath } from "./aseprite/env.js";
-import { runAsepriteCommand } from "./aseprite/cli.js";
-async function main() {
-    try {
-        const path = await resolveAsepritePath();
-        const { stdout: version } = await runAsepriteCommand(["--version"]);
-        console.log("✅ Aseprite OK");
-        console.log("Path:", path);
-        console.log("Version:", version);
-    }
-    catch (err) {
-        console.error("❌ Failed");
-        console.error(err.message ?? err);
-    }
-}
-main();

package/build/lua/templates.js

@@ -1,60 +0,0 @@
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-import { ensureSafePath } from "../aseprite/path.js";
-import { runAsepriteCommand } from "../aseprite/cli.js";
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-export const LUA_TEMPLATES = [
-    {
-        id: "remove_layer_by_name",
-        description: "Removes a layer with a given name and saves to a new file (or overwrites).",
-        params: ["inputFile", "layerName"],
-        optionalParams: ["saveOutput"],
-        scriptPath: path.join(__dirname, "templates", "remove_layer_by_name.lua")
-    },
-    {
-        id: "export_tag_frames",
-        description: "Exports only the frames of a specific tag as PNG images.",
-        params: ["inputFile", "tag", "outputDir"],
-        optionalParams: ["filenamePrefix"],
-        scriptPath: path.join(__dirname, "templates", "export_tag_frames.lua")
-    },
-    {
-        id: "recolor_palette",
-        description: "Recolors the palette based on a mapping of from->to colors.",
-        params: ["inputFile", "saveOutput", "mapping"],
-        optionalParams: [],
-        scriptPath: path.join(__dirname, "templates", "recolor_palette.lua")
-    },
-    {
-        id: "normalize_animation_speed",
-        description: "Normalizes all frame durations to a single target duration (in seconds).",
-        params: ["inputFile", "saveOutput", "targetDuration"],
-        optionalParams: [],
-        scriptPath: path.join(__dirname, "templates", "normalize_animation_speed.lua")
-    }
-];
-export function findLuaTemplate(id) {
-    return LUA_TEMPLATES.find(t => t.id === id);
-}
-export async function runLuaTemplate(template, params) {
-    return runLua(template, params);
-}
-export async function runLuaScript(scriptPath, params) {
-    return runLua(scriptPath, params);
-}
-export async function runLua(script, params) {
-    const args = ["--batch"];
-    if (typeof params.inputFile === "string") {
-        const inputAbs = ensureSafePath(params.inputFile, { mustExist: true });
-        args.push(`"${inputAbs}"`);
-    }
-    const scriptPath = typeof script === "string" ? script : script.scriptPath;
-    args.push("--script", `"${scriptPath}"`);
-    for (const [key, value] of Object.entries(params)) {
-        if (key === "inputFile" || value == null)
-            continue;
-        args.push("--script-param", `${key}=${value}`);
-    }
-    return runAsepriteCommand(args);
-}

package/build/pipeline/character.js

@@ -1,66 +0,0 @@
-export function analyzeCharacterFromMetadata(inputFile, metaJson) {
-    const framesArray = Object.values(metaJson.frames);
-    const totalFrames = framesArray.length;
-    const width = metaJson.meta.size?.w ?? 0;
-    const height = metaJson.meta.size?.h ?? 0;
-    const tags = metaJson.meta.frameTags ?? [];
-    const tagAnalyses = [];
-    const warnings = [];
-    const recommendations = [];
-    const recommendedTags = ["Idle", "Walk", "Attack"];
-    for (const tag of tags) {
-        const { name, from, to } = tag;
-        const durationPattern = [];
-        const issues = [];
-        for (let i = from; i <= to; i++) {
-            const frame = framesArray[i];
-            if (frame) {
-                durationPattern.push(frame.duration);
-            }
-            else {
-                issues.push(`missing_frame_index_${i}`);
-            }
-        }
-        if (durationPattern.length > 1) {
-            const first = durationPattern[0];
-            const inconsistent = durationPattern.some((duration) => duration !== first);
-            if (inconsistent) {
-                issues.push("duration_inconsistent");
-            }
-        }
-        tagAnalyses.push({
-            name,
-            frames: to - from + 1,
-            from,
-            to,
-            durationPattern,
-            issues
-        });
-    }
-    const existingTagNames = new Set(tags.map((tag) => tag.name));
-    for (const tag of recommendedTags) {
-        const exists = Array.from(existingTagNames).some((tagName) => tagName.toLowerCase() === tag.toLowerCase());
-        if (!exists) {
-            warnings.push(`Missing recommended animation tag: ${tag}`);
-        }
-    }
-    if (tags.length === 0) {
-        warnings.push("No frame tags found. Consider defining Idle/Walk/Attack tags.");
-        recommendations.push("Define basic animation tags like Idle, Walk, and Attack.");
-    }
-    if (tagAnalyses.some((tagAnalysis) => tagAnalysis.issues.includes("duration_inconsistent"))) {
-        warnings.push("Some tags have inconsistent frame durations.");
-        recommendations.push("Normalize frame durations for smoother animations.");
-    }
-    return {
-        file: inputFile,
-        sprite: {
-            width,
-            height,
-            frames: totalFrames
-        },
-        tags: tagAnalyses,
-        warnings,
-        recommendations
-    };
-}

package/build/pipeline/tools.js

@@ -1,226 +0,0 @@
-import fs from "node:fs/promises";
-import path from "node:path";
-import os from "node:os";
-import { fileURLToPath } from "node:url";
-import z from "zod";
-import { errorResult, successResult } from "../util.js";
-import { analyzeCharacterFromMetadata } from "./character.js";
-import { ensureSafePath } from "../aseprite/path.js";
-import { runAsepriteCommand } from "../aseprite/cli.js";
-import { runLuaScriptFile } from "../lua/cli.js";
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-const toolSchemas = createToolSchemas();
-export function createToolHandlers() {
-    const character_pipeline_analyze = async ({ inputFile }) => {
-        try {
-            const inputAbs = ensureSafePath(inputFile, { mustExist: true });
-            const tempJsonPath = path.join(os.tmpdir(), `${inputFile}-analyze-${Date.now()}.json`);
-            const args = [
-                "--batch",
-                `"${inputAbs}"`,
-                "--data",
-                `"${tempJsonPath}"`,
-                "--list-tags",
-                "--list-layers"
-            ];
-            const result = await runAsepriteCommand(args);
-            const metaJson = await fs.readFile(tempJsonPath, "utf8");
-            const parsedMeta = JSON.parse(metaJson);
-            const analysis = analyzeCharacterFromMetadata(inputAbs, parsedMeta);
-            return successResult("character_pipeline_analyze", {
-                command: result.command,
-                inputFile: inputAbs,
-                analysis,
-                stdout: result.stdout.trim(),
-                stderr: result.stderr.trim(),
-            });
-        }
-        catch (err) {
-            return errorResult("character_pipeline_analyze", `Character analysis failed: ${err instanceof Error ? err.message : String(err)}`);
-        }
-    };
-    const character_pipeline_normalize = async ({ inputFile, saveOutput, targetMs, autoCrop }) => {
-        try {
-            const inputAbs = ensureSafePath(inputFile, { mustExist: true });
-            const baseDir = path.dirname(inputAbs);
-            const baseName = path.basename(inputAbs, path.extname(inputAbs));
-            const outputPath = saveOutput ??
-                path.join(baseDir, `${baseName}_normalized.aseprite`);
-            const outputAbs = ensureSafePath(outputPath, { mustExist: false });
-            const targetDuration = targetMs ?? 100;
-            const autoCropEnabled = autoCrop ?? true;
-            // Lua templates are in the source directory, reference from project root
-            const luaScriptPath = path.join(process.cwd(), "src", "lua", "templates", "character_normalize.lua");
-            const result = await runLuaScriptFile(luaScriptPath, {
-                inputFile: inputAbs,
-                saveOutput: outputAbs,
-                targetMs: targetDuration,
-                autoCrop: autoCropEnabled
-            });
-            if (result.timedOut) {
-                return errorResult("character_pipeline_normalize", "Lua script timed out while normalizing character");
-            }
-            return successResult("character_pipeline_normalize", {
-                command: result.command,
-                inputFile: inputAbs,
-                outputFile: outputAbs,
-                targetMs: targetDuration,
-                autoCrop: autoCropEnabled,
-                stdout: result.stdout.trim(),
-                stderr: result.stderr.trim(),
-            });
-        }
-        catch (err) {
-            return errorResult("character_pipeline_normalize", `Character normalization failed: ${err instanceof Error ? err.message : String(err)}`);
-        }
-    };
-    const character_pipeline_export = async ({ inputFile, exportDir, sheetType = "packed", format = "json-hash" }) => {
-        try {
-            const inputAbs = ensureSafePath(inputFile, { mustExist: true });
-            const exportDirAbs = ensureSafePath(exportDir, { mustExist: false });
-            await fs.mkdir(exportDirAbs, { recursive: true });
-            const tempJsonPath = path.join(os.tmpdir(), `${inputFile}-export-${Date.now()}.json`);
-            const metaArgs = [
-                "--batch",
-                `"${inputAbs}"`,
-                "--data",
-                `"${tempJsonPath}"`,
-                "--list-tags"
-            ];
-            await runAsepriteCommand(metaArgs);
-            const metaJson = await fs.readFile(tempJsonPath, "utf8");
-            const parsedMeta = JSON.parse(metaJson);
-            const tags = parsedMeta.meta.frameTags ?? [];
-            if (tags.length === 0) {
-                return errorResult("character_pipeline_export", "No tags found in sprite. Define animation tags before export.");
-            }
-            const baseName = path.basename(inputAbs, path.extname(inputAbs));
-            const generated = [];
-            for (const tag of tags) {
-                const tagName = tag.name;
-                const safeTag = tagName.toLowerCase();
-                const pngPath = path.join(exportDirAbs, `${baseName}_${safeTag}.png`);
-                const jsonPath = path.join(exportDirAbs, `${baseName}_${safeTag}.json`);
-                const args = [
-                    "--batch",
-                    `"${inputAbs}"`,
-                    "--tag",
-                    `"${tagName}"`,
-                    "--sheet",
-                    `"${pngPath}"`,
-                    "--data",
-                    `"${jsonPath}"`,
-                    "--sheet-type",
-                    sheetType,
-                    "--format",
-                    format
-                ];
-                await runAsepriteCommand(args);
-                generated.push({
-                    tag: tagName,
-                    png: pngPath,
-                    json: jsonPath,
-                    frames: tag.to - tag.from + 1
-                });
-            }
-            return successResult("character_pipeline_export", {
-                inputFile: inputAbs,
-                exportDir: exportDirAbs,
-                sheetType,
-                format,
-                generated,
-            });
-        }
-        catch (err) {
-            return errorResult("character_pipeline_export", `Character export failed: ${err instanceof Error ? err.message : String(err)}`);
-        }
-    };
-    const character_pipeline_build = async ({ inputFile, tempOutput, exportDir, normalizeOption = { targetMs: 100, autoCrop: true }, exportOption = { sheetType: "packed", format: "json-hash" } }) => {
-        try {
-            const inputAbs = ensureSafePath(inputFile, { mustExist: true });
-            const baseDir = path.dirname(inputAbs);
-            const baseName = path.basename(inputAbs, path.extname(inputAbs));
-            const normalizedOutput = tempOutput ??
-                path.join(baseDir, `${baseName}_normalized.aseprite`);
-            const exportDirAbs = ensureSafePath(exportDir, { mustExist: false });
-            const analyzeResponse = await character_pipeline_analyze({ inputFile: inputAbs }, {});
-            const analyzeContent = analyzeResponse.content[0];
-            const analyzeParsed = JSON.parse(analyzeContent.text);
-            if (!analyzeParsed.success) {
-                return errorResult("character_pipeline_build", analyzeParsed.error);
-            }
-            const normalizeResponse = await character_pipeline_normalize({
-                inputFile: inputAbs,
-                saveOutput: normalizedOutput,
-                targetMs: normalizeOption.targetMs,
-                autoCrop: normalizeOption.autoCrop,
-            }, {});
-            const normalizeContent = normalizeResponse.content[0];
-            const normalizeParsed = JSON.parse(normalizeContent.text);
-            if (!normalizeParsed.success) {
-                return errorResult("character_pipeline_build", normalizeParsed.error);
-            }
-            const exportResponse = await character_pipeline_export({
-                inputFile: normalizedOutput,
-                exportDir: exportDirAbs,
-                sheetType: exportOption.sheetType,
-                format: exportOption.format,
-            }, {});
-            const exportContent = exportResponse.content[0];
-            const exportParsed = JSON.parse(exportContent.text);
-            if (!exportParsed.success) {
-                return errorResult("character_pipeline_build", exportParsed.error);
-            }
-            return successResult("character_pipeline_build", {
-                inputFile: inputAbs,
-                normalizedFile: normalizedOutput,
-                exportDir: exportDirAbs,
-                analyze: analyzeParsed.result,
-                normalize: normalizeParsed.result,
-                export: exportParsed.result,
-            });
-        }
-        catch (err) {
-            return errorResult("character_pipeline_build", `Character pipeline failed: ${err instanceof Error ? err.message : String(err)}`);
-        }
-    };
-    return {
-        character_pipeline_analyze,
-        character_pipeline_normalize,
-        character_pipeline_export,
-        character_pipeline_build,
-    };
-}
-export function createToolSchemas() {
-    return {
-        character_pipeline_analyze: z.object({
-            inputFile: z.string(),
-        }),
-        character_pipeline_normalize: z.object({
-            inputFile: z.string(),
-            saveOutput: z.string().optional(),
-            targetMs: z.number().optional(),
-            autoCrop: z.boolean().optional(),
-        }),
-        character_pipeline_export: z.object({
-            inputFile: z.string(),
-            exportDir: z.string(),
-            sheetType: z.enum(["packed", "rows"]).optional(),
-            format: z.enum(["json-hash", "json-array"]).optional(),
-        }),
-        character_pipeline_build: z.object({
-            inputFile: z.string(),
-            tempOutput: z.string().optional(),
-            exportDir: z.string(),
-            normalizeOption: z.object({
-                targetMs: z.number().optional(),
-                autoCrop: z.boolean().optional(),
-            }).optional(),
-            exportOption: z.object({
-                sheetType: z.enum(["packed", "rows"]).optional(),
-                format: z.enum(["json-hash", "json-array"]).optional(),
-            }).optional(),
-        }),
-    };
-}

package/build/server.js

@@ -1,177 +0,0 @@
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import * as z from "zod/v4";
-import { readFileSync as readFileSyncNode } from "node:fs";
-import { resolveAsepritePath as resolveAsepritePathDefault } from "./aseprite/env.js";
-import { runAsepriteCommand as runAsepriteCommandDefault } from "./aseprite/cli.js";
-import { ensureSafePath as ensureSafePathDefault } from "./aseprite/path.js";
-import { errorResult as errorResultDefault, successResult as successResultDefault } from "./util.js";
-export function createServer(deps = {}) {
-    const d = {
-        resolveAsepritePath: resolveAsepritePathDefault,
-        runAsepriteCommand: runAsepriteCommandDefault,
-        ensureSafePath: ensureSafePathDefault,
-        readFileSync: readFileSyncNode,
-        successResult: successResultDefault,
-        errorResult: errorResultDefault,
-        ...deps,
-    };
-    const server = new McpServer({
-        name: "aseprite-mcp",
-        version: "0.1.0",
-    });
-    const tools = new Map();
-    tools.set("aseprite_check_environment", server.registerTool("aseprite_check_environment", {
-        description: "Check the environment of Aseprite",
-        inputSchema: undefined,
-        outputSchema: undefined,
-    }, async () => {
-        try {
-            const asepritePath = await d.resolveAsepritePath();
-            const { stdout: version } = await d.runAsepriteCommand(["--version"]);
-            return d.successResult("aseprite_check_environment", {
-                path: asepritePath,
-                version,
-            });
-        }
-        catch (e) {
-            return d.errorResult("aseprite_check_environment", e instanceof Error ? e.message : String(e));
-        }
-    }));
-    tools.set("aseprite_export_sheet", server.registerTool("aseprite_export_sheet", {
-        description: "Export Aseprite file to sprite sheet image",
-        inputSchema: z.object({
-            inputFile: z.string(),
-            outputSheet: z.string(),
-            sheetType: z.enum(["rows", "columns", "packed"]).optional().default("packed"),
-            dataFile: z.string().optional(),
-            tag: z.string().optional(),
-        }),
-        outputSchema: z.object({
-            content: z.array(z.object({
-                type: z.literal("text"),
-                text: z.string(),
-            })),
-        }),
-    }, async ({ inputFile, outputSheet, sheetType, dataFile, tag }) => {
-        try {
-            const inputAbsPath = d.ensureSafePath(inputFile, { mustExist: true });
-            const sheetAbsPath = d.ensureSafePath(outputSheet, { createDirIfNeeded: true });
-            const dataAbsPath = dataFile
-                ? d.ensureSafePath(dataFile, { createDirIfNeeded: true })
-                : undefined;
-            const args = [
-                "--batch",
-                `"${inputAbsPath}"`,
-                "--sheet",
-                `"${sheetAbsPath}"`,
-                "--sheet-type",
-                sheetType,
-            ];
-            if (tag)
-                args.push("--tag", `"${tag}"`);
-            if (dataAbsPath)
-                args.push("--data", `"${dataAbsPath}"`);
-            const result = await d.runAsepriteCommand(args);
-            return d.successResult("aseprite_export_sheet", {
-                command: result.command,
-                inputFile: inputAbsPath,
-                outputSheet: sheetAbsPath,
-                sheetType,
-                dataFile: dataAbsPath ? dataAbsPath : undefined,
-                tag: tag ? tag : undefined,
-                stdout: result.stdout.trim(),
-                stderr: result.stderr.trim(),
-            });
-        }
-        catch (e) {
-            return d.errorResult("aseprite_export_sheet", e instanceof Error ? e.message : String(e));
-        }
-    }));
-    tools.set("aseprite_export_frames", server.registerTool("aseprite_export_frames", {
-        description: "Export each frame of Aseprite file",
-        inputSchema: z.object({
-            inputFile: z.string(),
-            outputPattern: z.string(),
-            tag: z.string().optional(),
-        }),
-        outputSchema: z.object({
-            content: z.array(z.object({
-                type: z.literal("text"),
-                text: z.string(),
-            })),
-        }),
-    }, async ({ inputFile, outputPattern, tag }) => {
-        try {
-            const inputAbsPath = d.ensureSafePath(inputFile, { mustExist: true });
-            const outputAbsPath = d.ensureSafePath(outputPattern, { createDirIfNeeded: true });
-            const args = [
-                "--batch",
-                `"${inputAbsPath}"`,
-                "--save-as",
-                `"${outputAbsPath}"`,
-            ];
-            if (tag)
-                args.push("--tag", `"${tag}"`);
-            const result = await d.runAsepriteCommand(args);
-            return d.successResult("aseprite_export_frames", {
-                command: result.command,
-                inputFile: inputAbsPath,
-                outputPattern: outputAbsPath,
-                tag: tag ? tag : undefined,
-                stdout: result.stdout.trim(),
-                stderr: result.stderr.trim(),
-            });
-        }
-        catch (e) {
-            return d.errorResult("aseprite_export_frames", e instanceof Error ? e.message : String(e));
-        }
-    }));
-    tools.set("aseprite_export_metadata", server.registerTool("aseprite_export_metadata", {
-        description: "Export metadata json from Aseprite file",
-        inputSchema: z.object({
-            inputFile: z.string(),
-            dataFile: z.string(),
-            format: z.string().optional(),
-        }),
-        outputSchema: z.object({
-            content: z.array(z.object({
-                type: z.literal("text"),
-                text: z.string(),
-            })),
-        }),
-    }, async ({ inputFile, dataFile, format }) => {
-        try {
-            const inputAbsPath = d.ensureSafePath(inputFile, { mustExist: true });
-            const dataAbsPath = d.ensureSafePath(dataFile, { createDirIfNeeded: true });
-            const args = [
-                "--batch",
-                `"${inputAbsPath}"`,
-                "--data",
-                `"${dataAbsPath}"`,
-            ];
-            if (format)
-                args.push("--format", `"${format}"`);
-            const result = await d.runAsepriteCommand(args);
-            let metaText = "";
-            try {
-                metaText = d.readFileSync(dataAbsPath, "utf8");
-            }
-            catch (e) {
-                metaText = `Failed to read metadata: ${e instanceof Error ? e.message : String(e)}`;
-            }
-            return d.successResult("aseprite_export_metadata", {
-                command: result.command,
-                inputFile: inputAbsPath,
-                dataFile: dataAbsPath,
-                format: format ? format : undefined,
-                stdout: result.stdout.trim(),
-                stderr: result.stderr.trim(),
-                metadata: metaText,
-            });
-        }
-        catch (e) {
-            return d.errorResult("aseprite_export_metadata", e instanceof Error ? e.message : String(e));
-        }
-    }));
-    return { server, tools };
-}

package/build/tools.js

@@ -1,145 +0,0 @@
-import z from "zod";
-import { resolveAsepritePath } from "./aseprite/env.js";
-import { runAsepriteCommand } from "./aseprite/cli.js";
-import { errorResult, successResult } from "./util.js";
-import { ensureSafePath } from "./aseprite/path.js";
-import { readFileSync } from "node:fs";
-const toolSchemas = createToolSchemas();
-export function createToolHandlers() {
-    const aseprite_check_environment = async () => {
-        try {
-            const asepritePath = await resolveAsepritePath();
-            const { stdout: version } = await runAsepriteCommand(["--version"]);
-            return successResult("aseprite_check_environment", { path: asepritePath, version });
-        }
-        catch (e) {
-            return errorResult("aseprite_check_environment", e instanceof Error ? e.message : String(e));
-        }
-    };
-    const aseprite_export_sheet = async ({ inputFile, outputSheet, sheetType = "packed", dataFile, tag }) => {
-        try {
-            const inputAbsPath = ensureSafePath(inputFile, { mustExist: true });
-            const sheetAbsPath = ensureSafePath(outputSheet, { createDirIfNeeded: true });
-            const dataAbsPath = dataFile ? ensureSafePath(dataFile, { createDirIfNeeded: true }) : undefined;
-            const args = [
-                "--batch",
-                `"${inputAbsPath}"`,
-                "--sheet",
-                `"${sheetAbsPath}"`,
-                "--sheet-type",
-                sheetType
-            ];
-            if (tag)
-                args.push("--tag", `"${tag}"`);
-            if (dataAbsPath)
-                args.push("--data", `"${dataAbsPath}"`);
-            const result = await runAsepriteCommand(args);
-            return successResult("aseprite_export_sheet", {
-                command: result.command,
-                inputFile: inputAbsPath,
-                outputSheet: sheetAbsPath,
-                sheetType,
-                dataFile: dataAbsPath ? dataAbsPath : undefined,
-                tag: tag ? tag : undefined,
-                stdout: result.stdout.trim(),
-                stderr: result.stderr.trim(),
-            });
-        }
-        catch (e) {
-            return errorResult("aseprite_export_sheet", e instanceof Error ? e.message : String(e));
-        }
-    };
-    const aseprite_export_frames = async ({ inputFile, outputPattern, tag }) => {
-        try {
-            const inputAbsPath = ensureSafePath(inputFile, { mustExist: true });
-            const outputAbsPath = ensureSafePath(outputPattern, { createDirIfNeeded: true });
-            const args = [
-                "--batch",
-                `"${inputAbsPath}"`,
-                "--save-as",
-                `"${outputAbsPath}"`
-            ];
-            if (tag)
-                args.push("--tag", `"${tag}"`);
-            const result = await runAsepriteCommand(args);
-            return successResult("aseprite_export_frames", {
-                command: result.command,
-                inputFile: inputAbsPath,
-                outputPattern: outputAbsPath,
-                tag: tag ? tag : undefined,
-                stdout: result.stdout.trim(),
-                stderr: result.stderr.trim(),
-            });
-        }
-        catch (e) {
-            return errorResult("aseprite_export_frames", e instanceof Error ? e.message : String(e));
-        }
-    };
-    const aseprite_export_metadata = async ({ inputFile, dataFile, format }) => {
-        try {
-            const inputAbsPath = ensureSafePath(inputFile, { mustExist: true });
-            const dataAbsPath = ensureSafePath(dataFile, { createDirIfNeeded: true });
-            const args = [
-                "--batch",
-                `"${inputAbsPath}"`,
-                "--data",
-                `"${dataAbsPath}"`
-            ];
-            if (format)
-                args.push("--format", `"${format}"`);
-            const result = await runAsepriteCommand(args);
-            let metaText = "";
-            try {
-                metaText = readFileSync(dataAbsPath, "utf8");
-            }
-            catch (e) {
-                metaText = `Failed to read metadata: ${e instanceof Error ? e.message : String(e)}`;
-            }
-            return successResult("aseprite_export_metadata", {
-                command: result.command,
-                inputFile: inputAbsPath,
-                dataFile: dataAbsPath,
-                format: format ? format : undefined,
-                stdout: result.stdout.trim(),
-                stderr: result.stderr.trim(),
-                metadata: metaText,
-            });
-        }
-        catch (e) {
-            return errorResult("aseprite_export_metadata", e instanceof Error ? e.message : String(e));
-        }
-    };
-    return {
-        aseprite_check_environment,
-        aseprite_export_sheet,
-        aseprite_export_frames,
-        aseprite_export_metadata
-    };
-}
-export function createToolSchemas() {
-    return {
-        aseprite_export_sheet: z.object({
-            inputFile: z.string(),
-            outputSheet: z.string(),
-            sheetType: z.enum(["rows", "columns", "packed"]).optional().default("packed"),
-            dataFile: z.string().optional(),
-            tag: z.string().optional(),
-        }),
-        aseprite_export_frames: z.object({
-            inputFile: z.string(),
-            outputPattern: z.string(),
-            tag: z.string().optional(),
-        }),
-        aseprite_export_metadata: z.object({
-            inputFile: z.string(),
-            dataFile: z.string(),
-            format: z.string().optional(),
-        }),
-        aseprite_output_result: z.object({
-            content: z.array(z.object({
-                type: z.literal("text"),
-                text: z.string(),
-            })),
-        }),
-    };
-}