blockwerk-mcp 0.1.1 → 0.2.2

package/README.md

@@ -0,0 +1,75 @@
+# BlockWerk MCP Server
+
+[![npm version](https://img.shields.io/npm/v/blockwerk-mcp.svg)](https://www.npmjs.com/package/blockwerk-mcp)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+**BlockWerk MCP Server** bridges external AI clients (like Claude Desktop or Cursor) to a live BlockWerk browser tab. This allows an AI to observe and manipulate your block diagrams in real-time.
+
+---
+
+## 🚀 Features
+
+- **Read Canvas**: The AI can see all blocks, connections, and parameters.
+- **Manipulate Canvas**: Add blocks, connect ports, update parameters, and delete blocks.
+- **Simulation Control**: Run simulations, perform frequency sweeps (Bode plots), and analyze system topology.
+- **Layout Engine**: Automatic layout tidying.
+
+## 📦 Installation
+
+You can run it directly via `npx`:
+
+```bash
+npx blockwerk-mcp --session <YOUR_SESSION_ID>
+```
+
+Or install it globally:
+
+```bash
+npm install -g blockwerk-mcp
+```
+
+## 🛠️ Setup
+
+### 1. Get your Session ID
+1. Open [blockwerk.tech](https://blockwerk.tech).
+2. Click on the **AI Assistant** panel (right side).
+3. Select **Connect External AI**.
+4. Copy the provided **Session ID** (e.g., `bw-a1b2c3d4`).
+
+### 2. Configure your Client
+
+#### Claude Desktop
+Add this to your `claude_desktop_config.json`:
+
+```json
+{
+  "mcpServers": {
+    "blockwerk": {
+      "command": "npx",
+      "args": ["-y", "blockwerk-mcp", "--session", "YOUR_SESSION_ID"]
+    }
+  }
+}
+```
+
+#### Cursor
+1. Go to **Settings > Models > MCP**.
+2. Add a new MCP server:
+   - **Name**: BlockWerk
+   - **Type**: command
+   - **Command**: `npx -y blockwerk-mcp --session YOUR_SESSION_ID`
+
+## 👨‍💻 Development
+
+If you want to contribute or run from source:
+
+```bash
+git clone https://github.com/blockwerk/blockwerk
+cd ui/blockwerk/projects/mcp-server
+npm install
+npm run build
+npm run dev -- --session <YOUR_SESSION_ID>
+```
+
+## 📄 License
+MIT

package/dist/index.js

@@ -6,12 +6,23 @@
  * browser tab via the Netlify relay.
  *
  * Usage:
- *   npx @blockwerk/mcp --session bw-a1b2c3d4
- *   npx @blockwerk/mcp --session bw-a1b2c3d4 --relay https://blockwerk.tech
+ *   # Path based (local dev)
+ *   node projects/mcp-server/dist/index.js --session bw-a1b2c3d4
+ *   npx tsx projects/mcp-server/src/index.ts --session bw-a1b2c3d4
+ *
+ *   # npm based (after publishing)
+ *   npx blockwerk-mcp --session bw-a1b2c3d4
  */
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { z } from 'zod';
+import crypto from 'node:crypto';
+import { promisify } from 'node:util';
+import { PostHog } from 'posthog-node';
+const posthog = new PostHog(process.env.POSTHOG_API_KEY ?? '', {
+    host: process.env.POSTHOG_HOST ?? 'https://eu.i.posthog.com',
+});
+const pbkdf2 = promisify(crypto.pbkdf2);
 // ── Config ────────────────────────────────────────────────────────────────────
 const args = process.argv.slice(2);
 const getArg = (flag) => {
@@ -21,24 +32,79 @@ const getArg = (flag) => {
 let SESSION_ID = getArg('--session') ?? process.env.BLOCKWERK_SESSION;
 const RELAY_BASE = (getArg('--relay') ??
     process.env.BLOCKWERK_RELAY ??
-    'https://blockwerk.tech').replace(/\/$/, '');
+    'http://localhost:5173').replace(/\/$/, '');
 const RELAY_URL = `${RELAY_BASE}/api/mcp-relay`;
 if (!SESSION_ID) {
     console.error('[BlockWerk MCP] Warning: No session ID provided at startup.\n' +
         'Use the "configure_bridge" tool to set the session ID at runtime.');
 }
+console.error(`[BlockWerk MCP] Connecting to relay: ${RELAY_URL}`);
+// ── Cryptography ─────────────────────────────────────────────────────────────
+const ITERATIONS = 100000;
+const KEY_LEN = 32; // AES-256
+/**
+ * Derives an AES-256 key from the session ID using PBKDF2.
+ * Uses a per-session salt (first 16 bytes of session ID hashed) to prevent
+ * rainbow table attacks against the static salt.
+ */
+async function deriveKey(password, saltHex) {
+    const salt = saltHex ? Buffer.from(saltHex, 'hex') : crypto.randomBytes(16);
+    const key = await pbkdf2(password, salt, ITERATIONS, KEY_LEN, 'sha256');
+    return { key, saltHex: salt.toString('hex') };
+}
+async function encryptData(data, sessionId) {
+    const { key, saltHex } = await deriveKey(sessionId);
+    const iv = crypto.randomBytes(12);
+    const cipher = crypto.createCipheriv('aes-256-gcm', key, iv);
+    const buffer = Buffer.from(JSON.stringify(data));
+    const encrypted = Buffer.concat([cipher.update(buffer), cipher.final()]);
+    const tag = cipher.getAuthTag();
+    // Format: salt:iv:ciphertext+tag (all hex/base64)
+    const ivHex = iv.toString('hex');
+    const ciphertextBase64 = Buffer.concat([encrypted, tag]).toString('base64');
+    return `${saltHex}:${ivHex}:${ciphertextBase64}`;
+}
+async function decryptData(encryptedString, sessionId) {
+    try {
+        const parts = encryptedString.split(':');
+        if (parts.length < 3)
+            return null;
+        const saltHex = parts[0];
+        const ivHex = parts[1];
+        const ciphertextBase64 = parts[2];
+        const { key } = await deriveKey(sessionId, saltHex);
+        const iv = Buffer.from(ivHex, 'hex');
+        const combined = Buffer.from(ciphertextBase64, 'base64');
+        const ciphertext = combined.subarray(0, combined.length - 16);
+        const tag = combined.subarray(combined.length - 16);
+        const decipher = crypto.createDecipheriv('aes-256-gcm', key, iv);
+        decipher.setAuthTag(tag);
+        const decrypted = Buffer.concat([decipher.update(ciphertext), decipher.final()]);
+        return JSON.parse(decrypted.toString());
+    }
+    catch (e) {
+        console.error('[MCP Crypto] Decryption failed:', e);
+        return null;
+    }
+}
 // ── Relay communication ───────────────────────────────────────────────────────
 const MAX_WAIT_MS = 60000; // total wait before giving up
 async function callBlockWerk(name, input) {
     if (!SESSION_ID) {
         throw new Error('Session ID not configured. Please provide your BlockWerk Session ID first using the "configure_bridge" tool.');
     }
+    posthog.capture({
+        distinctId: SESSION_ID,
+        event: 'mcp_tool_called',
+        properties: { tool: name },
+    });
     const requestId = crypto.randomUUID();
-    // 1. Push command to relay
+    // 1. Push command to relay (ENCRYPTED)
+    const encryptedCmd = await encryptData({ requestId, name, input }, SESSION_ID);
     const pushRes = await fetch(`${RELAY_URL}?session=${SESSION_ID}&type=command`, {
         method: 'POST',
         headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ requestId, name, input }),
+        body: JSON.stringify(encryptedCmd), // Relay accepts string as raw body or JSON string
     });
     if (!pushRes.ok) {
         throw new Error(`Relay rejected command: ${pushRes.status} ${await pushRes.text()}`);
@@ -52,8 +118,12 @@ async function callBlockWerk(name, input) {
             throw new Error(`Relay poll failed: ${pollRes.status}`);
         }
         const data = (await pollRes.json());
-        if (!data.pending) {
-            return typeof data.result === 'string' ? data.result : JSON.stringify(data.result);
+        if (!data.pending && data.result) {
+            // DECRYPT Result
+            const decryptedResult = await decryptData(data.result, SESSION_ID);
+            return typeof decryptedResult === 'string'
+                ? decryptedResult
+                : JSON.stringify(decryptedResult);
         }
         // pending: true — relay timed out but result not yet ready, retry immediately
     }
@@ -62,13 +132,17 @@ async function callBlockWerk(name, input) {
 // ── MCP server ────────────────────────────────────────────────────────────────
 const server = new McpServer({
     name: 'blockwerk',
-    version: '0.1.0',
+    version: '0.2.1',
 });
 // ── Tools ─────────────────────────────────────────────────────────────────────
 server.tool('configure_bridge', 'Connects this AI assistant to a specific BlockWerk browser session.', {
     sessionId: z.string().describe('The Session ID from the BlockWerk UI (e.g. bw-a1b2c3d4)'),
 }, async ({ sessionId }) => {
     SESSION_ID = sessionId;
+    posthog.capture({
+        distinctId: SESSION_ID,
+        event: 'mcp_bridge_configured',
+    });
     return {
         content: [
             {
@@ -166,7 +240,77 @@ server.tool('load_diagram', 'Loads a complete BlockWerk project from a JSON stri
 }, async ({ json }) => ({
     content: [{ type: 'text', text: await callBlockWerk('load_diagram', { json }) }],
 }));
+server.tool('get_signal_data', 'Retrieves time-series data (time and values) for a specific block and channel. Channel 0 is usually the primary signal.', {
+    blockId: z.string().describe('The ID of the block to inspect (e.g. Scope, UPlotScope)'),
+    channel: z.number().int().nonnegative().optional().describe('Channel index, default is 0'),
+}, async ({ blockId, channel }) => ({
+    content: [{ type: 'text', text: await callBlockWerk('getSignalData', { blockId, channel }) }],
+}));
+server.tool('calculate_metrics', 'Calculates step response performance metrics (overshoot, rise time, settling time) for a specific block.', {
+    blockId: z.string().describe('The ID of the block to analyze'),
+    setpoint: z.number().finite().optional().describe('The target setpoint value (default 1.0)'),
+}, async ({ blockId, setpoint }) => ({
+    content: [
+        { type: 'text', text: await callBlockWerk('calculateMetrics', { blockId, setpoint }) },
+    ],
+}));
+server.tool('analyze_topology', 'Analyzes the diagram topology to detect feedback loops, cycles, and connectivity issues.', {}, async () => ({
+    content: [{ type: 'text', text: await callBlockWerk('analyzeTopology', {}) }],
+}));
+server.tool('get_engine_status', 'Returns the current status of the simulation engine (Running, Idle, Error), simulation progress, and identifies any algebraic loops.', {}, async () => ({
+    content: [{ type: 'text', text: await callBlockWerk('get_engine_status', {}) }],
+}));
+server.tool('get_bode_data', 'Performs a frequency sweep analysis to generate Bode plot data (magnitude and phase) for a system.', {
+    inputBlockId: z
+        .string()
+        .describe('The ID of the block providing the sine excitation (e.g. SineWave)'),
+    outputBlockId: z
+        .string()
+        .describe('The ID of the block to measure (e.g. TransferFunction or Scope)'),
+    startFreq: z.number().optional().describe('Start frequency in rad/s (default 0.1)'),
+    endFreq: z.number().optional().describe('End frequency in rad/s (default 100)'),
+    pointsPerDecade: z
+        .number()
+        .int()
+        .optional()
+        .describe('Resolution in points per decade (default 10)'),
+}, async (input) => ({
+    content: [{ type: 'text', text: await callBlockWerk('get_bode_data', input) }],
+}));
+server.tool('get_fft_data', 'Calculates the Fast Fourier Transform (FFT) for a specific signal to analyze its frequency spectrum.', {
+    blockId: z.string().describe('The ID of the block to analyze'),
+    channel: z.number().int().nonnegative().optional().describe('Channel index (default 0)'),
+}, async ({ blockId, channel }) => ({
+    content: [{ type: 'text', text: await callBlockWerk('get_fft_data', { blockId, channel }) }],
+}));
+server.tool('undo_last_ai_action', 'Undoes the last AI action, restoring the canvas to its state before the tool was executed.', {}, async () => ({
+    content: [{ type: 'text', text: await callBlockWerk('undo_last_ai_action', {}) }],
+}));
+server.tool('redo_last_ai_action', 'Redoes the last undone AI action.', {}, async () => ({
+    content: [{ type: 'text', text: await callBlockWerk('redo_last_ai_action', {}) }],
+}));
+server.tool('get_ai_history', 'Returns a summary of recent AI actions with their results and timestamps.', {
+    limit: z
+        .number()
+        .int()
+        .positive()
+        .optional()
+        .describe('Number of recent entries to return (default 10)'),
+}, async ({ limit }) => ({
+    content: [{ type: 'text', text: await callBlockWerk('get_ai_history', { limit }) }],
+}));
 // ── Start ─────────────────────────────────────────────────────────────────────
 const transport = new StdioServerTransport();
 await server.connect(transport);
 console.error(`[BlockWerk MCP] Started — session: ${SESSION_ID || 'PENDING'}, relay: ${RELAY_URL}`);
+posthog.capture({
+    distinctId: SESSION_ID ?? 'anonymous',
+    event: 'mcp_server_started',
+    properties: {
+        relay_url: RELAY_BASE,
+        has_session: !!SESSION_ID,
+    },
+});
+process.on('exit', () => { posthog.shutdown(); });
+process.on('SIGINT', async () => { await posthog.shutdown(); process.exit(0); });
+process.on('SIGTERM', async () => { await posthog.shutdown(); process.exit(0); });

package/package.json

@@ -1,26 +1,47 @@
-{
-  "name": "blockwerk-mcp",
-  "version": "0.1.1",
-  "description": "MCP server for BlockWerk — lets Claude Desktop and Cursor control a live BlockWerk browser tab",
-  "type": "module",
-  "bin": {
-    "blockwerk-mcp": "dist/index.js"
-  },
-  "scripts": {
-    "build": "tsc",
-    "dev": "tsx src/index.ts",
-    "start": "node dist/index.js"
-  },
-  "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.15.0",
-    "zod": "^3.25.0"
-  },
-  "devDependencies": {
-    "@types/node": "^22.0.0",
-    "tsx": "^4.19.0",
-    "typescript": "~5.9.3"
-  },
-  "engines": {
-    "node": ">=18"
-  }
-}
+{
+  "name": "blockwerk-mcp",
+  "version": "0.2.2",
+  "description": "MCP server for BlockWerk — lets Claude Desktop and Cursor control a live BlockWerk browser tab",
+  "homepage": "https://blockwerk.tech",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/blockwerk/blockwerk.git"
+  },
+  "bugs": {
+    "url": "https://github.com/blockwerk/blockwerk/issues"
+  },
+  "keywords": [
+    "mcp",
+    "blockwerk",
+    "block-diagram",
+    "simulation",
+    "control",
+    "ai",
+    "claude",
+    "cursor"
+  ],
+  "author": "BlockWerk Team",
+  "license": "MIT",
+  "type": "module",
+  "bin": {
+    "blockwerk-mcp": "dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsx src/index.ts",
+    "start": "node dist/index.js"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.15.0",
+    "posthog-node": "^5.28.11",
+    "zod": "^3.25.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "tsx": "^4.19.0",
+    "typescript": "~5.9.3"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}

package/src/index.ts

@@ -6,13 +6,26 @@
  * browser tab via the Netlify relay.
  *
  * Usage:
- *   npx @blockwerk/mcp --session bw-a1b2c3d4
- *   npx @blockwerk/mcp --session bw-a1b2c3d4 --relay https://blockwerk.tech
+ *   # Path based (local dev)
+ *   node projects/mcp-server/dist/index.js --session bw-a1b2c3d4
+ *   npx tsx projects/mcp-server/src/index.ts --session bw-a1b2c3d4
+ *
+ *   # npm based (after publishing)
+ *   npx blockwerk-mcp --session bw-a1b2c3d4
  */
 
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { z } from 'zod';
+import crypto from 'node:crypto';
+import { promisify } from 'node:util';
+import { PostHog } from 'posthog-node';
+
+const posthog = new PostHog(process.env.POSTHOG_API_KEY ?? '', {
+  host: process.env.POSTHOG_HOST ?? 'https://eu.i.posthog.com',
+});
+
+const pbkdf2 = promisify(crypto.pbkdf2);
 
 // ── Config ────────────────────────────────────────────────────────────────────
 
@@ -26,7 +39,7 @@ let SESSION_ID = getArg('--session') ?? process.env.BLOCKWERK_SESSION;
 const RELAY_BASE = (
   getArg('--relay') ??
   process.env.BLOCKWERK_RELAY ??
-  'https://blockwerk.tech'
+  'http://localhost:5173'
 ).replace(/\/$/, '');
 const RELAY_URL = `${RELAY_BASE}/api/mcp-relay`;
 
@@ -37,6 +50,70 @@ if (!SESSION_ID) {
   );
 }
 
+console.error(`[BlockWerk MCP] Connecting to relay: ${RELAY_URL}`);
+
+// ── Cryptography ─────────────────────────────────────────────────────────────
+
+const ITERATIONS = 100000;
+const KEY_LEN = 32; // AES-256
+
+/**
+ * Derives an AES-256 key from the session ID using PBKDF2.
+ * Uses a per-session salt (first 16 bytes of session ID hashed) to prevent
+ * rainbow table attacks against the static salt.
+ */
+async function deriveKey(
+  password: string,
+  saltHex?: string
+): Promise<{ key: Buffer; saltHex: string }> {
+  const salt = saltHex ? Buffer.from(saltHex, 'hex') : crypto.randomBytes(16);
+  const key = await pbkdf2(password, salt, ITERATIONS, KEY_LEN, 'sha256');
+  return { key, saltHex: salt.toString('hex') };
+}
+
+async function encryptData(data: unknown, sessionId: string): Promise<string> {
+  const { key, saltHex } = await deriveKey(sessionId);
+  const iv = crypto.randomBytes(12);
+  const cipher = crypto.createCipheriv('aes-256-gcm', key, iv);
+
+  const buffer = Buffer.from(JSON.stringify(data));
+  const encrypted = Buffer.concat([cipher.update(buffer), cipher.final()]);
+  const tag = cipher.getAuthTag();
+
+  // Format: salt:iv:ciphertext+tag (all hex/base64)
+  const ivHex = iv.toString('hex');
+  const ciphertextBase64 = Buffer.concat([encrypted, tag]).toString('base64');
+
+  return `${saltHex}:${ivHex}:${ciphertextBase64}`;
+}
+
+async function decryptData(encryptedString: string, sessionId: string): Promise<unknown> {
+  try {
+    const parts = encryptedString.split(':');
+    if (parts.length < 3) return null;
+
+    const saltHex = parts[0];
+    const ivHex = parts[1];
+    const ciphertextBase64 = parts[2];
+
+    const { key } = await deriveKey(sessionId, saltHex);
+    const iv = Buffer.from(ivHex, 'hex');
+    const combined = Buffer.from(ciphertextBase64, 'base64');
+
+    const ciphertext = combined.subarray(0, combined.length - 16);
+    const tag = combined.subarray(combined.length - 16);
+
+    const decipher = crypto.createDecipheriv('aes-256-gcm', key, iv);
+    decipher.setAuthTag(tag);
+
+    const decrypted = Buffer.concat([decipher.update(ciphertext), decipher.final()]);
+    return JSON.parse(decrypted.toString());
+  } catch (e) {
+    console.error('[MCP Crypto] Decryption failed:', e);
+    return null;
+  }
+}
+
 // ── Relay communication ───────────────────────────────────────────────────────
 
 const MAX_WAIT_MS = 60000; // total wait before giving up
@@ -47,13 +124,20 @@ async function callBlockWerk(name: string, input: Record<string, unknown>): Prom
       'Session ID not configured. Please provide your BlockWerk Session ID first using the "configure_bridge" tool.'
     );
   }
+  posthog.capture({
+    distinctId: SESSION_ID,
+    event: 'mcp_tool_called',
+    properties: { tool: name },
+  });
   const requestId = crypto.randomUUID();
 
-  // 1. Push command to relay
+  // 1. Push command to relay (ENCRYPTED)
+  const encryptedCmd = await encryptData({ requestId, name, input }, SESSION_ID);
+
   const pushRes = await fetch(`${RELAY_URL}?session=${SESSION_ID}&type=command`, {
     method: 'POST',
     headers: { 'Content-Type': 'application/json' },
-    body: JSON.stringify({ requestId, name, input }),
+    body: JSON.stringify(encryptedCmd), // Relay accepts string as raw body or JSON string
   });
 
   if (!pushRes.ok) {
@@ -73,10 +157,14 @@ async function callBlockWerk(name: string, input: Record<string, unknown>): Prom
       throw new Error(`Relay poll failed: ${pollRes.status}`);
     }
 
-    const data = (await pollRes.json()) as { pending?: boolean; result?: unknown };
+    const data = (await pollRes.json()) as { pending?: boolean; result?: string };
 
-    if (!data.pending) {
-      return typeof data.result === 'string' ? data.result : JSON.stringify(data.result);
+    if (!data.pending && data.result) {
+      // DECRYPT Result
+      const decryptedResult = await decryptData(data.result, SESSION_ID);
+      return typeof decryptedResult === 'string'
+        ? decryptedResult
+        : JSON.stringify(decryptedResult);
     }
 
     // pending: true — relay timed out but result not yet ready, retry immediately
@@ -91,7 +179,7 @@ async function callBlockWerk(name: string, input: Record<string, unknown>): Prom
 
 const server = new McpServer({
   name: 'blockwerk',
-  version: '0.1.0',
+  version: '0.2.1',
 });
 
 // ── Tools ─────────────────────────────────────────────────────────────────────
@@ -104,6 +192,10 @@ server.tool(
   },
   async ({ sessionId }) => {
     SESSION_ID = sessionId;
+    posthog.capture({
+      distinctId: SESSION_ID,
+      event: 'mcp_bridge_configured',
+    });
     return {
       content: [
         {
@@ -265,8 +357,129 @@ server.tool(
   })
 );
 
+server.tool(
+  'get_signal_data',
+  'Retrieves time-series data (time and values) for a specific block and channel. Channel 0 is usually the primary signal.',
+  {
+    blockId: z.string().describe('The ID of the block to inspect (e.g. Scope, UPlotScope)'),
+    channel: z.number().int().nonnegative().optional().describe('Channel index, default is 0'),
+  },
+  async ({ blockId, channel }) => ({
+    content: [{ type: 'text', text: await callBlockWerk('getSignalData', { blockId, channel }) }],
+  })
+);
+
+server.tool(
+  'calculate_metrics',
+  'Calculates step response performance metrics (overshoot, rise time, settling time) for a specific block.',
+  {
+    blockId: z.string().describe('The ID of the block to analyze'),
+    setpoint: z.number().finite().optional().describe('The target setpoint value (default 1.0)'),
+  },
+  async ({ blockId, setpoint }) => ({
+    content: [
+      { type: 'text', text: await callBlockWerk('calculateMetrics', { blockId, setpoint }) },
+    ],
+  })
+);
+
+server.tool(
+  'analyze_topology',
+  'Analyzes the diagram topology to detect feedback loops, cycles, and connectivity issues.',
+  {},
+  async () => ({
+    content: [{ type: 'text', text: await callBlockWerk('analyzeTopology', {}) }],
+  })
+);
+
+server.tool(
+  'get_engine_status',
+  'Returns the current status of the simulation engine (Running, Idle, Error), simulation progress, and identifies any algebraic loops.',
+  {},
+  async () => ({
+    content: [{ type: 'text', text: await callBlockWerk('get_engine_status', {}) }],
+  })
+);
+
+server.tool(
+  'get_bode_data',
+  'Performs a frequency sweep analysis to generate Bode plot data (magnitude and phase) for a system.',
+  {
+    inputBlockId: z
+      .string()
+      .describe('The ID of the block providing the sine excitation (e.g. SineWave)'),
+    outputBlockId: z
+      .string()
+      .describe('The ID of the block to measure (e.g. TransferFunction or Scope)'),
+    startFreq: z.number().optional().describe('Start frequency in rad/s (default 0.1)'),
+    endFreq: z.number().optional().describe('End frequency in rad/s (default 100)'),
+    pointsPerDecade: z
+      .number()
+      .int()
+      .optional()
+      .describe('Resolution in points per decade (default 10)'),
+  },
+  async (input) => ({
+    content: [{ type: 'text', text: await callBlockWerk('get_bode_data', input) }],
+  })
+);
+
+server.tool(
+  'get_fft_data',
+  'Calculates the Fast Fourier Transform (FFT) for a specific signal to analyze its frequency spectrum.',
+  {
+    blockId: z.string().describe('The ID of the block to analyze'),
+    channel: z.number().int().nonnegative().optional().describe('Channel index (default 0)'),
+  },
+  async ({ blockId, channel }) => ({
+    content: [{ type: 'text', text: await callBlockWerk('get_fft_data', { blockId, channel }) }],
+  })
+);
+
+server.tool(
+  'undo_last_ai_action',
+  'Undoes the last AI action, restoring the canvas to its state before the tool was executed.',
+  {},
+  async () => ({
+    content: [{ type: 'text', text: await callBlockWerk('undo_last_ai_action', {}) }],
+  })
+);
+
+server.tool('redo_last_ai_action', 'Redoes the last undone AI action.', {}, async () => ({
+  content: [{ type: 'text', text: await callBlockWerk('redo_last_ai_action', {}) }],
+}));
+
+server.tool(
+  'get_ai_history',
+  'Returns a summary of recent AI actions with their results and timestamps.',
+  {
+    limit: z
+      .number()
+      .int()
+      .positive()
+      .optional()
+      .describe('Number of recent entries to return (default 10)'),
+  },
+  async ({ limit }) => ({
+    content: [{ type: 'text', text: await callBlockWerk('get_ai_history', { limit }) }],
+  })
+);
+
 // ── Start ─────────────────────────────────────────────────────────────────────
 
 const transport = new StdioServerTransport();
 await server.connect(transport);
 console.error(`[BlockWerk MCP] Started — session: ${SESSION_ID || 'PENDING'}, relay: ${RELAY_URL}`);
+
+posthog.capture({
+  distinctId: SESSION_ID ?? 'anonymous',
+  event: 'mcp_server_started',
+  properties: {
+    relay_url: RELAY_BASE,
+    has_session: !!SESSION_ID,
+  },
+});
+
+process.on('exit', () => { posthog.shutdown(); });
+process.on('SIGINT', async () => { await posthog.shutdown(); process.exit(0); });
+process.on('SIGTERM', async () => { await posthog.shutdown(); process.exit(0); });

package/tsconfig.json

@@ -1,13 +1,13 @@
-{
-  "compilerOptions": {
-    "target": "ES2022",
-    "module": "NodeNext",
-    "moduleResolution": "NodeNext",
-    "outDir": "dist",
-    "rootDir": "src",
-    "strict": true,
-    "esModuleInterop": true,
-    "skipLibCheck": true
-  },
-  "include": ["src"]
-}
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "outDir": "dist",
+    "rootDir": "src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true
+  },
+  "include": ["src"]
+}