@vscxml/mcp 0.1.0

package/dist/server.js

@@ -0,0 +1,721 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { z } from 'zod';
+import { GeneratorBridge } from './bridges/generator-bridge.js';
+import { SimulatorBridge } from './bridges/simulator-bridge.js';
+import { EditorBridge } from './bridges/editor-bridge.js';
+import { ProcessManager } from './process-manager.js';
+// Semantic color presets for editor_highlight
+const HIGHLIGHT_PRESETS = {
+    error: '#ef4444',
+    danger: '#dc2626',
+    warning: '#f59e0b',
+    success: '#16a34a',
+    info: '#2563eb',
+    active: '#8b5cf6',
+};
+export function createServer(config = {}) {
+    const server = new McpServer({
+        name: 'scxml-gen',
+        version: '0.1.0',
+    });
+    const generator = new GeneratorBridge(config.generatorUrl);
+    const simulator = new SimulatorBridge(config.simulatorUrl);
+    const editor = new EditorBridge(config.editorUrl);
+    const processManager = new ProcessManager();
+    // ═══════════════════════════════════════════════
+    // Design Tools
+    // ═══════════════════════════════════════════════
+    server.tool('scxml_validate', 'Validate SCXML against the W3C spec. Returns errors/warnings, state count, transition count, and datamodel type.', { scxml: z.string().describe('SCXML XML content to validate') }, async ({ scxml }) => {
+        const result = await generator.validate(scxml);
+        return {
+            content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+        };
+    });
+    server.tool('scxml_inspect', 'Inspect an SCXML file and return its full structured model: states, transitions, events, guards, actions, data variables, and hierarchy. Use this to reason about a state machine without seeing a diagram.', { scxml: z.string().describe('SCXML XML content to inspect') }, async ({ scxml }) => {
+        const result = await generator.inspect(scxml);
+        return {
+            content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+        };
+    });
+    server.tool('scxml_create', 'Create a new SCXML state machine from a structured specification. Returns valid SCXML XML. This is easier than writing raw XML — specify states, transitions, and data as structured objects.', {
+        name: z.string().optional().default('StateMachine').describe('Machine name'),
+        datamodel: z.enum(['ecmascript', 'null', 'native-java', 'native-js', 'native-python', 'native-go', 'native-st']).optional().default('ecmascript'),
+        binding: z.enum(['early', 'late']).optional().default('early'),
+        states: z.array(z.object({
+            id: z.string().describe('State ID'),
+            type: z.enum(['atomic', 'compound', 'parallel', 'final']).optional().default('atomic'),
+            parent: z.string().nullable().optional().describe('Parent state ID (null = top-level)'),
+            initial: z.string().nullable().optional().describe('Initial child state (for compound)'),
+            onEntry: z.string().nullable().optional().describe('Script to execute on entry'),
+            onExit: z.string().nullable().optional().describe('Script to execute on exit'),
+            data: z.array(z.object({
+                id: z.string(),
+                expr: z.string().optional(),
+                type: z.string().optional(),
+            })).optional().describe('State-local data variables'),
+        })).describe('States'),
+        transitions: z.array(z.object({
+            source: z.string().describe('Source state ID'),
+            target: z.string().nullable().optional().describe('Target state ID'),
+            event: z.string().nullable().optional().describe('Trigger event'),
+            cond: z.string().nullable().optional().describe('Guard condition'),
+            type: z.enum(['external', 'internal']).optional(),
+            actions: z.string().nullable().optional().describe('Script actions'),
+        })).optional().default([]).describe('Transitions'),
+        data: z.array(z.object({
+            id: z.string(),
+            expr: z.string().optional(),
+            type: z.string().optional(),
+        })).optional().default([]).describe('Top-level data variables'),
+    }, async ({ name, datamodel, binding, states, transitions, data }) => {
+        const result = await generator.create({
+            name, datamodel, binding, states, transitions, data,
+        });
+        return {
+            content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+        };
+    });
+    server.tool('scxml_generate_project', 'Generate a complete runnable project for a target language. Unlike scxml_generate with codeOnly, this includes build files, runtime dependencies, and project scaffolding.', {
+        scxml: z.string().describe('SCXML XML content'),
+        target: z.enum(['java', 'js', 'javascript', 'csharp', 'c', 'python', 'go', 'st']).describe('Target language'),
+        options: z.object({
+            className: z.string().optional(),
+            packageName: z.string().optional(),
+            namespace: z.string().optional(),
+            bundleAuto: z.boolean().optional(),
+            plcPlatform: z.string().optional(),
+        }).optional().describe('Target-specific options'),
+    }, async ({ scxml, target, options }) => {
+        const result = await generator.generateProject(scxml, target, options);
+        // Build helpful metadata
+        const buildCommands = {
+            java: 'gradle build',
+            javascript: 'npm install && npm test',
+            js: 'npm install && npm test',
+            csharp: 'dotnet build',
+            c: 'mkdir build && cd build && cmake .. && make',
+            python: 'pip install -e . && python -m pytest',
+            go: 'go build ./...',
+            st: '(Import .st file into CODESYS/TwinCAT IDE)',
+        };
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify({
+                        files: result.files,
+                        target: result.target,
+                        buildCommand: buildCommands[target] || '',
+                        fileCount: result.files.length,
+                    }, null, 2),
+                }],
+        };
+    });
+    // ═══════════════════════════════════════════════
+    // Simulation Tools
+    // ═══════════════════════════════════════════════
+    server.tool('scxml_sim_start', 'Load SCXML into the simulator and start a session. Returns the initial active states, variables, and enabled events.', { scxml: z.string().describe('SCXML XML content to simulate') }, async ({ scxml }) => {
+        if (!simulator.isConnected()) {
+            await simulator.connect();
+        }
+        await simulator.loadScxml(scxml);
+        const state = await simulator.start();
+        return {
+            content: [{ type: 'text', text: JSON.stringify(state, null, 2) }],
+        };
+    });
+    server.tool('scxml_sim_send', 'Send a single event to the running simulation and return the resulting trace (state exits, entries, transitions, variable changes) and new state.', {
+        event: z.string().describe('Event name to send'),
+        data: z.unknown().optional().describe('Optional event data'),
+    }, async ({ event, data }) => {
+        if (!simulator.isConnected()) {
+            throw new Error('No active simulation session. Use scxml_sim_start first.');
+        }
+        const result = await simulator.sendEvent(event, data);
+        return {
+            content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+        };
+    });
+    server.tool('scxml_sim_scenario', 'Run a batch of events against a simulation and return the complete trace. This is the most useful tool for testing behavior — "send these events and show me what happens."', {
+        scxml: z.string().optional().describe('SCXML content (creates fresh session). Omit to use existing session.'),
+        events: z.array(z.union([
+            z.string(),
+            z.object({
+                name: z.string(),
+                data: z.unknown().optional(),
+            }),
+        ])).describe('Events to send in sequence'),
+        stopOnError: z.boolean().optional().default(true).describe('Stop on first error (default: true)'),
+    }, async ({ scxml, events, stopOnError }) => {
+        if (!simulator.isConnected()) {
+            await simulator.connect();
+        }
+        // Start fresh session if SCXML provided
+        if (scxml) {
+            await simulator.loadScxml(scxml);
+            await simulator.start();
+        }
+        const allTrace = [];
+        const perEvent = [];
+        let error;
+        for (const evt of events) {
+            const eventName = typeof evt === 'string' ? evt : evt.name;
+            const eventData = typeof evt === 'string' ? undefined : evt.data;
+            try {
+                const result = await simulator.sendEvent(eventName, eventData);
+                allTrace.push(...result.trace);
+                perEvent.push({
+                    event: eventName,
+                    trace: result.trace,
+                    activeStates: result.state.activeStates,
+                    variables: result.state.variables,
+                });
+                if (result.state.finished)
+                    break;
+            }
+            catch (err) {
+                error = err instanceof Error ? err.message : String(err);
+                if (stopOnError)
+                    break;
+            }
+        }
+        const finalState = await simulator.getState();
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify({
+                        trace: allTrace,
+                        perEvent,
+                        finalActiveStates: finalState.activeStates,
+                        finalVariables: finalState.variables,
+                        finished: finalState.finished,
+                        error,
+                    }, null, 2),
+                }],
+        };
+    });
+    server.tool('scxml_sim_get_state', 'Get the current simulation state without sending an event. Returns active states, variables, enabled events, execution mode, and full trace history.', {}, async () => {
+        if (!simulator.isConnected()) {
+            throw new Error('No active simulation session. Use scxml_sim_start first.');
+        }
+        const state = await simulator.getState();
+        return {
+            content: [{ type: 'text', text: JSON.stringify(state, null, 2) }],
+        };
+    });
+    server.tool('scxml_sim_reset', 'Reset the simulation session to its initial state.', {}, async () => {
+        if (!simulator.isConnected()) {
+            throw new Error('No active simulation session. Use scxml_sim_start first.');
+        }
+        const state = await simulator.reset();
+        return {
+            content: [{ type: 'text', text: JSON.stringify(state, null, 2) }],
+        };
+    });
+    // ═══════════════════════════════════════════════
+    // Code Generation Tools
+    // ═══════════════════════════════════════════════
+    server.tool('scxml_generate', 'Generate code for a target language from SCXML. Returns the generated source files as text.', {
+        scxml: z.string().describe('SCXML XML content'),
+        target: z.enum(['java', 'js', 'javascript', 'csharp', 'c', 'python', 'go', 'st'])
+            .describe('Target language'),
+        options: z.object({
+            className: z.string().optional(),
+            packageName: z.string().optional(),
+            namespace: z.string().optional(),
+            codeOnly: z.boolean().optional(),
+            bundleAuto: z.boolean().optional(),
+            plcPlatform: z.string().optional(),
+            eventQueueDepth: z.number().optional(),
+        }).optional().describe('Target-specific generation options'),
+    }, async ({ scxml, target, options }) => {
+        const result = await generator.generate(scxml, target, options);
+        return {
+            content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+        };
+    });
+    server.tool('scxml_list_targets', 'List available code generation targets and their options.', {}, async () => {
+        const targets = await generator.listTargets();
+        return {
+            content: [{ type: 'text', text: JSON.stringify({ targets }, null, 2) }],
+        };
+    });
+    // ═══════════════════════════════════════════════
+    // Verification Tools
+    // ═══════════════════════════════════════════════
+    server.tool('scxml_compare_traces', 'Compare two execution traces (e.g., simulation trace vs generated-code trace) and report differences.', {
+        expected: z.array(z.record(z.unknown())).describe('Expected trace entries (e.g., from simulation)'),
+        actual: z.array(z.record(z.unknown())).describe('Actual trace entries (e.g., from running generated code)'),
+        ignoreTimestamps: z.boolean().optional().default(true).describe('Ignore timestamp differences'),
+    }, async ({ expected, actual, ignoreTimestamps }) => {
+        const result = compareTraces(expected, actual, ignoreTimestamps);
+        return {
+            content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+        };
+    });
+    // ═══════════════════════════════════════════════
+    // Trace Management Tools
+    // ═══════════════════════════════════════════════
+    server.tool('scxml_trace_list', 'List all embedded traces in the current SCXML document. Requires an active simulation session.', {}, async () => {
+        if (!simulator.isConnected()) {
+            throw new Error('No active simulation session. Use scxml_sim_start first.');
+        }
+        const traces = await simulator.listTraces();
+        return {
+            content: [{ type: 'text', text: JSON.stringify({ traces }, null, 2) }],
+        };
+    });
+    server.tool('scxml_trace_embed', 'Embed a trace into the SCXML document. Provide JSONL content to embed an external trace, or omit content to embed the current session execution history.', {
+        name: z.string().describe('Trace name (identifier for later retrieval)'),
+        description: z.string().optional().describe('Human-readable description of this trace'),
+        content: z.string().optional().describe('Raw JSONL trace content to embed. If omitted, the current session execution history is used.'),
+    }, async ({ name, description, content }) => {
+        if (!simulator.isConnected()) {
+            throw new Error('No active simulation session. Use scxml_sim_start first.');
+        }
+        const result = await simulator.saveTrace(name, { description, content });
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify({
+                        embedded: name,
+                        entryCount: result.entryCount,
+                    }, null, 2),
+                }],
+        };
+    });
+    server.tool('scxml_trace_delete', 'Delete an embedded trace from the SCXML document by name.', {
+        name: z.string().describe('Trace name to delete'),
+    }, async ({ name }) => {
+        if (!simulator.isConnected()) {
+            throw new Error('No active simulation session. Use scxml_sim_start first.');
+        }
+        await simulator.deleteTrace(name);
+        return {
+            content: [{ type: 'text', text: JSON.stringify({ deleted: name }, null, 2) }],
+        };
+    });
+    server.tool('scxml_trace_get', 'Get an embedded trace by name. Returns the parsed trace entries for inspection, comparison, or export.', {
+        name: z.string().describe('Trace name to retrieve'),
+    }, async ({ name }) => {
+        if (!simulator.isConnected()) {
+            throw new Error('No active simulation session. Use scxml_sim_start first.');
+        }
+        const result = await simulator.loadTrace(name);
+        return {
+            content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+        };
+    });
+    // ═══════════════════════════════════════════════
+    // Trace Playback + Variable Tools
+    // ═══════════════════════════════════════════════
+    server.tool('scxml_trace_play', 'Start playback of an embedded trace by name. The simulator will replay the trace with state updates broadcast in real-time.', {
+        name: z.string().describe('Embedded trace name to play'),
+        speed: z.number().optional().describe('Playback speed multiplier (1.0 = real-time, 2.0 = 2x speed). Default: 1.0'),
+    }, async ({ name, speed }) => {
+        if (!simulator.isConnected()) {
+            throw new Error('No active simulation session. Use scxml_sim_start first.');
+        }
+        const result = await simulator.playTrace(name, speed);
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify({
+                        playing: name,
+                        entryCount: result.entryCount,
+                        speed: speed || 1.0,
+                    }, null, 2),
+                }],
+        };
+    });
+    server.tool('scxml_trace_step', 'Step forward or backward through a loaded trace. Returns the current position and trace entry.', {
+        delta: z.number().describe('Steps to move: positive = forward, negative = backward'),
+    }, async ({ delta }) => {
+        if (!simulator.isConnected()) {
+            throw new Error('No active simulation session. Use scxml_sim_start first.');
+        }
+        const result = await simulator.stepTrace(delta);
+        return {
+            content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+        };
+    });
+    server.tool('scxml_sim_set_variable', 'Set a variable value during simulation. The variable must exist in the state machine datamodel.', {
+        name: z.string().describe('Variable name'),
+        value: z.unknown().describe('New value for the variable'),
+    }, async ({ name, value }) => {
+        if (!simulator.isConnected()) {
+            throw new Error('No active simulation session. Use scxml_sim_start first.');
+        }
+        await simulator.setVariable(name, value);
+        return {
+            content: [{ type: 'text', text: JSON.stringify({ set: name, value }, null, 2) }],
+        };
+    });
+    // ═══════════════════════════════════════════════
+    // Editor Interaction Tools
+    // ═══════════════════════════════════════════════
+    server.tool('editor_push_scxml', 'Push SCXML content to the VSCXML-Generator editor for the user to see and edit. The editor will update its SCXML input pane.', { scxml: z.string().describe('SCXML XML content to push to the editor') }, async ({ scxml }) => {
+        if (!editor.isConnected()) {
+            try {
+                await editor.connect();
+            }
+            catch {
+                return {
+                    content: [{ type: 'text', text: JSON.stringify({ success: false, error: 'Editor not connected. Is VSCXML-Generator running?' }) }],
+                };
+            }
+        }
+        const result = await editor.pushScxml(scxml);
+        return {
+            content: [{ type: 'text', text: JSON.stringify(result) }],
+        };
+    });
+    server.tool('editor_get_scxml', 'Get the current SCXML content from the VSCXML-Generator editor (what the user is currently editing).', {}, async () => {
+        if (!editor.isConnected()) {
+            try {
+                await editor.connect();
+            }
+            catch {
+                return {
+                    content: [{ type: 'text', text: JSON.stringify({ error: 'Editor not connected. Is VSCXML-Generator running?' }) }],
+                };
+            }
+        }
+        const result = await editor.getScxml();
+        return {
+            content: [{ type: 'text', text: JSON.stringify(result) }],
+        };
+    });
+    server.tool('editor_show_notification', 'Show a toast notification in the VSCXML-Generator editor UI. Useful for status updates.', {
+        message: z.string().describe('Notification message'),
+        severity: z.enum(['info', 'warning', 'error', 'success']).optional().default('info'),
+        duration: z.number().optional().default(5000).describe('Duration in ms (0 = persistent)'),
+    }, async ({ message, severity, duration }) => {
+        if (!editor.isConnected()) {
+            try {
+                await editor.connect();
+            }
+            catch {
+                return {
+                    content: [{ type: 'text', text: JSON.stringify({ success: false, error: 'Editor not connected' }) }],
+                };
+            }
+        }
+        await editor.showNotification(message, severity, duration);
+        return {
+            content: [{ type: 'text', text: JSON.stringify({ success: true }) }],
+        };
+    });
+    server.tool('editor_highlight', 'Highlight specific states in the VSCXML-Editor canvas. Used to draw attention to states during explanation or debugging.', {
+        states: z.array(z.string()).describe('State IDs to highlight'),
+        color: z.string().optional().describe('Highlight color: hex (#ef4444) or preset (error, success, warning, info, active, danger). Default: blue.'),
+        duration: z.number().optional().describe('Duration in ms (0 = persistent until cleared)'),
+        clear: z.boolean().optional().describe('Clear existing highlights first'),
+    }, async ({ states, color, duration, clear }) => {
+        if (!editor.isConnected()) {
+            try {
+                await editor.connect();
+            }
+            catch {
+                return { content: [{ type: 'text', text: JSON.stringify({ success: false, error: 'Editor not connected' }) }] };
+            }
+        }
+        const resolvedColor = color ? (HIGHLIGHT_PRESETS[color.toLowerCase()] || color) : undefined;
+        await editor.highlight(states, { color: resolvedColor, duration, clear });
+        return { content: [{ type: 'text', text: JSON.stringify({ success: true }) }] };
+    });
+    server.tool('editor_add_note', 'Add a note/annotation to the VSCXML-Editor canvas. Notes can be attached to states and conditionally visible.', {
+        content: z.string().describe('Note text content'),
+        attachedTo: z.string().optional().describe('State ID to attach the note to (moves with state)'),
+        color: z.string().optional().describe('Note background color (default: light blue)'),
+        visibleWhen: z.array(z.string()).optional().describe('Only show when these state IDs are active'),
+    }, async ({ content, attachedTo, color, visibleWhen }) => {
+        if (!editor.isConnected()) {
+            try {
+                await editor.connect();
+            }
+            catch {
+                return { content: [{ type: 'text', text: JSON.stringify({ success: false, error: 'Editor not connected' }) }] };
+            }
+        }
+        const result = await editor.addNote(content, { attachedTo, color, visibleWhen });
+        return { content: [{ type: 'text', text: JSON.stringify({ success: true, noteId: result.noteId }) }] };
+    });
+    server.tool('editor_remove_notes', 'Remove notes previously added by MCP from the editor canvas. Call with no noteIds to remove all MCP-added notes.', {
+        noteIds: z.array(z.string()).optional().describe('Specific note IDs to remove (omit to remove all MCP notes)'),
+    }, async ({ noteIds }) => {
+        if (!editor.isConnected()) {
+            try {
+                await editor.connect();
+            }
+            catch {
+                return { content: [{ type: 'text', text: JSON.stringify({ success: false, error: 'Editor not connected' }) }] };
+            }
+        }
+        await editor.removeNotes(noteIds);
+        return { content: [{ type: 'text', text: JSON.stringify({ success: true }) }] };
+    });
+    server.tool('editor_navigate', 'Navigate the VSCXML-Editor canvas to show specific states or fit the entire diagram.', {
+        target: z.string().optional().describe('State ID to center on'),
+        fitStates: z.array(z.string()).optional().describe('Fit view to show all these states'),
+        fitAll: z.boolean().optional().describe('Fit entire diagram in view'),
+        zoom: z.number().optional().describe('Zoom level (default: 1.0)'),
+    }, async ({ target, fitStates, fitAll, zoom }) => {
+        if (!editor.isConnected()) {
+            try {
+                await editor.connect();
+            }
+            catch {
+                return { content: [{ type: 'text', text: JSON.stringify({ success: false, error: 'Editor not connected' }) }] };
+            }
+        }
+        await editor.navigate({ target, fitStates, fitAll, zoom });
+        return { content: [{ type: 'text', text: JSON.stringify({ success: true }) }] };
+    });
+    server.tool('editor_save_file', 'Save SCXML content to a file on disk. If content is omitted, saves the current editor content.', {
+        filePath: z.string().describe('Absolute file path to save to'),
+        content: z.string().optional().describe('SCXML content to save. If omitted, fetches current content from the editor.'),
+    }, async ({ filePath, content }) => {
+        if (!editor.isConnected()) {
+            try {
+                await editor.connect();
+            }
+            catch {
+                return { content: [{ type: 'text', text: JSON.stringify({ success: false, error: 'Editor not connected' }) }] };
+            }
+        }
+        // If no content provided, get it from the editor
+        let scxmlContent = content;
+        if (!scxmlContent) {
+            const editorContent = await editor.getScxml();
+            scxmlContent = editorContent.scxml;
+        }
+        const result = await editor.saveFile(filePath, scxmlContent);
+        return { content: [{ type: 'text', text: JSON.stringify(result) }] };
+    });
+    server.tool('editor_load_file', 'Load an SCXML file from disk into the editor. The editor will display the loaded content.', {
+        filePath: z.string().describe('Absolute file path to load'),
+    }, async ({ filePath }) => {
+        if (!editor.isConnected()) {
+            try {
+                await editor.connect();
+            }
+            catch {
+                return { content: [{ type: 'text', text: JSON.stringify({ success: false, error: 'Editor not connected' }) }] };
+            }
+        }
+        const result = await editor.loadFile(filePath);
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify({
+                        success: true,
+                        filePath: result.filePath,
+                        contentLength: result.content.length,
+                    }),
+                }],
+        };
+    });
+    server.tool('editor_screenshot', 'Capture a screenshot of the VSCXML-Generator editor window. Returns a base64-encoded PNG image.', {}, async () => {
+        if (!editor.isConnected()) {
+            try {
+                await editor.connect();
+            }
+            catch {
+                return { content: [{ type: 'text', text: JSON.stringify({ error: 'Editor not connected' }) }] };
+            }
+        }
+        const result = await editor.screenshot();
+        return {
+            content: [{
+                    type: 'image',
+                    data: result.data,
+                    mimeType: 'image/png',
+                }],
+        };
+    });
+    server.tool('editor_connect_simulator', 'Connect the editor to the simulator backend so it shows live state highlights during MCP-driven simulation.', {
+        port: z.number().optional().describe('Simulator WebSocket port (default: 48621)'),
+    }, async ({ port }) => {
+        if (!editor.isConnected()) {
+            try {
+                await editor.connect();
+            }
+            catch {
+                return { content: [{ type: 'text', text: JSON.stringify({ success: false, error: 'Editor not connected' }) }] };
+            }
+        }
+        const result = await editor.connectSimulator(port);
+        return { content: [{ type: 'text', text: JSON.stringify(result) }] };
+    });
+    server.tool('editor_get_selection', 'Get the current selection state in the editor — selected states, transitions, and MCP highlights (with colors). Also includes the latest buffered selection event from user clicks.', {}, async () => {
+        if (!editor.isConnected()) {
+            try {
+                await editor.connect();
+            }
+            catch {
+                return { content: [{ type: 'text', text: JSON.stringify({ error: 'Editor not connected' }) }] };
+            }
+        }
+        const result = await editor.getSelection();
+        const buffered = editor.getLastSelection();
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify({ ...result, lastSelectionEvent: buffered }, null, 2),
+                }],
+        };
+    });
+    server.tool('editor_get_viewport', 'Get the editor viewport: visible area, zoom level, pan offset. Also returns the latest buffered selection and document change events.', {}, async () => {
+        if (!editor.isConnected()) {
+            try {
+                await editor.connect();
+            }
+            catch {
+                return { content: [{ type: 'text', text: JSON.stringify({ error: 'Editor not connected' }) }] };
+            }
+        }
+        const viewport = await editor.getViewport();
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify({
+                        ...viewport,
+                        lastSelection: editor.getLastSelection(),
+                        lastDocumentChange: editor.getLastDocumentChange(),
+                    }, null, 2),
+                }],
+        };
+    });
+    // ═══════════════════════════════════════════════
+    // Export Tools
+    // ═══════════════════════════════════════════════
+    server.tool('editor_export_svg', 'Export the current diagram from the editor as a complete SVG. Returns parseable text the agent can read directly — contains state IDs, labels, positions, transitions, colors.', {}, async () => {
+        if (!editor.isConnected()) {
+            try {
+                await editor.connect();
+            }
+            catch {
+                return { content: [{ type: 'text', text: JSON.stringify({ error: 'Editor not connected' }) }] };
+            }
+        }
+        const result = await editor.exportSvg();
+        return { content: [{ type: 'text', text: result.svg }] };
+    });
+    server.tool('editor_export_png', 'Export the current diagram from the editor as a full PNG image at 2x resolution. Unlike editor_screenshot (viewport only), this renders the entire diagram.', {}, async () => {
+        if (!editor.isConnected()) {
+            try {
+                await editor.connect();
+            }
+            catch {
+                return { content: [{ type: 'text', text: JSON.stringify({ error: 'Editor not connected' }) }] };
+            }
+        }
+        const result = await editor.exportPng();
+        return {
+            content: [{ type: 'image', data: result.data, mimeType: 'image/png' }],
+        };
+    });
+    server.tool('editor_export_player_html', 'Export a self-contained interactive HTML player for the current state machine. The HTML includes embedded SVG, SCXML, and JavaScript runtime for live simulation and trace playback. Opens in any browser with zero dependencies.', {
+        exportMode: z.enum(['interactive', 'traces', 'both']).optional().default('interactive')
+            .describe('interactive = live simulation, traces = recorded playback, both = switchable'),
+        selectedTraceIds: z.array(z.string()).optional()
+            .describe('Trace IDs to include when exportMode is "traces" or "both"'),
+    }, async ({ exportMode, selectedTraceIds }) => {
+        if (!editor.isConnected()) {
+            try {
+                await editor.connect();
+            }
+            catch {
+                return { content: [{ type: 'text', text: JSON.stringify({ error: 'Editor not connected' }) }] };
+            }
+        }
+        const result = await editor.exportPlayerHtml({ exportMode, selectedTraceIds });
+        return { content: [{ type: 'text', text: result.html }] };
+    });
+    server.tool('editor_status', 'Check if the VSCXML-Generator editor is running and connected.', {}, async () => {
+        const status = await editor.getStatus();
+        return {
+            content: [{ type: 'text', text: JSON.stringify(status) }],
+        };
+    });
+    // ═══════════════════════════════════════════════
+    // Connection Status Tool
+    // ═══════════════════════════════════════════════
+    server.tool('scxml_status', 'Check the connection status of VSCXML backends (generator, simulator, editor).', {}, async () => {
+        const [genAvail, simAvail, editorStatus] = await Promise.all([
+            generator.isAvailable(),
+            simulator.isAvailable(),
+            editor.getStatus(),
+        ]);
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify({
+                        generator: { connected: genAvail },
+                        simulator: { connected: simAvail, sessionId: simulator.getSessionId() },
+                        editor: editorStatus,
+                    }, null, 2),
+                }],
+        };
+    });
+    return server;
+}
+// ═══════════════════════════════════════════════
+// Trace comparison (pure logic, no backend call)
+// ═══════════════════════════════════════════════
+function compareTraces(expected, actual, ignoreTimestamps) {
+    const differences = [];
+    const maxLen = Math.max(expected.length, actual.length);
+    for (let i = 0; i < maxLen; i++) {
+        const exp = expected[i];
+        const act = actual[i];
+        if (!exp) {
+            differences.push({
+                index: i,
+                expected: exp,
+                actual: act,
+                description: `Extra actual entry: ${act.type}`,
+            });
+            continue;
+        }
+        if (!act) {
+            differences.push({
+                index: i,
+                expected: exp,
+                actual: act,
+                description: `Missing actual entry: ${exp.type}`,
+            });
+            continue;
+        }
+        // Compare entries
+        const expClean = ignoreTimestamps ? { ...exp, timestamp: undefined } : exp;
+        const actClean = ignoreTimestamps ? { ...act, timestamp: undefined } : act;
+        if (JSON.stringify(expClean) !== JSON.stringify(actClean)) {
+            const desc = [];
+            if (exp.type !== act.type)
+                desc.push(`type: ${exp.type} vs ${act.type}`);
+            if (exp.state !== act.state)
+                desc.push(`state: ${exp.state} vs ${act.state}`);
+            if (exp.event !== act.event)
+                desc.push(`event: ${exp.event} vs ${act.event}`);
+            if (exp.from !== act.from)
+                desc.push(`from: ${exp.from} vs ${act.from}`);
+            if (exp.to !== act.to)
+                desc.push(`to: ${exp.to} vs ${act.to}`);
+            differences.push({
+                index: i,
+                expected: exp,
+                actual: act,
+                description: desc.length > 0 ? desc.join(', ') : 'Values differ',
+            });
+        }
+    }
+    return {
+        match: differences.length === 0,
+        differences,
+        summary: differences.length === 0
+            ? `Traces match (${expected.length} entries)`
+            : `${differences.length} difference(s) found in ${maxLen} entries`,
+    };
+}
+//# sourceMappingURL=server.js.map