indesign-cli 0.2.0__py3-none-any.whl

cli_anything/indesign/server/src/advanced/index.js

@@ -0,0 +1,76 @@
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { ListToolsRequestSchema, CallToolRequestSchema } from '@modelcontextprotocol/sdk/types.js';
+import { advancedTemplateToolDefinitions } from '../types/toolDefinitionsAdvancedTemplates.js';
+import { AdvancedTemplateHandlers } from '../handlers/advancedTemplateHandlers.js';
+import { formatErrorResponse } from '../utils/stringUtils.js';
+
+const TOOL_MAP = {
+    list_template_blueprints: AdvancedTemplateHandlers.listTemplateBlueprints,
+    inspect_template_blueprint: AdvancedTemplateHandlers.inspectTemplate,
+    create_page_with_template: AdvancedTemplateHandlers.createPageWithTemplate,
+    get_page_information: AdvancedTemplateHandlers.getPageInformation,
+    populate_template_slots: AdvancedTemplateHandlers.fillTemplateFromSlots,
+    run_jsx_file: AdvancedTemplateHandlers.runJsxFile,
+};
+
+class AdvancedTemplateServer {
+    constructor() {
+        this.server = new Server(
+            {
+                name: 'indesign-template-orchestrator',
+                version: '0.1.0'
+            },
+            {
+                capabilities: {
+                    tools: {}
+                }
+            }
+        );
+
+        this.server.setRequestHandler(ListToolsRequestSchema, async () => ({
+            tools: advancedTemplateToolDefinitions.map((tool) => ({
+                name: tool.name,
+                description: tool.description,
+                inputSchema: tool.inputSchema
+            }))
+        }));
+
+        this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
+            const { name, arguments: args } = request.params;
+            const handler = TOOL_MAP[name];
+            if (!handler) {
+                const payload = formatErrorResponse(`Tool not found: ${name}`, 'Advanced Template Tool Call');
+                return {
+                    content: [{ type: 'text', text: JSON.stringify(payload, null, 2) }]
+                };
+            }
+            try {
+                const result = await handler(args || {});
+                return {
+                    content: [{ type: 'text', text: JSON.stringify(result, null, 2) }]
+                };
+            } catch (error) {
+                const payload = formatErrorResponse(error.message, `Advanced Template Tool '${name}'`);
+                return {
+                    content: [{ type: 'text', text: JSON.stringify(payload, null, 2) }]
+                };
+            }
+        });
+    }
+
+    async run() {
+        const transport = new StdioServerTransport();
+        await this.server.connect(transport);
+    }
+}
+
+async function main() {
+    const server = new AdvancedTemplateServer();
+    await server.run();
+}
+
+main().catch((error) => {
+    console.error('Failed to start advanced template server:', error);
+    process.exit(1);
+});

cli_anything/indesign/server/src/core/InDesignMCPServer.js

@@ -0,0 +1,273 @@
+/**
+ * Main InDesign MCP Server class
+ */
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { ListToolsRequestSchema, CallToolRequestSchema } from '@modelcontextprotocol/sdk/types.js';
+import { allToolDefinitions } from '../types/index.js';
+import {
+    BookHandlers,
+    DocumentHandlers,
+    ExportHandlers,
+    GraphicsHandlers,
+    GroupHandlers,
+    HelpHandlers,
+    MasterSpreadHandlers,
+    SpreadHandlers,
+    LayerHandlers,
+    PageHandlers,
+    PageItemHandlers,
+    StyleHandlers,
+    TextHandlers,
+    UtilityHandlers,
+    PresentationHandlers
+} from '../handlers/index.js';
+import { formatErrorResponse } from '../utils/stringUtils.js';
+
+export class InDesignMCPServer {
+    constructor() {
+        this.server = new Server(
+            {
+                name: 'indesign-server-complete',
+                version: '1.0.0',
+            },
+            {
+                capabilities: {
+                    tools: {},
+                },
+            }
+        );
+
+        this.setupToolHandlers();
+    }
+
+    setupToolHandlers() {
+        this.server.setRequestHandler(ListToolsRequestSchema, async () => ({
+            tools: allToolDefinitions,
+        }));
+
+        this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
+            const { name, arguments: args } = request.params;
+
+            try {
+                const result = await this.handleToolCall(name, args);
+                return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+            } catch (error) {
+                return { content: [{ type: 'text', text: `Error: ${error.message}` }] };
+            }
+        });
+    }
+
+    async handleToolCall(name, args) {
+        // Document Management
+        switch (name) {
+            case 'get_document_info': return await DocumentHandlers.getDocumentInfo();
+            case 'create_document': return await DocumentHandlers.createDocument(args);
+            case 'open_document': return await DocumentHandlers.openDocument(args);
+            case 'save_document': return await DocumentHandlers.saveDocument(args);
+            case 'close_document': return await DocumentHandlers.closeDocument();
+
+            // Document Advanced Tools
+            case 'preflight_document': return await DocumentHandlers.preflightDocument(args);
+            case 'zoom_to_page': return await DocumentHandlers.zoomToPage(args);
+            case 'data_merge': return await DocumentHandlers.dataMerge(args);
+
+            // Document Elements & Styles
+            case 'get_document_elements': return await DocumentHandlers.getDocumentElements(args);
+            case 'get_document_styles': return await DocumentHandlers.getDocumentStyles(args);
+            case 'get_document_colors': return await DocumentHandlers.getDocumentColors(args);
+
+            // Document Preferences
+            case 'get_document_preferences': return await DocumentHandlers.getDocumentPreferences(args);
+            case 'set_document_preferences': return await DocumentHandlers.setDocumentPreferences(args);
+
+            // Document Stories & Text
+            case 'get_document_stories': return await DocumentHandlers.getDocumentStories(args);
+            case 'find_text_in_document': return await DocumentHandlers.findTextInDocument(args);
+
+            // Document Layers & Organization
+            case 'get_document_layers': return await DocumentHandlers.getDocumentLayers(args);
+            case 'organize_document_layers': return await DocumentHandlers.organizeDocumentLayers(args);
+
+            // Document Hyperlinks & Interactivity
+            case 'get_document_hyperlinks': return await DocumentHandlers.getDocumentHyperlinks(args);
+            case 'create_document_hyperlink': return await DocumentHandlers.createDocumentHyperlink(args);
+
+            // Document Sections & Numbering
+            case 'get_document_sections': return await DocumentHandlers.getDocumentSections();
+            case 'create_document_section': return await DocumentHandlers.createDocumentSection(args);
+
+            // Document XML & Structure
+            case 'get_document_xml_structure': return await DocumentHandlers.getDocumentXmlStructure(args);
+            case 'export_document_xml': return await DocumentHandlers.exportDocumentXml(args);
+
+            // Document Cloud & Collaboration
+            case 'save_document_to_cloud': return await DocumentHandlers.saveDocumentToCloud(args);
+            case 'open_cloud_document': return await DocumentHandlers.openCloudDocument(args);
+
+            // Document Grid & Layout
+            case 'get_document_grid_settings': return await DocumentHandlers.getDocumentGridSettings();
+            case 'set_document_grid_settings': return await DocumentHandlers.setDocumentGridSettings(args);
+            case 'get_document_layout_preferences': return await DocumentHandlers.getDocumentLayoutPreferences();
+            case 'set_document_layout_preferences': return await DocumentHandlers.setDocumentLayoutPreferences(args);
+
+            // Document Validation & Cleanup
+            case 'validate_document': return await DocumentHandlers.validateDocument(args);
+            case 'cleanup_document': return await DocumentHandlers.cleanupDocument(args);
+
+            // Page Management
+            case 'add_page': return await PageHandlers.addPage(args);
+            case 'get_page_info': return await PageHandlers.getPageInfo(args);
+            case 'navigate_to_page': return await PageHandlers.navigateToPage(args);
+
+            // Advanced Page Management
+            case 'duplicate_page': return await PageHandlers.duplicatePage(args);
+            case 'move_page': return await PageHandlers.movePage(args);
+            case 'delete_page': return await PageHandlers.deletePage(args);
+            case 'set_page_properties': return await PageHandlers.setPageProperties(args);
+            case 'set_page_background': return await PageHandlers.setPageBackground(args);
+            case 'adjust_page_layout': return await PageHandlers.adjustPageLayout(args);
+            case 'resize_page': return await PageHandlers.resizePage(args);
+            case 'create_page_guides': return await PageHandlers.createPageGuides(args);
+            case 'place_file_on_page': return await PageHandlers.placeFileOnPage(args);
+            case 'place_xml_on_page': return await PageHandlers.placeXmlOnPage(args);
+            case 'snapshot_page_layout': return await PageHandlers.snapshotPageLayout(args);
+            case 'delete_page_layout_snapshot': return await PageHandlers.deletePageLayoutSnapshot(args);
+            case 'delete_all_page_layout_snapshots': return await PageHandlers.deleteAllPageLayoutSnapshots(args);
+            case 'reframe_page': return await PageHandlers.reframePage(args);
+            case 'select_page': return await PageHandlers.selectPage(args);
+            case 'get_page_content_summary': return await PageHandlers.getPageContentSummary(args);
+
+            // Text Management
+            case 'create_text_frame': return await TextHandlers.createTextFrame(args);
+            case 'edit_text_frame': return await TextHandlers.editTextFrame(args);
+            case 'create_table': return await TextHandlers.createTable(args);
+            case 'populate_table': return await TextHandlers.populateTable(args);
+            case 'find_replace_text': return await TextHandlers.findReplaceText(args);
+
+            // Graphics Management
+            case 'create_rectangle': return await GraphicsHandlers.createRectangle(args);
+            case 'create_ellipse': return await GraphicsHandlers.createEllipse(args);
+            case 'create_polygon': return await GraphicsHandlers.createPolygon(args);
+            case 'place_image': return await GraphicsHandlers.placeImage(args);
+            case 'create_object_style': return await GraphicsHandlers.createObjectStyle(args);
+            case 'list_object_styles': return await GraphicsHandlers.listObjectStyles();
+            case 'apply_object_style': return await GraphicsHandlers.applyObjectStyle(args);
+            case 'get_image_info': return await GraphicsHandlers.getImageInfo(args);
+
+            // Style Management
+            case 'create_paragraph_style': return await StyleHandlers.createParagraphStyle(args);
+            case 'create_character_style': return await StyleHandlers.createCharacterStyle(args);
+            case 'apply_paragraph_style': return await StyleHandlers.applyParagraphStyle(args);
+            case 'apply_character_style': return await StyleHandlers.applyCharacterStyle(args);
+            case 'apply_color': return await StyleHandlers.applyColor(args);
+            case 'create_color_swatch': return await StyleHandlers.createColorSwatch(args);
+            case 'list_styles': return await StyleHandlers.listStyles(args);
+            case 'list_color_swatches': return await StyleHandlers.listColorSwatches();
+
+            // Export Functions
+            case 'export_pdf': return await ExportHandlers.exportPDF(args);
+            case 'export_images': return await ExportHandlers.exportImages(args);
+            case 'package_document': return await ExportHandlers.packageDocument(args);
+            case 'export_epub': return await ExportHandlers.exportEPUB(args);
+
+            // Master Spread Management
+            case 'create_master_spread': return await MasterSpreadHandlers.createMasterSpread(args);
+            case 'list_master_spreads': return await MasterSpreadHandlers.listMasterSpreads(args);
+            case 'delete_master_spread': return await MasterSpreadHandlers.deleteMasterSpread(args);
+            case 'duplicate_master_spread': return await MasterSpreadHandlers.duplicateMasterSpread(args);
+            case 'apply_master_spread': return await MasterSpreadHandlers.applyMasterSpread(args);
+            case 'create_master_text_frame': return await MasterSpreadHandlers.createMasterTextFrame(args);
+            case 'create_master_rectangle': return await MasterSpreadHandlers.createMasterRectangle(args);
+            case 'create_master_guides': return await MasterSpreadHandlers.createMasterGuides(args);
+            case 'get_master_spread_info': return await MasterSpreadHandlers.getMasterSpreadInfo(args);
+            case 'detach_master_items': return await MasterSpreadHandlers.detachMasterItems(args);
+            case 'remove_master_override': return await MasterSpreadHandlers.removeMasterOverride(args);
+
+            // Spread Management
+            case 'list_spreads': return await SpreadHandlers.listSpreads(args);
+            case 'get_spread_info': return await SpreadHandlers.getSpreadInfo(args);
+            case 'duplicate_spread': return await SpreadHandlers.duplicateSpread(args);
+            case 'move_spread': return await SpreadHandlers.moveSpread(args);
+            case 'delete_spread': return await SpreadHandlers.deleteSpread(args);
+            case 'set_spread_properties': return await SpreadHandlers.setSpreadProperties(args);
+            case 'create_spread_guides': return await SpreadHandlers.createSpreadGuides(args);
+            case 'place_file_on_spread': return await SpreadHandlers.placeFileOnSpread(args);
+            case 'place_xml_on_spread': return await SpreadHandlers.placeXmlOnSpread(args);
+            case 'select_spread': return await SpreadHandlers.selectSpread(args);
+            case 'get_spread_content_summary': return await SpreadHandlers.getSpreadContentSummary(args);
+
+            // Layer Management
+            case 'create_layer': return await LayerHandlers.createLayer(args);
+            case 'set_active_layer': return await LayerHandlers.setActiveLayer(args);
+            case 'list_layers': return await LayerHandlers.listLayers(args);
+
+            // Book Management
+            case 'create_book': return await BookHandlers.createBook(args);
+            case 'open_book': return await BookHandlers.openBook(args);
+            case 'list_books': return await BookHandlers.listBooks(args);
+            case 'add_document_to_book': return await BookHandlers.addDocumentToBook(args);
+            case 'synchronize_book': return await BookHandlers.synchronizeBook(args);
+            case 'repaginate_book': return await BookHandlers.repaginateBook(args);
+            case 'update_all_cross_references': return await BookHandlers.updateAllCrossReferences(args);
+            case 'update_all_numbers': return await BookHandlers.updateAllNumbers(args);
+            case 'update_chapter_and_paragraph_numbers': return await BookHandlers.updateChapterAndParagraphNumbers(args);
+            case 'export_book': return await BookHandlers.exportBook(args);
+            case 'package_book': return await BookHandlers.packageBook(args);
+            case 'preflight_book': return await BookHandlers.preflightBook(args);
+            case 'print_book': return await BookHandlers.printBook(args);
+            case 'get_book_info': return await BookHandlers.getBookInfo(args);
+            case 'set_book_properties': return await BookHandlers.setBookProperties(args);
+
+            // PageItem Management
+            case 'get_page_item_info': return await PageItemHandlers.getPageItemInfo(args);
+            case 'select_page_item': return await PageItemHandlers.selectPageItem(args);
+            case 'move_page_item': return await PageItemHandlers.movePageItem(args);
+            case 'resize_page_item': return await PageItemHandlers.resizePageItem(args);
+            case 'set_page_item_properties': return await PageItemHandlers.setPageItemProperties(args);
+            case 'duplicate_page_item': return await PageItemHandlers.duplicatePageItem(args);
+            case 'delete_page_item': return await PageItemHandlers.deletePageItem(args);
+            case 'get_page_item_script_labels': return await PageItemHandlers.getPageItemScriptLabels(args);
+            case 'set_page_item_script_label': return await PageItemHandlers.setPageItemScriptLabel(args);
+            case 'list_page_items': return await PageItemHandlers.listPageItems(args);
+
+            // Group Management
+            case 'create_group': return await GroupHandlers.createGroup(args);
+            case 'create_group_from_items': return await GroupHandlers.createGroupFromItems(args);
+            case 'ungroup': return await GroupHandlers.ungroup(args);
+            case 'get_group_info': return await GroupHandlers.getGroupInfo(args);
+            case 'add_item_to_group': return await GroupHandlers.addItemToGroup(args);
+            case 'remove_item_from_group': return await GroupHandlers.removeItemFromGroup(args);
+            case 'list_groups': return await GroupHandlers.listGroups(args);
+            case 'set_group_properties': return await GroupHandlers.setGroupProperties(args);
+
+            // Utility Functions
+            case 'execute_indesign_code': return await UtilityHandlers.executeInDesignCode(args);
+            case 'view_document': return await UtilityHandlers.viewDocument();
+            case 'get_session_info': return await UtilityHandlers.getSessionInfo();
+            case 'clear_session': return await UtilityHandlers.clearSession();
+
+            // Presentation (Architecture report deck)
+            case 'create_presentation_document': return await PresentationHandlers.createPresentationDocument(args);
+            case 'add_cover_page': return await PresentationHandlers.addCoverPage(args);
+            case 'add_section_page': return await PresentationHandlers.addSectionPage(args);
+            case 'add_full_bleed_image': return await PresentationHandlers.addFullBleedImage(args);
+            case 'add_image_grid': return await PresentationHandlers.addImageGrid(args);
+            case 'export_presentation_pdf': return await PresentationHandlers.exportPresentationPDF(args);
+
+            // Help System
+            case 'help': return await HelpHandlers.getHelp(args);
+
+            // Add more handlers as we create them
+            default:
+                return formatErrorResponse(`Tool '${name}' not found or not implemented. Use 'help' to see available tools.`, "Tool Call");
+        }
+    }
+
+    async run() {
+        const transport = new StdioServerTransport();
+        await this.server.connect(transport);
+        // Don't log to stdout as it interferes with MCP protocol
+        // console.log('InDesign MCP Server started');
+    }
+} 

cli_anything/indesign/server/src/core/scriptExecutor.js

@@ -0,0 +1,271 @@
+/**
+ * Core script execution functionality (macOS AppleScript + Windows COM)
+ */
+import { execFileSync } from 'child_process';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { fileURLToPath } from 'url';
+import { createRequire } from 'module';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const EXTENDSCRIPT_RUNTIME_SNIPPET = `
+if (typeof JSON === "undefined") { JSON = {}; }
+function __mcpJsonSeenContains(arr, value) {
+  for (var i = 0; i < arr.length; i++) {
+    if (arr[i] === value) return true;
+  }
+  return false;
+}
+function __mcpJsonEscapeString(str) {
+  if (str === null || str === undefined) return "";
+  var result = "";
+  var backslash = String.fromCharCode(92);
+  for (var i = 0; i < str.length; i++) {
+    var ch = str.charAt(i);
+    var code = str.charCodeAt(i);
+    if (code === 34) {
+      result += backslash + '"';
+    } else if (code === 92) {
+      result += backslash + backslash;
+    } else if (code === 8) {
+      result += backslash + "b";
+    } else if (code === 9) {
+      result += backslash + "t";
+    } else if (code === 10) {
+      result += backslash + "n";
+    } else if (code === 12) {
+      result += backslash + "f";
+    } else if (code === 13) {
+      result += backslash + "r";
+    } else if (code === 0x2028 || code === 0x2029) {
+      result += backslash + "u" + code.toString(16);
+    } else if (code < 32) {
+      var hex = code.toString(16);
+      result += backslash + "u" + ("0000" + hex).slice(-4);
+    } else {
+      result += ch;
+    }
+  }
+  return result;
+}
+function __mcpJsonSerialize(value) {
+  var seen = [];
+  function serialize(v) {
+    if (v === null) return "null";
+    var t = typeof v;
+    if (t === "number" || t === "boolean") return String(v);
+    if (t === "string") return '"' + __mcpJsonEscapeString(v) + '"';
+    if (v instanceof Array) {
+      var arr = [];
+      for (var i = 0; i < v.length; i++) arr.push(serialize(v[i]));
+      return "[" + arr.join(",") + "]";
+    }
+    if (t === "object") {
+      if (__mcpJsonSeenContains(seen, v)) return '"[Circular]"';
+      seen.push(v);
+      var props = [];
+      for (var key in v) {
+        if (!v.hasOwnProperty(key)) continue;
+        props.push('"' + __mcpJsonEscapeString(key) + '":' + serialize(v[key]));
+      }
+      seen.pop();
+      return "{" + props.join(",") + "}";
+    }
+    return "null";
+  }
+  return serialize(value);
+}
+if (typeof JSON.stringify !== "function") {
+  JSON.stringify = function(value) { return __mcpJsonSerialize(value); };
+}
+if (typeof JSON.parse !== "function") {
+  JSON.parse = function(text) { return eval("(" + text + ")"); };
+}
+`;
+
+export class ScriptExecutor {
+    // Cache a COM Application instance for Windows to avoid repeated activation
+    static _winApp = null;
+
+    static isWindows() {
+        return process.platform === 'win32';
+    }
+
+    /**
+     * Execute AppleScript command (macOS only)
+     * @param {string} script - The AppleScript to execute
+     * @returns {string} The result of the AppleScript execution
+     */
+    static async executeAppleScript(script) {
+        try {
+            const result = execFileSync('osascript', ['-e', script], { encoding: 'utf8' });
+            return result.trim();
+        } catch (error) {
+            throw new Error(`AppleScript execution failed: ${error.message}`);
+        }
+    }
+
+    /**
+     * Resolve a Windows COM InDesign.Application object via winax
+     * Tries multiple ProgIDs to maximize compatibility across versions.
+     */
+    static _getWindowsInDesignApp() {
+        if (!this.isWindows()) {
+            throw new Error('Windows COM is only available on Windows');
+        }
+        if (this._winApp) return this._winApp;
+
+        // Lazy-require winax to avoid issues on non-Windows platforms
+        const requireCjs = createRequire(import.meta.url);
+        let WinaxObject;
+        try {
+            const winax = requireCjs('winax');
+            // winax provides constructor as winax.Object and also sets global.ActiveXObject in CJS
+            WinaxObject = winax.Object || global.ActiveXObject;
+        } catch (e) {
+            throw new Error("Missing dependency 'winax'. Please run: npm install winax");
+        }
+
+        // Prefer explicit recent desktop ProgIDs, then generic, then older versions
+        const progIDs = [
+            // Newer/future first
+            'InDesign.Application.2026',
+            'InDesign.Application.CC.2026',
+            // Current
+            'InDesign.Application.2025',
+            'InDesign.Application.CC.2025',
+            // Generic
+            'InDesign.Application',
+            // Recent past
+            'InDesign.Application.2024',
+            'InDesign.Application.CC.2024',
+            'InDesign.Application.2023',
+            'InDesign.Application.CC.2023',
+            'InDesign.Application.2022',
+            'InDesign.Application.CC.2022',
+            // InDesign Server fallbacks (least preferred)
+            'InDesignServer.Application.2025',
+            'InDesignServer.Application.2024',
+            'InDesignServer.Application',
+        ];
+
+        let lastError;
+        for (const id of progIDs) {
+            try {
+                const app = new WinaxObject(id);
+                this._winApp = app;
+                return app;
+            } catch (err) {
+                lastError = err;
+            }
+        }
+        throw new Error(
+            `Could not create InDesign COM object. Tried: ${progIDs.join(', ')}. ` +
+            `Last error: ${lastError?.message || lastError}. ` +
+            `Tips: Ensure Adobe InDesign desktop is installed and has been launched at least once, ` +
+            `and that COM registration is available. If installation is fresh, try restarting or running once as administrator.`
+        );
+    }
+
+    /**
+     * Execute InDesign ExtendScript/JavaScript code
+     * - On Windows: Use COM DoScript via winax
+     * - On macOS: Use AppleScript to run the temp JSX file
+     * @param {string} script - The ExtendScript to execute
+     * @returns {string} The result of the script execution
+     */
+    static async executeInDesignScript(script) {
+        if (this.isWindows()) {
+            return await this._executeInDesignScriptWindows(script);
+        }
+        // macOS path (AppleScript + temp JSX file)
+        let tempDir;
+        let tempScriptPath;
+        try {
+            tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'indesign-mcp-'));
+            tempScriptPath = path.join(tempDir, 'script.jsx');
+
+            // Force non-interactive (headless) execution where possible
+            const wrapped = [
+                'try {',
+                '  app.scriptPreferences.userInteractionLevel = UserInteractionLevels.NEVER_INTERACT;',
+                EXTENDSCRIPT_RUNTIME_SNIPPET,
+                script,
+                '} catch (e) {',
+                '  "Error: " + e.message;',
+                '}'
+            ].join('\n');
+            fs.writeFileSync(tempScriptPath, wrapped, { encoding: 'utf8' });
+
+            const escapedScriptPath = tempScriptPath.replace(/"/g, '\\"');
+            const appleScript = `
+        tell application "Adobe InDesign 2025"
+          do script POSIX file "${escapedScriptPath}" language javascript
+        end tell
+      `;
+
+            const result = await this.executeAppleScript(appleScript);
+
+            return result;
+        } catch (error) {
+            throw new Error(`Error executing tool (macOS): ${error.message}`);
+        } finally {
+            if (tempDir) {
+                try { fs.rmSync(tempDir, { recursive: true, force: true }); } catch {}
+            }
+        }
+    }
+
+    /**
+     * Execute a JSX file directly so $.fileName, relative #include, etc. behave correctly.
+     * @param {string} filePath - Absolute or relative path to the JSX file.
+     * @returns {string} The result of the script execution.
+     */
+    static async executeInDesignScriptFile(filePath) {
+        if (!filePath || typeof filePath !== 'string') {
+            throw new Error('filePath must be a string');
+        }
+        const resolved = path.resolve(filePath);
+        const escaped = resolved.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+        const wrapper = [
+            'var __mcpResult = "";',
+            'try {',
+            `  var __mcpFile = File("${escaped}");`,
+            '  if (!__mcpFile.exists) { throw new Error("JSX 文件不存在: " + __mcpFile.fsName); }',
+            '  __mcpResult = app.doScript(__mcpFile, ScriptLanguage.JAVASCRIPT);',
+            '} catch (e) {',
+            '  __mcpResult = "Error: " + (e && e.message ? e.message : e);',
+            '}',
+            '__mcpResult;'
+        ].join('\n');
+        return await this.executeInDesignScript(wrapper);
+    }
+
+    /**
+     * Windows: Execute via COM DoScript
+     */
+    static async _executeInDesignScriptWindows(script) {
+        try {
+            const app = this._getWindowsInDesignApp();
+            // Wrap to enforce non-interactive mode and basic error capture
+            const wrapped = [
+                'try {',
+                '  app.scriptPreferences.userInteractionLevel = UserInteractionLevels.NEVER_INTERACT;',
+                EXTENDSCRIPT_RUNTIME_SNIPPET,
+                script,
+                '} catch (e) {',
+                '  "Error: " + e.message;',
+                '}'
+            ].join('\n');
+            // ScriptLanguage.JAVASCRIPT (numeric enum for COM environments)
+            const ScriptLanguage_JAVASCRIPT = 1246973031;
+            const result = app.DoScript(wrapped, ScriptLanguage_JAVASCRIPT);
+            return (result === undefined || result === null) ? '' : String(result);
+        } catch (error) {
+            throw new Error(`Windows COM execution failed: ${error.message}`);
+        }
+    }
+}