@mixofreality/live-mcp 1.0.0 → 1.1.1

package/dist/index.js

@@ -1,32 +1,350 @@
 #!/usr/bin/env node
-// MCP server entry point
-import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { BridgeClient } from './bridge-client.js';
-import { registerAllTools } from './tools/index.js';
-const BRIDGE_HOST = process.env['LIVE_MCP_BRIDGE_HOST'] ?? '127.0.0.1';
-const BRIDGE_PORT = parseInt(process.env['LIVE_MCP_BRIDGE_PORT'] ?? '19740', 10);
-const server = new McpServer({
-    name: 'live-mcp',
-    version: '1.0.0',
-}, {
+
+// src/index.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// src/bridge-client.ts
+import * as net from "net";
+import { randomUUID } from "crypto";
+
+// ../../../shared/max4live-nodescript-ts/dist/bridge-protocol.js
+function isBridgeNotification(msg) {
+  return "notification" in msg;
+}
+
+// src/bridge-client.ts
+var BridgeClient = class {
+  constructor(host, port) {
+    this.host = host;
+    this.port = port;
+  }
+  socket = null;
+  buffer = "";
+  pending = /* @__PURE__ */ new Map();
+  notificationListeners = [];
+  async connect() {
+    return new Promise((resolve, reject) => {
+      const socket = net.createConnection({ host: this.host, port: this.port });
+      socket.once("connect", () => {
+        this.socket = socket;
+        resolve();
+      });
+      socket.once("error", reject);
+      socket.on("data", (data) => this.handleData(data.toString()));
+      socket.on("close", () => {
+        this.socket = null;
+        for (const [, { reject: rej }] of this.pending) {
+          rej(new Error("Bridge connection closed"));
+        }
+        this.pending.clear();
+      });
+    });
+  }
+  async disconnect() {
+    if (this.socket) {
+      return new Promise((resolve) => {
+        this.socket.end(() => resolve());
+      });
+    }
+  }
+  isConnected() {
+    return this.socket !== null && !this.socket.destroyed;
+  }
+  async request(method, params) {
+    if (!this.isConnected()) {
+      throw new Error("Not connected to bridge");
+    }
+    const id = randomUUID();
+    const request = JSON.stringify({ id, method, params });
+    return new Promise((resolve, reject) => {
+      this.pending.set(id, { resolve, reject });
+      this.socket.write(request + "\n");
+    });
+  }
+  onNotification(listener) {
+    this.notificationListeners.push(listener);
+  }
+  handleData(data) {
+    this.buffer += data;
+    const lines = this.buffer.split("\n");
+    this.buffer = lines.pop();
+    for (const line of lines) {
+      if (!line.trim()) continue;
+      let msg;
+      try {
+        msg = JSON.parse(line);
+      } catch {
+        continue;
+      }
+      if (isBridgeNotification(msg)) {
+        for (const listener of this.notificationListeners) {
+          listener(msg);
+        }
+      } else {
+        const response = msg;
+        const pendingReq = this.pending.get(response.id);
+        if (pendingReq) {
+          this.pending.delete(response.id);
+          if (response.error) {
+            pendingReq.reject(new Error(response.error.message));
+          } else if (response.result) {
+            pendingReq.resolve(response.result);
+          }
+        }
+      }
+    }
+  }
+};
+
+// src/tools/get-property.ts
+import { z } from "zod";
+function registerGetProperty(server2, bridge2) {
+  server2.registerTool(
+    "get_property",
+    {
+      title: "Get LOM Property",
+      description: 'Read a property from a Live Object Model object. Use LOM paths like "live_set", "live_set tracks 0", "live_set tracks 0 devices 1 parameters 2".',
+      inputSchema: {
+        path: z.string().describe('LOM path (e.g. "live_set tracks 0")'),
+        property: z.string().describe('Property name (e.g. "tempo", "name")')
+      }
+    },
+    async ({ path, property }) => {
+      try {
+        const result = await bridge2.request("get_property", {
+          path,
+          property
+        });
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return { content: [{ type: "text", text: `Error: ${message}` }], isError: true };
+      }
+    }
+  );
+}
+
+// src/tools/set-property.ts
+import { z as z2 } from "zod";
+function registerSetProperty(server2, bridge2) {
+  server2.registerTool(
+    "set_property",
+    {
+      title: "Set LOM Property",
+      description: 'Set a property on a Live Object Model object. The value should be a JSON string that will be parsed (e.g. "120.0", "\\"hello\\"", "true").',
+      inputSchema: {
+        path: z2.string().describe('LOM path (e.g. "live_set tracks 0")'),
+        property: z2.string().describe('Property name (e.g. "tempo", "name")'),
+        value: z2.string().describe('Value as JSON string (e.g. "120.0", "\\"hello\\"", "true")')
+      }
+    },
+    async ({ path, property, value }) => {
+      try {
+        const parsed = JSON.parse(value);
+        const result = await bridge2.request("set_property", {
+          path,
+          property,
+          value: parsed
+        });
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return { content: [{ type: "text", text: `Error: ${message}` }], isError: true };
+      }
+    }
+  );
+}
+
+// src/tools/call-function.ts
+import { z as z3 } from "zod";
+function registerCallFunction(server2, bridge2) {
+  server2.registerTool(
+    "call_function",
+    {
+      title: "Call LOM Function",
+      description: 'Call a function on a Live Object Model object. Args is an optional JSON array string (e.g. "[1, 2]").',
+      inputSchema: {
+        path: z3.string().describe('LOM path (e.g. "live_set tracks 0")'),
+        function: z3.string().describe('Function name (e.g. "fire", "stop")'),
+        args: z3.string().optional().describe('Arguments as JSON array string (e.g. "[1, \\"hello\\"]")')
+      }
+    },
+    async ({ path, function: fn, args }) => {
+      try {
+        const parsedArgs = args ? JSON.parse(args) : void 0;
+        const result = await bridge2.request("call_function", {
+          path,
+          function: fn,
+          args: parsedArgs
+        });
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return { content: [{ type: "text", text: `Error: ${message}` }], isError: true };
+      }
+    }
+  );
+}
+
+// src/tools/get-children.ts
+import { z as z4 } from "zod";
+function registerGetChildren(server2, bridge2) {
+  server2.registerTool(
+    "get_children",
+    {
+      title: "Get LOM Children",
+      description: "List the children of a Live Object Model object. Returns child paths for navigation.",
+      inputSchema: {
+        path: z4.string().describe('LOM path (e.g. "live_set", "live_set tracks 0")')
+      }
+    },
+    async ({ path }) => {
+      try {
+        const result = await bridge2.request("get_children", {
+          path
+        });
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return { content: [{ type: "text", text: `Error: ${message}` }], isError: true };
+      }
+    }
+  );
+}
+
+// src/tools/observe.ts
+import { z as z5 } from "zod";
+function registerObserve(server2, bridge2) {
+  server2.registerTool(
+    "observe",
+    {
+      title: "Observe LOM Property",
+      description: "Subscribe to changes on a Live Object Model property. Returns a subscriptionId for later unobserve.",
+      inputSchema: {
+        path: z5.string().describe('LOM path (e.g. "live_set tracks 0")'),
+        property: z5.string().describe('Property name to observe (e.g. "tempo", "name")')
+      }
+    },
+    async ({ path, property }) => {
+      try {
+        const result = await bridge2.request("observe", {
+          path,
+          property
+        });
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return { content: [{ type: "text", text: `Error: ${message}` }], isError: true };
+      }
+    }
+  );
+}
+
+// src/tools/unobserve.ts
+import { z as z6 } from "zod";
+function registerUnobserve(server2, bridge2) {
+  server2.registerTool(
+    "unobserve",
+    {
+      title: "Unobserve LOM Property",
+      description: "Unsubscribe from a previously observed Live Object Model property using its subscriptionId.",
+      inputSchema: {
+        subscriptionId: z6.string().describe("Subscription ID returned from observe")
+      }
+    },
+    async ({ subscriptionId }) => {
+      try {
+        const result = await bridge2.request("unobserve", { subscriptionId });
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return { content: [{ type: "text", text: `Error: ${message}` }], isError: true };
+      }
+    }
+  );
+}
+
+// src/tools/index.ts
+function registerAllTools(server2, bridge2) {
+  registerGetProperty(server2, bridge2);
+  registerSetProperty(server2, bridge2);
+  registerCallFunction(server2, bridge2);
+  registerGetChildren(server2, bridge2);
+  registerObserve(server2, bridge2);
+  registerUnobserve(server2, bridge2);
+}
+
+// src/index.ts
+var BRIDGE_HOST = process.env["LIVE_MCP_BRIDGE_HOST"] ?? "127.0.0.1";
+var BRIDGE_PORT = parseInt(process.env["LIVE_MCP_BRIDGE_PORT"] ?? "19740", 10);
+var server = new McpServer(
+  {
+    name: "live-mcp",
+    version: "1.0.0"
+  },
+  {
     capabilities: { logging: {} },
-});
-const bridge = new BridgeClient(BRIDGE_HOST, BRIDGE_PORT);
+    instructions: `Live MCP controls Ableton Live through the Live Object Model (LOM).
+Full API reference: https://docs.cycling74.com/apiref/lom/
+User guide: https://docs.cycling74.com/userguide/
+
+## Path Syntax
+
+Paths use space-separated navigation from root objects:
+- \`live_set\` \u2014 the Song
+- \`live_app\` \u2014 the Application
+- \`live_set tracks 0\` \u2014 first track
+- \`live_set tracks 0 clip_slots 2 clip\` \u2014 clip in slot 2 of track 0
+- \`live_set tracks 0 devices 1 parameters 3\` \u2014 parameter 3 of device 1
+- \`live_set master_track\` \u2014 master track
+- \`live_set return_tracks 0\` \u2014 first return track
+- \`live_set scenes 0\` \u2014 first scene
+
+## Object Hierarchy
+
+Song (live_set)
+\u251C\u2500\u2500 tracks[] \u2192 Track
+\u2502   \u251C\u2500\u2500 clip_slots[] \u2192 ClipSlot \u2192 clip \u2192 Clip
+\u2502   \u251C\u2500\u2500 devices[] \u2192 Device (or RackDevice, SimplerDevice, PluginDevice, MaxDevice)
+\u2502   \u2502   \u251C\u2500\u2500 parameters[] \u2192 DeviceParameter
+\u2502   \u2502   \u251C\u2500\u2500 chains[] \u2192 Chain \u2192 devices[], mixer_device (racks only)
+\u2502   \u2502   \u251C\u2500\u2500 drum_pads[] \u2192 DrumPad \u2192 chains[] \u2192 DrumChain (drum racks only)
+\u2502   \u2502   \u2514\u2500\u2500 return_chains[] \u2192 Chain (racks only)
+\u2502   \u2514\u2500\u2500 mixer_device \u2192 MixerDevice (volume, panning, sends)
+\u251C\u2500\u2500 return_tracks[] \u2192 Track
+\u251C\u2500\u2500 master_track \u2192 Track
+\u251C\u2500\u2500 scenes[] \u2192 Scene
+\u251C\u2500\u2500 cue_points[] \u2192 CuePoint
+\u2514\u2500\u2500 groove_pool \u2192 GroovePool \u2192 grooves[]
+Application (live_app)
+\u251C\u2500\u2500 view \u2192 Application.View
+\u2514\u2500\u2500 control_surfaces[]
+
+## Workflow
+
+1. Use get_children to discover what's available at any path
+2. Use get_property / set_property to read/write values
+3. Use call_function to invoke actions (fire, stop, create, delete, etc.)
+4. Consult https://docs.cycling74.com/apiref/lom/<classname>/ for property and function details on specific classes`
+  }
+);
+var bridge = new BridgeClient(BRIDGE_HOST, BRIDGE_PORT);
 registerAllTools(server, bridge);
 async function main() {
-    try {
-        await bridge.connect();
-        console.error('Connected to M4L bridge');
-    }
-    catch {
-        console.error(`Warning: Could not connect to M4L bridge at ${BRIDGE_HOST}:${BRIDGE_PORT}. Tools will fail until bridge is available.`);
-    }
-    const transport = new StdioServerTransport();
-    await server.connect(transport);
-    console.error('Live MCP Server running on stdio');
+  try {
+    await bridge.connect();
+    console.error("Connected to M4L bridge");
+  } catch {
+    console.error(
+      `Warning: Could not connect to M4L bridge at ${BRIDGE_HOST}:${BRIDGE_PORT}. Tools will fail until bridge is available.`
+    );
+  }
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error("Live MCP Server running on stdio");
 }
 main().catch((error) => {
-    console.error('Fatal error:', error);
-    process.exit(1);
+  console.error("Fatal error:", error);
+  process.exit(1);
 });

package/package.json

@@ -1,14 +1,16 @@
 {
   "name": "@mixofreality/live-mcp",
-  "version": "1.0.0",
+  "version": "1.1.1",
   "type": "module",
   "main": "./dist/index.js",
   "bin": {
     "live-mcp": "./dist/index.js"
   },
-  "files": ["dist"],
+  "files": [
+    "dist"
+  ],
   "scripts": {
-    "build": "tsc",
+    "build": "tsup",
     "dev": "node --watch dist/index.js",
     "typecheck": "tsc --noEmit",
     "test": "vitest run",
@@ -16,7 +18,13 @@
     "check": "npm run typecheck && npm run test",
     "prepublishOnly": "npm run check && npm run build"
   },
-  "keywords": ["mcp", "ableton", "live", "max4live", "lom"],
+  "keywords": [
+    "mcp",
+    "ableton",
+    "live",
+    "max4live",
+    "lom"
+  ],
   "license": "MIT",
   "description": "MCP server for controlling Ableton Live via the Live Object Model",
   "dependencies": {
@@ -24,9 +32,10 @@
     "zod": "^3.25.0"
   },
   "devDependencies": {
-    "typescript": "~5.9.3",
-    "vitest": "^4.0.16",
+    "@mixofreality/max4live-nodescript-ts": "file:../../../shared/max4live-nodescript-ts",
     "@types/node": "^22.0.0",
-    "@mixofreality/max4live-nodescript-ts": "file:../../../shared/max4live-nodescript-ts"
+    "tsup": "^8.5.1",
+    "typescript": "~5.9.3",
+    "vitest": "^4.0.16"
   }
 }

package/dist/__tests__/bridge-client.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/__tests__/bridge-client.test.js

@@ -1,110 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import * as net from 'node:net';
-import { BridgeClient } from '../bridge-client.js';
-describe('BridgeClient', () => {
-    let mockServer;
-    let serverPort;
-    beforeEach(async () => {
-        mockServer = net.createServer();
-        await new Promise((resolve) => {
-            mockServer.listen(0, '127.0.0.1', () => resolve());
-        });
-        const addr = mockServer.address();
-        serverPort = addr.port;
-    });
-    afterEach(async () => {
-        await new Promise((resolve) => {
-            mockServer.close(() => resolve());
-        });
-    });
-    it('should connect to the bridge server', async () => {
-        const serverGotConnection = new Promise((resolve) => {
-            mockServer.on('connection', () => resolve());
-        });
-        const client = new BridgeClient('127.0.0.1', serverPort);
-        await client.connect();
-        await serverGotConnection;
-        expect(client.isConnected()).toBe(true);
-        await client.disconnect();
-    });
-    it('should send a request and receive a response', async () => {
-        mockServer.on('connection', (socket) => {
-            let buffer = '';
-            socket.on('data', (data) => {
-                buffer += data.toString();
-                const lines = buffer.split('\n');
-                buffer = lines.pop();
-                for (const line of lines) {
-                    if (line.trim()) {
-                        const req = JSON.parse(line);
-                        const response = JSON.stringify({ id: req.id, result: { value: 120 } });
-                        socket.write(response + '\n');
-                    }
-                }
-            });
-        });
-        const client = new BridgeClient('127.0.0.1', serverPort);
-        await client.connect();
-        const result = await client.request('get_property', {
-            path: 'live_set',
-            property: 'tempo',
-        });
-        expect(result).toEqual({ value: 120 });
-        await client.disconnect();
-    });
-    it('should handle bridge error responses', async () => {
-        mockServer.on('connection', (socket) => {
-            let buffer = '';
-            socket.on('data', (data) => {
-                buffer += data.toString();
-                const lines = buffer.split('\n');
-                buffer = lines.pop();
-                for (const line of lines) {
-                    if (line.trim()) {
-                        const req = JSON.parse(line);
-                        const response = JSON.stringify({
-                            id: req.id,
-                            error: { code: -1, message: 'Object not found' },
-                        });
-                        socket.write(response + '\n');
-                    }
-                }
-            });
-        });
-        const client = new BridgeClient('127.0.0.1', serverPort);
-        await client.connect();
-        await expect(client.request('get_property', { path: 'live_set tracks 99', property: 'name' })).rejects.toThrow('Object not found');
-        await client.disconnect();
-    });
-    it('should emit notifications for property changes', async () => {
-        mockServer.on('connection', (socket) => {
-            setTimeout(() => {
-                const notification = JSON.stringify({
-                    notification: 'property_changed',
-                    subscriptionId: 'sub-1',
-                    path: 'live_set',
-                    property: 'tempo',
-                    value: 140,
-                });
-                socket.write(notification + '\n');
-            }, 50);
-        });
-        const client = new BridgeClient('127.0.0.1', serverPort);
-        await client.connect();
-        const notification = await new Promise((resolve) => {
-            client.onNotification((n) => resolve(n));
-        });
-        expect(notification).toEqual({
-            notification: 'property_changed',
-            subscriptionId: 'sub-1',
-            path: 'live_set',
-            property: 'tempo',
-            value: 140,
-        });
-        await client.disconnect();
-    });
-    it('should report disconnected when not connected', () => {
-        const client = new BridgeClient('127.0.0.1', 0);
-        expect(client.isConnected()).toBe(false);
-    });
-});

package/dist/bridge-client.d.ts

@@ -1,16 +0,0 @@
-import type { BridgeMethod, BridgeRequestParams, BridgeNotification, BridgeResult } from '@mixofreality/max4live-nodescript-ts';
-export declare class BridgeClient {
-    private readonly host;
-    private readonly port;
-    private socket;
-    private buffer;
-    private pending;
-    private notificationListeners;
-    constructor(host: string, port: number);
-    connect(): Promise<void>;
-    disconnect(): Promise<void>;
-    isConnected(): boolean;
-    request(method: BridgeMethod, params: BridgeRequestParams): Promise<BridgeResult>;
-    onNotification(listener: (notification: BridgeNotification) => void): void;
-    private handleData;
-}

package/dist/bridge-client.js

@@ -1,91 +0,0 @@
-import * as net from 'node:net';
-import { randomUUID } from 'node:crypto';
-import { isBridgeNotification } from '@mixofreality/max4live-nodescript-ts';
-export class BridgeClient {
-    host;
-    port;
-    socket = null;
-    buffer = '';
-    pending = new Map();
-    notificationListeners = [];
-    constructor(host, port) {
-        this.host = host;
-        this.port = port;
-    }
-    async connect() {
-        return new Promise((resolve, reject) => {
-            const socket = net.createConnection({ host: this.host, port: this.port });
-            socket.once('connect', () => {
-                this.socket = socket;
-                resolve();
-            });
-            socket.once('error', reject);
-            socket.on('data', (data) => this.handleData(data.toString()));
-            socket.on('close', () => {
-                this.socket = null;
-                for (const [, { reject: rej }] of this.pending) {
-                    rej(new Error('Bridge connection closed'));
-                }
-                this.pending.clear();
-            });
-        });
-    }
-    async disconnect() {
-        if (this.socket) {
-            return new Promise((resolve) => {
-                this.socket.end(() => resolve());
-            });
-        }
-    }
-    isConnected() {
-        return this.socket !== null && !this.socket.destroyed;
-    }
-    async request(method, params) {
-        if (!this.isConnected()) {
-            throw new Error('Not connected to bridge');
-        }
-        const id = randomUUID();
-        const request = JSON.stringify({ id, method, params });
-        return new Promise((resolve, reject) => {
-            this.pending.set(id, { resolve, reject });
-            this.socket.write(request + '\n');
-        });
-    }
-    onNotification(listener) {
-        this.notificationListeners.push(listener);
-    }
-    handleData(data) {
-        this.buffer += data;
-        const lines = this.buffer.split('\n');
-        this.buffer = lines.pop();
-        for (const line of lines) {
-            if (!line.trim())
-                continue;
-            let msg;
-            try {
-                msg = JSON.parse(line);
-            }
-            catch {
-                continue;
-            }
-            if (isBridgeNotification(msg)) {
-                for (const listener of this.notificationListeners) {
-                    listener(msg);
-                }
-            }
-            else {
-                const response = msg;
-                const pendingReq = this.pending.get(response.id);
-                if (pendingReq) {
-                    this.pending.delete(response.id);
-                    if (response.error) {
-                        pendingReq.reject(new Error(response.error.message));
-                    }
-                    else if (response.result) {
-                        pendingReq.resolve(response.result);
-                    }
-                }
-            }
-        }
-    }
-}

package/dist/index.d.ts

@@ -1,2 +0,0 @@
-#!/usr/bin/env node
-export {};

package/dist/tools/call-function.d.ts

@@ -1,3 +0,0 @@
-import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import type { BridgeClient } from '../bridge-client.js';
-export declare function registerCallFunction(server: McpServer, bridge: BridgeClient): void;

package/dist/tools/call-function.js

@@ -1,31 +0,0 @@
-import { z } from 'zod';
-export function registerCallFunction(server, bridge) {
-    server.registerTool('call_function', {
-        title: 'Call LOM Function',
-        description: 'Call a function on a Live Object Model object. Args is an optional JSON array string (e.g. "[1, 2]").',
-        inputSchema: {
-            path: z.string().describe('LOM path (e.g. "live_set tracks 0")'),
-            function: z.string().describe('Function name (e.g. "fire", "stop")'),
-            args: z
-                .string()
-                .optional()
-                .describe('Arguments as JSON array string (e.g. "[1, \\"hello\\"]")'),
-        },
-    }, async ({ path, function: fn, args }) => {
-        try {
-            const parsedArgs = args
-                ? JSON.parse(args)
-                : undefined;
-            const result = await bridge.request('call_function', {
-                path: path,
-                function: fn,
-                args: parsedArgs,
-            });
-            return { content: [{ type: 'text', text: JSON.stringify(result) }] };
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            return { content: [{ type: 'text', text: `Error: ${message}` }], isError: true };
-        }
-    });
-}

package/dist/tools/get-children.d.ts

@@ -1,3 +0,0 @@
-import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import type { BridgeClient } from '../bridge-client.js';
-export declare function registerGetChildren(server: McpServer, bridge: BridgeClient): void;

package/dist/tools/get-children.js

@@ -1,21 +0,0 @@
-import { z } from 'zod';
-export function registerGetChildren(server, bridge) {
-    server.registerTool('get_children', {
-        title: 'Get LOM Children',
-        description: 'List the children of a Live Object Model object. Returns child paths for navigation.',
-        inputSchema: {
-            path: z.string().describe('LOM path (e.g. "live_set", "live_set tracks 0")'),
-        },
-    }, async ({ path }) => {
-        try {
-            const result = await bridge.request('get_children', {
-                path: path,
-            });
-            return { content: [{ type: 'text', text: JSON.stringify(result) }] };
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            return { content: [{ type: 'text', text: `Error: ${message}` }], isError: true };
-        }
-    });
-}

package/dist/tools/get-property.d.ts

@@ -1,3 +0,0 @@
-import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import type { BridgeClient } from '../bridge-client.js';
-export declare function registerGetProperty(server: McpServer, bridge: BridgeClient): void;

package/dist/tools/get-property.js

@@ -1,23 +0,0 @@
-import { z } from 'zod';
-export function registerGetProperty(server, bridge) {
-    server.registerTool('get_property', {
-        title: 'Get LOM Property',
-        description: 'Read a property from a Live Object Model object. Use LOM paths like "live_set", "live_set tracks 0", "live_set tracks 0 devices 1 parameters 2".',
-        inputSchema: {
-            path: z.string().describe('LOM path (e.g. "live_set tracks 0")'),
-            property: z.string().describe('Property name (e.g. "tempo", "name")'),
-        },
-    }, async ({ path, property }) => {
-        try {
-            const result = await bridge.request('get_property', {
-                path: path,
-                property,
-            });
-            return { content: [{ type: 'text', text: JSON.stringify(result) }] };
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            return { content: [{ type: 'text', text: `Error: ${message}` }], isError: true };
-        }
-    });
-}

package/dist/tools/index.d.ts

@@ -1,3 +0,0 @@
-import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import type { BridgeClient } from '../bridge-client.js';
-export declare function registerAllTools(server: McpServer, bridge: BridgeClient): void;

package/dist/tools/index.js

@@ -1,14 +0,0 @@
-import { registerGetProperty } from './get-property.js';
-import { registerSetProperty } from './set-property.js';
-import { registerCallFunction } from './call-function.js';
-import { registerGetChildren } from './get-children.js';
-import { registerObserve } from './observe.js';
-import { registerUnobserve } from './unobserve.js';
-export function registerAllTools(server, bridge) {
-    registerGetProperty(server, bridge);
-    registerSetProperty(server, bridge);
-    registerCallFunction(server, bridge);
-    registerGetChildren(server, bridge);
-    registerObserve(server, bridge);
-    registerUnobserve(server, bridge);
-}

package/dist/tools/observe.d.ts

@@ -1,3 +0,0 @@
-import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import type { BridgeClient } from '../bridge-client.js';
-export declare function registerObserve(server: McpServer, bridge: BridgeClient): void;

package/dist/tools/observe.js

@@ -1,23 +0,0 @@
-import { z } from 'zod';
-export function registerObserve(server, bridge) {
-    server.registerTool('observe', {
-        title: 'Observe LOM Property',
-        description: 'Subscribe to changes on a Live Object Model property. Returns a subscriptionId for later unobserve.',
-        inputSchema: {
-            path: z.string().describe('LOM path (e.g. "live_set tracks 0")'),
-            property: z.string().describe('Property name to observe (e.g. "tempo", "name")'),
-        },
-    }, async ({ path, property }) => {
-        try {
-            const result = await bridge.request('observe', {
-                path: path,
-                property,
-            });
-            return { content: [{ type: 'text', text: JSON.stringify(result) }] };
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            return { content: [{ type: 'text', text: `Error: ${message}` }], isError: true };
-        }
-    });
-}

package/dist/tools/set-property.d.ts

@@ -1,3 +0,0 @@
-import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import type { BridgeClient } from '../bridge-client.js';
-export declare function registerSetProperty(server: McpServer, bridge: BridgeClient): void;

package/dist/tools/set-property.js

@@ -1,26 +0,0 @@
-import { z } from 'zod';
-export function registerSetProperty(server, bridge) {
-    server.registerTool('set_property', {
-        title: 'Set LOM Property',
-        description: 'Set a property on a Live Object Model object. The value should be a JSON string that will be parsed (e.g. "120.0", "\\"hello\\"", "true").',
-        inputSchema: {
-            path: z.string().describe('LOM path (e.g. "live_set tracks 0")'),
-            property: z.string().describe('Property name (e.g. "tempo", "name")'),
-            value: z.string().describe('Value as JSON string (e.g. "120.0", "\\"hello\\"", "true")'),
-        },
-    }, async ({ path, property, value }) => {
-        try {
-            const parsed = JSON.parse(value);
-            const result = await bridge.request('set_property', {
-                path: path,
-                property,
-                value: parsed,
-            });
-            return { content: [{ type: 'text', text: JSON.stringify(result) }] };
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            return { content: [{ type: 'text', text: `Error: ${message}` }], isError: true };
-        }
-    });
-}

package/dist/tools/unobserve.d.ts

@@ -1,3 +0,0 @@
-import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import type { BridgeClient } from '../bridge-client.js';
-export declare function registerUnobserve(server: McpServer, bridge: BridgeClient): void;

package/dist/tools/unobserve.js

@@ -1,19 +0,0 @@
-import { z } from 'zod';
-export function registerUnobserve(server, bridge) {
-    server.registerTool('unobserve', {
-        title: 'Unobserve LOM Property',
-        description: 'Unsubscribe from a previously observed Live Object Model property using its subscriptionId.',
-        inputSchema: {
-            subscriptionId: z.string().describe('Subscription ID returned from observe'),
-        },
-    }, async ({ subscriptionId }) => {
-        try {
-            const result = await bridge.request('unobserve', { subscriptionId });
-            return { content: [{ type: 'text', text: JSON.stringify(result) }] };
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            return { content: [{ type: 'text', text: `Error: ${message}` }], isError: true };
-        }
-    });
-}