@iborymagic/aseprite-mcp 0.1.0

package/README.md

@@ -0,0 +1,61 @@
+# Aseprite-MCP
+This server automates Aseprite workflows using the Model Context Protocol (MCP).  
+It enables AI, chat assistants, and automation pipelines to directly execute Aseprite tasks such as sprite sheet export, frame extraction, and metadata output.  
+*Lua-based automation and high-level sprite/tile generation features are not included yet.  
+*Aseprite must be installed in order to use this MCP server.  
+
+## How to use
+1) Run directly with npx
+```bash
+npx -y aseprite-mcp
+```
+
+2) Local Build & Run (for development)
+```bash
+npm install
+npm run build
+npx aseprite-mcp
+```
+
+### Using with ChatGPT
+Add the following to your mcp.json
+```json
+{
+  "servers": {
+    "aseprite-mcp": {
+      "command": "npx",
+      "args": ["-y", "aseprite-mcp"]
+    }
+  }
+}
+```
+
+### Using with Claude
+Add the following to your servers.json
+```json
+{
+  "aseprite-mcp": {
+    "command": "npx",
+    "args": ["-y", "aseprite-mcp"]
+  }
+}
+```
+
+### Using with Cursor
+Add the following to your .cursor.json
+```json
+{
+  "mcpServers": {
+    "aseprite-mcp": {
+      "command": "npx",
+      "args": ["-y", "aseprite-mcp"]
+    }
+  }
+}
+```
+
+## Tools
+- `aseprite_check_environment`: Checks Aseprite installation status, executable path, and version
+- `aseprite_export_sheet`: Exports a sprite sheet as PNG + JSON
+- `aseprite_export_frames`: Exports each animation frame as an individual PNG file
+- `aseprite_export_metadata`: Exports Aseprite metadata in JSON format

package/build/aseprite/cli.js

@@ -0,0 +1,15 @@
+import { exec } from "node:child_process";
+import { promisify } from "node:util";
+import { resolveAsepritePath } from "./env.js";
+const execAsync = promisify(exec);
+export async function runAsepriteCommand(args) {
+    const path = await resolveAsepritePath();
+    const command = `"${path}" ${args.join(" ")}`;
+    try {
+        const { stdout, stderr } = await execAsync(command);
+        return { command, stdout, stderr };
+    }
+    catch (error) {
+        throw new Error(`Failed to run Aseprite command: ${command}\n${error instanceof Error ? error.message : String(error)}`);
+    }
+}

package/build/aseprite/env.js

@@ -0,0 +1,120 @@
+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 candidates = {
+    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 [];
+}
+export async function resolveAsepritePath() {
+    try {
+        const platform = process.platform;
+        const cmd = platform === "win32" ? "where aseprite" : "which aseprite";
+        const { stdout } = await execAsync(cmd);
+        const found = stdout.split("\n")[0].trim();
+        if (found && existsSync(found))
+            return found;
+    }
+    catch { }
+    const defaults = candidates[process.platform] ??
+        [];
+    for (const path of defaults) {
+        if (existsSync(path))
+            return path;
+    }
+    const steamPaths = getSteamAsepritePaths();
+    for (const path of steamPaths) {
+        if (existsSync(path)) {
+            return path;
+        }
+    }
+    throw new Error(`Aseprite not found. Please install it or add to PATH.\nDetected OS: ${process.platform}`);
+}

package/build/aseprite/path.js

@@ -0,0 +1,33 @@
+import { existsSync, mkdirSync, statSync } from "node:fs";
+import path from "node:path";
+export function normalizePath(p) {
+    if (!p || typeof p !== "string") {
+        throw new Error("Path must be a non-empty string");
+    }
+    return path.resolve(p);
+}
+export function mkdirSafe(dir) {
+    try {
+        mkdirSync(dir, { recursive: true });
+    }
+    catch (err) {
+        throw new Error(`Failed to create directory: ${dir}`);
+    }
+}
+export function ensureSafePath(p, options = {}) {
+    const absPath = normalizePath(p);
+    const parentDir = path.dirname(absPath);
+    if (options.mustExist) {
+        if (!existsSync(absPath)) {
+            throw new Error(`File does not exist: ${absPath}`);
+        }
+        const stat = statSync(absPath);
+        if (!stat.isFile()) {
+            throw new Error(`Not a file: ${absPath}`);
+        }
+    }
+    if (options.createDirIfNeeded) {
+        mkdirSafe(parentDir);
+    }
+    return absPath;
+}

package/build/aseprite/steam.js

@@ -0,0 +1,96 @@
+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/index.js

@@ -0,0 +1,39 @@
+#!/usr/bin/env node
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { createToolHandlers, createToolSchemas } from "./tools.js";
+const server = new McpServer({
+    name: "aseprite-mcp",
+    version: "0.1.0"
+});
+const toolSchemas = createToolSchemas();
+const toolHandlers = createToolHandlers();
+server.registerTool("aseprite_check_environment", {
+    description: "Check the environment of Aseprite",
+    inputSchema: undefined,
+    outputSchema: undefined,
+}, toolHandlers.aseprite_check_environment);
+server.registerTool("aseprite_export_sheet", {
+    description: "Export Aseprite file to sprite sheet image",
+    inputSchema: toolSchemas.aseprite_export_sheet,
+    outputSchema: toolSchemas.aseprite_output_result,
+}, toolHandlers.aseprite_export_sheet);
+server.registerTool("aseprite_export_frames", {
+    description: "Export each frame of Aseprite file",
+    inputSchema: toolSchemas.aseprite_export_frames,
+    outputSchema: toolSchemas.aseprite_output_result,
+}, toolHandlers.aseprite_export_frames);
+server.registerTool("aseprite_export_metadata", {
+    description: "Export metadata json from Aseprite file",
+    inputSchema: toolSchemas.aseprite_export_metadata,
+    outputSchema: toolSchemas.aseprite_output_result,
+}, toolHandlers.aseprite_export_metadata);
+async function main() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.log("Aseprite MCP server started");
+}
+main().catch(err => {
+    console.error("MCP Error:", err);
+    process.exit(1);
+});

package/build/localtest.js

@@ -0,0 +1,16 @@
+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/server.js

@@ -0,0 +1,177 @@
+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

@@ -0,0 +1,145 @@
+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(),
+            })),
+        }),
+    };
+}

package/build/util.js

@@ -0,0 +1,28 @@
+export function successResult(tool, result) {
+    return {
+        content: [
+            {
+                type: "text",
+                text: JSON.stringify({
+                    success: true,
+                    tool,
+                    result,
+                }, null, 2)
+            }
+        ]
+    };
+}
+export function errorResult(tool, error) {
+    return {
+        content: [
+            {
+                type: "text",
+                text: JSON.stringify({
+                    success: false,
+                    tool,
+                    error,
+                }, null, 2)
+            }
+        ]
+    };
+}

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@iborymagic/aseprite-mcp",
+  "version": "0.1.0",
+  "description": "MCP server for using Aseprite API",
+  "main": "index.js",
+  "type": "module",
+  "bin": {
+    "aseprite-mcp": "./build/index.js"
+  },
+  "files": [
+    "build"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "start": "node build/index.js",
+    "dev": "npm run build && npm run start",
+    "test": "jest --runInBand --slient=false"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.25.1",
+    "zod": "^4.2.1"
+  },
+  "devDependencies": {
+    "@types/jest": "^30.0.0",
+    "@types/node": "^25.0.0",
+    "jest": "^30.2.0",
+    "ts-jest": "^29.4.6",
+    "typescript": "^5.0.0"
+  },
+  "author": "iborymagic",
+  "license": "MIT"
+}