@iborymagic/aseprite-mcp 0.4.0 → 0.4.2

package/README.md

@@ -16,6 +16,14 @@ Supports fundamental Aseprite export workflow:
 Adds deeper control using Aseprite Lua scripting, enabling safe AI-driven editing operations such as:
 - `aseprite_list_lua_templates`: Lists available Lua templates
 - Predefined safe Lua automation(templates)
+  - `get_active_sprite_info`: Provides basic information about the currently active sprite
+  - `get_frame_info`: Inspects the animation timeline and frame structure of the active sprite
+  - `get_layer_list`: Returns a full structural overview of all layers in the active sprite, including groups
+  - `get_tag_list`: Lists all animation tags defined in the active sprite
+  - `get_is_layer_exists`: Checks whether a layer with a specific name exists
+  - `get_is_tag_exists`: Checks whether a specific animation tag exists
+  - `get_palette_info`: Inspects the current palette of the active sprite
+  - `get_selection_bounds`: Inspects the current selection state and its bounds
   - `remove_layer_by_name`: Removing specific layers
   - `recolor_palette`: Palette recoloring
   - `normalize_animation_speed`: Normalizing animation speed

package/build/aseprite/cli.js

@@ -11,12 +11,7 @@ export async function runAsepriteCommand(args, timeout = 10_000) {
     }
     catch (error) {
         if (error.killed === true && error.code === null) {
-            return {
-                command,
-                stdout: "",
-                stderr: "Aseprite command timed out",
-                timedOut: true
-            };
+            throw new Error(`Aseprite command timed out: ${command}`);
         }
         throw new Error(`Failed to run Aseprite command: ${command}\n${error instanceof Error ? error.message : String(error)}`);
     }

package/build/aseprite/tools.js

@@ -34,15 +34,13 @@ export function createToolHandlers() {
             if (dataAbsPath)
                 args.push("--data", `"${dataAbsPath}"`);
             const result = await runAsepriteCommand(args);
-            return successResult("aseprite_export_sheet", {
+            return successResult("aseprite_export_sheet", result.stdout.trim(), {
                 command: result.command,
                 inputFile: inputAbsPath,
                 outputSheet: sheetAbsPath,
-                sheetType,
+                sheetType: sheetType,
                 dataFile: dataAbsPath ? dataAbsPath : undefined,
                 tag: tag ? tag : undefined,
-                stdout: result.stdout.trim(),
-                stderr: result.stderr.trim(),
             });
         }
         catch (e) {
@@ -62,13 +60,11 @@ export function createToolHandlers() {
             if (tag)
                 args.push("--tag", `"${tag}"`);
             const result = await runAsepriteCommand(args);
-            return successResult("aseprite_export_frames", {
+            return successResult("aseprite_export_frames", result.stdout.trim(), {
                 command: result.command,
                 inputFile: inputAbsPath,
                 outputPattern: outputAbsPath,
                 tag: tag ? tag : undefined,
-                stdout: result.stdout.trim(),
-                stderr: result.stderr.trim(),
             });
         }
         catch (e) {
@@ -95,13 +91,11 @@ export function createToolHandlers() {
             catch (e) {
                 metaText = `Failed to read metadata: ${e instanceof Error ? e.message : String(e)}`;
             }
-            return successResult("aseprite_export_metadata", {
+            return successResult("aseprite_export_metadata", result.stdout.trim(), {
                 command: result.command,
                 inputFile: inputAbsPath,
                 dataFile: dataAbsPath,
-                format: format ? format : undefined,
-                stdout: result.stdout.trim(),
-                stderr: result.stderr.trim(),
+                format,
                 metadata: metaText,
             });
         }

package/build/index.js

@@ -5,14 +5,28 @@ import { createToolHandlers as createAsepriteToolHandlers, createToolSchemas as
 import { createToolHandlers as createLuaToolHandlers, createToolSchemas as createLuaToolSchemas } from "./lua/tools.js";
 import path from "node:path";
 import { readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
 let version;
 try {
-    const packageJsonPath = path.join(process.cwd(), "package.json");
+    // Get the directory of the current file (build/index.js)
+    const __filename = fileURLToPath(import.meta.url);
+    const __dirname = path.dirname(__filename);
+    // Go up one level from build/ to package root
+    const packageJsonPath = path.join(__dirname, "..", "package.json");
     const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf8"));
     version = packageJson.version;
 }
 catch (error) {
-    console.error("Failed to read package.json:", error);
+    // Fallback: try process.cwd() if the above fails
+    try {
+        const packageJsonPath = path.join(process.cwd(), "package.json");
+        const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+        version = packageJson.version;
+    }
+    catch (fallbackError) {
+        // If both fail, use default version
+        version = undefined;
+    }
 }
 const server = new McpServer({
     name: "aseprite-mcp",

package/build/lua/tools.js

@@ -28,9 +28,6 @@ export function createToolHandlers() {
             throw new Error(`Missing required params: ${missing.join(", ")}`);
         }
         const result = await runLuaScriptFile(template.scriptPath, params);
-        if (result.timedOut) {
-            throw new Error(`Lua script timed out while executing template: ${templateId}`);
-        }
         const stderrTrimmed = result.stderr.trim();
         const stdoutTrimmed = result.stdout.trim();
         if (stderrTrimmed && stderrTrimmed.includes("ERROR:")) {
@@ -54,10 +51,9 @@ export function createToolHandlers() {
                     saveOutput: ensureSafePath(saveOutput, { createDirIfNeeded: true })
                 }
             });
-            return successResult("auto_crop_transparent", {
-                command: result.command,
-                stdout: result.stdout,
-                stderr: result.stderr
+            return successResult("auto_crop_transparent", result.stdout, {
+                inputFile: inputFile,
+                saveOutput: saveOutput,
             });
         }
         catch (err) {
@@ -73,10 +69,10 @@ export function createToolHandlers() {
                     saveOutput: ensureSafePath(saveOutput, { createDirIfNeeded: true })
                 }
             });
-            return successResult("merge_visible_layers", {
+            return successResult("merge_visible_layers", result.stdout, {
                 command: result.command,
-                stdout: result.stdout,
-                stderr: result.stderr
+                inputFile: inputFile,
+                saveOutput: saveOutput,
             });
         }
         catch (err) {
@@ -93,10 +89,11 @@ export function createToolHandlers() {
                     targetDuration
                 }
             });
-            return successResult("normalize_animation_speed", {
+            return successResult("normalize_animation_speed", result.stdout, {
                 command: result.command,
-                stdout: result.stdout,
-                stderr: result.stderr
+                inputFile: inputFile,
+                saveOutput: saveOutput,
+                targetDuration: targetDuration,
             });
         }
         catch (err) {
@@ -113,10 +110,11 @@ export function createToolHandlers() {
                     inputFile
                 }
             });
-            return successResult("recolor_palette", {
+            return successResult("recolor_palette", result.stdout, {
                 command: result.command,
-                stdout: result.stdout,
-                stderr: result.stderr
+                inputFile: inputFile,
+                saveOutput: saveOutput,
+                mapping: mapping,
             });
         }
         catch (err) {
@@ -125,6 +123,15 @@ export function createToolHandlers() {
     };
     const remove_layer_by_name = async ({ layerName, saveOutput, inputFile }) => {
         try {
+            const getIsLayerExistsResult = await get_is_layer_exists({
+                inputFile,
+                layerName
+            }, {});
+            const content = getIsLayerExistsResult.content[0];
+            const isLayerExist = JSON.parse(content.text).result === 'true';
+            if (!isLayerExist) {
+                return errorResult("remove_layer_by_name", `Layer not found: ${layerName}`);
+            }
             const result = await run_lua_template({
                 templateId: "remove_layer_by_name",
                 params: {
@@ -133,10 +140,11 @@ export function createToolHandlers() {
                     inputFile
                 }
             });
-            return successResult("remove_layer_by_name", {
+            return successResult("remove_layer_by_name", result.stdout, {
                 command: result.command,
-                stdout: result.stdout,
-                stderr: result.stderr
+                inputFile: inputFile,
+                layerName: layerName,
+                saveOutput: saveOutput,
             });
         }
         catch (err) {
@@ -145,6 +153,15 @@ export function createToolHandlers() {
     };
     const export_layer_only = async ({ layerName, outputDir, inputFile }) => {
         try {
+            const getIsLayerExistsResult = await get_is_layer_exists({
+                inputFile,
+                layerName
+            }, {});
+            const content = getIsLayerExistsResult.content[0];
+            const isLayerExist = JSON.parse(content.text).result === 'true';
+            if (!isLayerExist) {
+                return errorResult("export_layer_only", `Layer not found: ${layerName}`);
+            }
             const result = await run_lua_template({
                 templateId: "export_layer_only",
                 params: {
@@ -153,10 +170,11 @@ export function createToolHandlers() {
                     inputFile
                 }
             });
-            return successResult("export_layer_only", {
+            return successResult("export_layer_only", result.stdout, {
                 command: result.command,
-                stdout: result.stdout,
-                stderr: result.stderr
+                inputFile: inputFile,
+                layerName: layerName,
+                outputDir: outputDir,
             });
         }
         catch (err) {
@@ -165,6 +183,15 @@ export function createToolHandlers() {
     };
     const export_tag_frames = async ({ tag, outputDir, filenamePrefix, inputFile }) => {
         try {
+            const getIsTagExistsResult = await get_is_tag_exists({
+                inputFile,
+                tagName: tag
+            }, {});
+            const content = getIsTagExistsResult.content[0];
+            const isTagExist = JSON.parse(content.text).result === 'true';
+            if (!isTagExist) {
+                return errorResult("export_tag_frames", `Tag not found: ${tag}`);
+            }
             const result = await run_lua_template({
                 templateId: "export_tag_frames",
                 params: {
@@ -174,10 +201,12 @@ export function createToolHandlers() {
                     inputFile
                 }
             });
-            return successResult("export_tag_frames", {
+            return successResult("export_tag_frames", result.stdout, {
                 command: result.command,
-                stdout: result.stdout,
-                stderr: result.stderr
+                inputFile: inputFile,
+                tag: tag,
+                outputDir: outputDir,
+                filenamePrefix: filenamePrefix,
             });
         }
         catch (err) {
@@ -190,26 +219,11 @@ export function createToolHandlers() {
                 templateId: "get_is_layer_exists",
                 params: { layerName, inputFile }
             });
-            // Parse the boolean result from stdout
-            // Aseprite outputs Lua return values as JSON
-            const stdoutTrimmed = result.stdout.trim();
-            let exists;
-            if (stdoutTrimmed === "") {
-                // Empty stdout might mean false or error
-                exists = false;
-            }
-            else {
-                try {
-                    // Aseprite outputs Lua return values as JSON
-                    const parsed = JSON.parse(stdoutTrimmed);
-                    exists = parsed === true;
-                }
-                catch {
-                    // If not valid JSON, try string comparison
-                    exists = stdoutTrimmed.toLowerCase() === "true" || stdoutTrimmed === "1";
-                }
-            }
-            return successResult("get_is_layer_exists", exists);
+            return successResult("get_is_layer_exists", result.stdout, {
+                command: result.command,
+                inputFile: inputFile,
+                layerName: layerName,
+            });
         }
         catch (err) {
             return errorResult("get_is_layer_exists", `Execution failed: ${err instanceof Error ? err.message : String(err)}`);
@@ -221,26 +235,11 @@ export function createToolHandlers() {
                 templateId: "get_is_tag_exists",
                 params: { tagName, inputFile }
             });
-            // Parse the boolean result from stdout
-            // Aseprite outputs Lua return values as JSON
-            const stdoutTrimmed = result.stdout.trim();
-            let exists;
-            if (stdoutTrimmed === "") {
-                // Empty stdout might mean false or error
-                exists = false;
-            }
-            else {
-                try {
-                    // Aseprite outputs Lua return values as JSON
-                    const parsed = JSON.parse(stdoutTrimmed);
-                    exists = parsed === true;
-                }
-                catch {
-                    // If not valid JSON, try string comparison
-                    exists = stdoutTrimmed.toLowerCase() === "true" || stdoutTrimmed === "1";
-                }
-            }
-            return successResult("get_is_tag_exists", exists);
+            return successResult("get_is_tag_exists", result.stdout, {
+                command: result.command,
+                inputFile: inputFile,
+                tagName: tagName,
+            });
         }
         catch (err) {
             return errorResult("get_is_tag_exists", `Execution failed: ${err instanceof Error ? err.message : String(err)}`);
@@ -252,9 +251,10 @@ export function createToolHandlers() {
                 templateId: "get_palette_info",
                 params: { inputFile }
             });
-            // Parse the JSON result from stdout
-            const parsedResult = JSON.parse(result.stdout.trim());
-            return successResult("get_palette_info", parsedResult);
+            return successResult("get_palette_info", result.stdout, {
+                command: result.command,
+                inputFile: inputFile,
+            });
         }
         catch (err) {
             return errorResult("get_palette_info", `Execution failed: ${err instanceof Error ? err.message : String(err)}`);
@@ -266,9 +266,10 @@ export function createToolHandlers() {
                 templateId: "get_selection_bounds",
                 params: { inputFile }
             });
-            // Parse the JSON result from stdout
-            const parsedResult = JSON.parse(result.stdout.trim());
-            return successResult("get_selection_bounds", parsedResult);
+            return successResult("get_selection_bounds", result.stdout, {
+                command: result.command,
+                inputFile: inputFile,
+            });
         }
         catch (err) {
             return errorResult("get_selection_bounds", `Execution failed: ${err instanceof Error ? err.message : String(err)}`);
@@ -280,9 +281,10 @@ export function createToolHandlers() {
                 templateId: "get_tag_list",
                 params: { inputFile }
             });
-            // Parse the JSON result from stdout
-            const parsedResult = JSON.parse(result.stdout.trim());
-            return successResult("get_tag_list", parsedResult);
+            return successResult("get_tag_list", result.stdout, {
+                command: result.command,
+                inputFile: inputFile,
+            });
         }
         catch (err) {
             return errorResult("get_tag_list", `Execution failed: ${err instanceof Error ? err.message : String(err)}`);
@@ -294,9 +296,10 @@ export function createToolHandlers() {
                 templateId: "get_layer_list",
                 params: { inputFile }
             });
-            // Parse the JSON result from stdout
-            const parsedResult = JSON.parse(result.stdout.trim());
-            return successResult("get_layer_list", parsedResult);
+            return successResult("get_layer_list", result.stdout, {
+                command: result.command,
+                inputFile: inputFile,
+            });
         }
         catch (err) {
             return errorResult("get_layer_list", `Execution failed: ${err instanceof Error ? err.message : String(err)}`);
@@ -308,9 +311,10 @@ export function createToolHandlers() {
                 templateId: "get_frame_info",
                 params: { inputFile }
             });
-            // Parse the JSON result from stdout
-            const parsedResult = JSON.parse(result.stdout.trim());
-            return successResult("get_frame_info", parsedResult);
+            return successResult("get_frame_info", result.stdout, {
+                command: result.command,
+                inputFile: inputFile,
+            });
         }
         catch (err) {
             return errorResult("get_frame_info", `Execution failed: ${err instanceof Error ? err.message : String(err)}`);
@@ -322,9 +326,10 @@ export function createToolHandlers() {
                 templateId: "get_active_sprite_info",
                 params: { inputFile }
             });
-            // Parse the JSON result from stdout
-            const parsedResult = JSON.parse(result.stdout.trim());
-            return successResult("get_active_sprite_info", parsedResult);
+            return successResult("get_active_sprite_info", result.stdout, {
+                command: result.command,
+                inputFile: inputFile,
+            });
         }
         catch (err) {
             return errorResult("get_active_sprite_info", `Execution failed: ${err instanceof Error ? err.message : String(err)}`);
@@ -342,9 +347,6 @@ export function createToolHandlers() {
                 luaFilePath = tempPath;
             }
             const result = await runLuaScriptFile(luaFilePath, params);
-            if (result.timedOut) {
-                return errorResult("aseprite_run_lua_script", `Lua script timed out while executing script: ${luaFilePath}`);
-            }
             const stderrTrimmed = result.stderr.trim();
             const stdoutTrimmed = result.stdout.trim();
             if (stderrTrimmed && stderrTrimmed.includes("ERROR:")) {
@@ -353,10 +355,12 @@ export function createToolHandlers() {
             if (stdoutTrimmed && stdoutTrimmed.includes("ERROR:")) {
                 return errorResult("aseprite_run_lua_script", `Script execution failed: ${stdoutTrimmed}`);
             }
-            return successResult("aseprite_run_lua_script", {
+            return successResult("aseprite_run_lua_script", result.stdout, {
                 command: result.command,
-                stdout: stdoutTrimmed,
-                stderr: stderrTrimmed
+                inputFile: params.inputFile,
+                scriptPath: luaFilePath,
+                scriptContent: scriptContent,
+                params: params,
             });
         }
         catch (err) {

package/build/util.js

@@ -1,4 +1,4 @@
-export function successResult(tool, result) {
+export function successResult(tool, result, params) {
     return {
         content: [
             {
@@ -6,6 +6,7 @@ export function successResult(tool, result) {
                 text: JSON.stringify({
                     success: true,
                     tool,
+                    params: params ?? null,
                     result,
                 }, null, 2)
             }

package/package.json

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