@mthines/reaper-mcp 0.1.0

package/main.js

@@ -0,0 +1,755 @@
+#!/usr/bin/env node
+
+// apps/reaper-mcp-server/src/main.ts
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// apps/reaper-mcp-server/src/server.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+
+// apps/reaper-mcp-server/src/bridge.ts
+import { randomUUID } from "node:crypto";
+import { readFile, writeFile, readdir, unlink, mkdir, stat } from "node:fs/promises";
+import { join } from "node:path";
+import { homedir, platform } from "node:os";
+var POLL_INTERVAL_MS = 50;
+var DEFAULT_TIMEOUT_MS = 1e4;
+function getReaperResourcePath() {
+  const env = process.env["REAPER_RESOURCE_PATH"];
+  if (env) return env;
+  const home = homedir();
+  switch (platform()) {
+    case "darwin":
+      return join(home, "Library", "Application Support", "REAPER");
+    case "win32":
+      return join(process.env["APPDATA"] ?? join(home, "AppData", "Roaming"), "REAPER");
+    default:
+      return join(home, ".config", "REAPER");
+  }
+}
+function getBridgeDir() {
+  return join(getReaperResourcePath(), "Scripts", "mcp_bridge_data");
+}
+async function ensureBridgeDir() {
+  const dir = getBridgeDir();
+  await mkdir(dir, { recursive: true });
+  return dir;
+}
+async function sendCommand(type, params = {}, timeoutMs = DEFAULT_TIMEOUT_MS) {
+  const dir = await ensureBridgeDir();
+  const id = randomUUID();
+  const command2 = {
+    id,
+    type,
+    params,
+    timestamp: Date.now()
+  };
+  const commandPath = join(dir, `command_${id}.json`);
+  await writeFile(commandPath, JSON.stringify(command2, null, 2), "utf-8");
+  const responsePath = join(dir, `response_${id}.json`);
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    try {
+      const data = await readFile(responsePath, "utf-8");
+      const response = JSON.parse(data);
+      await Promise.allSettled([unlink(commandPath), unlink(responsePath)]);
+      return response;
+    } catch {
+      await sleep(POLL_INTERVAL_MS);
+    }
+  }
+  await unlink(commandPath).catch(() => {
+  });
+  return {
+    id,
+    success: false,
+    error: `Timeout: no response from REAPER Lua bridge after ${timeoutMs}ms. Is the bridge script running in REAPER?`,
+    timestamp: Date.now()
+  };
+}
+async function isBridgeRunning() {
+  const dir = getBridgeDir();
+  const heartbeatPath = join(dir, "heartbeat.json");
+  try {
+    const info = await stat(heartbeatPath);
+    return Date.now() - info.mtimeMs < 5e3;
+  } catch {
+    return false;
+  }
+}
+async function cleanupStaleFiles(maxAgeMs = 3e4) {
+  const dir = getBridgeDir();
+  let cleaned = 0;
+  try {
+    const files = await readdir(dir);
+    const now = Date.now();
+    for (const file of files) {
+      if (!file.startsWith("command_") && !file.startsWith("response_")) continue;
+      const filePath = join(dir, file);
+      const info = await stat(filePath);
+      if (now - info.mtimeMs > maxAgeMs) {
+        await unlink(filePath).catch(() => {
+        });
+        cleaned++;
+      }
+    }
+  } catch {
+  }
+  return cleaned;
+}
+function getReaperScriptsPath() {
+  return join(getReaperResourcePath(), "Scripts");
+}
+function getReaperEffectsPath() {
+  return join(getReaperResourcePath(), "Effects");
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// apps/reaper-mcp-server/src/tools/project.ts
+function registerProjectTools(server) {
+  server.tool(
+    "get_project_info",
+    "Get current REAPER project info: name, track count, tempo, time signature, sample rate, transport state",
+    {},
+    async () => {
+      const res = await sendCommand("get_project_info");
+      if (!res.success) {
+        return { content: [{ type: "text", text: `Error: ${res.error}` }], isError: true };
+      }
+      return { content: [{ type: "text", text: JSON.stringify(res.data, null, 2) }] };
+    }
+  );
+}
+
+// apps/reaper-mcp-server/src/tools/tracks.ts
+import { z } from "zod";
+function registerTrackTools(server) {
+  server.tool(
+    "list_tracks",
+    "List all tracks in the current REAPER project with name, index, volume, mute/solo state, and folder structure",
+    {},
+    async () => {
+      const res = await sendCommand("list_tracks");
+      if (!res.success) {
+        return { content: [{ type: "text", text: `Error: ${res.error}` }], isError: true };
+      }
+      return { content: [{ type: "text", text: JSON.stringify(res.data, null, 2) }] };
+    }
+  );
+  server.tool(
+    "get_track_properties",
+    "Get detailed properties of a specific track including volume, pan, mute, solo, and FX chain",
+    { trackIndex: z.number().int().min(0).describe("Zero-based track index") },
+    async ({ trackIndex }) => {
+      const res = await sendCommand("get_track_properties", { trackIndex });
+      if (!res.success) {
+        return { content: [{ type: "text", text: `Error: ${res.error}` }], isError: true };
+      }
+      return { content: [{ type: "text", text: JSON.stringify(res.data, null, 2) }] };
+    }
+  );
+  server.tool(
+    "set_track_property",
+    "Set a track property: volume (dB), pan (-1.0 to 1.0), mute (0/1), or solo (0/1)",
+    {
+      trackIndex: z.number().int().min(0).describe("Zero-based track index"),
+      property: z.enum(["volume", "pan", "mute", "solo"]).describe("Property to set"),
+      value: z.number().describe("Value: volume in dB, pan -1.0\u20131.0, mute/solo 0 or 1")
+    },
+    async ({ trackIndex, property, value }) => {
+      const res = await sendCommand("set_track_property", { trackIndex, property, value });
+      if (!res.success) {
+        return { content: [{ type: "text", text: `Error: ${res.error}` }], isError: true };
+      }
+      return { content: [{ type: "text", text: `Set track ${trackIndex} ${property} = ${value}` }] };
+    }
+  );
+}
+
+// apps/reaper-mcp-server/src/tools/fx.ts
+import { z as z2 } from "zod";
+function registerFxTools(server) {
+  server.tool(
+    "add_fx",
+    `Add an FX plugin to a track by name (e.g. "ReaEQ", "JS: Schwa's Spectral Analyzer", "VST: Pro-Q 3")`,
+    {
+      trackIndex: z2.number().int().min(0).describe("Zero-based track index"),
+      fxName: z2.string().describe("FX plugin name (partial match supported)"),
+      position: z2.number().int().optional().describe("Position in FX chain (-1 or omit for end)")
+    },
+    async ({ trackIndex, fxName, position }) => {
+      const res = await sendCommand("add_fx", { trackIndex, fxName, position: position ?? -1 });
+      if (!res.success) {
+        return { content: [{ type: "text", text: `Error: ${res.error}` }], isError: true };
+      }
+      return { content: [{ type: "text", text: JSON.stringify(res.data, null, 2) }] };
+    }
+  );
+  server.tool(
+    "remove_fx",
+    "Remove an FX plugin from a track by its index in the FX chain",
+    {
+      trackIndex: z2.number().int().min(0).describe("Zero-based track index"),
+      fxIndex: z2.number().int().min(0).describe("Zero-based FX index in the chain")
+    },
+    async ({ trackIndex, fxIndex }) => {
+      const res = await sendCommand("remove_fx", { trackIndex, fxIndex });
+      if (!res.success) {
+        return { content: [{ type: "text", text: `Error: ${res.error}` }], isError: true };
+      }
+      return { content: [{ type: "text", text: `Removed FX ${fxIndex} from track ${trackIndex}` }] };
+    }
+  );
+  server.tool(
+    "get_fx_parameters",
+    "List all parameters of an FX plugin with current values and ranges",
+    {
+      trackIndex: z2.number().int().min(0).describe("Zero-based track index"),
+      fxIndex: z2.number().int().min(0).describe("Zero-based FX index in the chain")
+    },
+    async ({ trackIndex, fxIndex }) => {
+      const res = await sendCommand("get_fx_parameters", { trackIndex, fxIndex });
+      if (!res.success) {
+        return { content: [{ type: "text", text: `Error: ${res.error}` }], isError: true };
+      }
+      return { content: [{ type: "text", text: JSON.stringify(res.data, null, 2) }] };
+    }
+  );
+  server.tool(
+    "set_fx_parameter",
+    "Set a specific FX parameter value (normalized 0.0\u20131.0)",
+    {
+      trackIndex: z2.number().int().min(0).describe("Zero-based track index"),
+      fxIndex: z2.number().int().min(0).describe("Zero-based FX index in the chain"),
+      paramIndex: z2.number().int().min(0).describe("Zero-based parameter index"),
+      value: z2.number().min(0).max(1).describe("Normalized parameter value 0.0\u20131.0")
+    },
+    async ({ trackIndex, fxIndex, paramIndex, value }) => {
+      const res = await sendCommand("set_fx_parameter", { trackIndex, fxIndex, paramIndex, value });
+      if (!res.success) {
+        return { content: [{ type: "text", text: `Error: ${res.error}` }], isError: true };
+      }
+      return { content: [{ type: "text", text: `Set FX ${fxIndex} param ${paramIndex} = ${value}` }] };
+    }
+  );
+}
+
+// apps/reaper-mcp-server/src/tools/meters.ts
+import { z as z3 } from "zod";
+function registerMeterTools(server) {
+  server.tool(
+    "read_track_meters",
+    "Read real-time peak and RMS levels (in dB) for a track. Returns L/R peak and RMS values.",
+    {
+      trackIndex: z3.number().int().min(0).describe("Zero-based track index")
+    },
+    async ({ trackIndex }) => {
+      const res = await sendCommand("read_track_meters", { trackIndex });
+      if (!res.success) {
+        return { content: [{ type: "text", text: `Error: ${res.error}` }], isError: true };
+      }
+      return { content: [{ type: "text", text: JSON.stringify(res.data, null, 2) }] };
+    }
+  );
+  server.tool(
+    "read_track_spectrum",
+    "Read real-time FFT frequency spectrum data for a track. Auto-inserts the MCP Spectrum Analyzer JSFX if not present. Returns frequency bins in dB from 0 Hz to Nyquist.",
+    {
+      trackIndex: z3.number().int().min(0).describe("Zero-based track index"),
+      fftSize: z3.number().int().optional().describe("FFT size (default 4096). Options: 512, 1024, 2048, 4096, 8192")
+    },
+    async ({ trackIndex, fftSize }) => {
+      const res = await sendCommand("read_track_spectrum", { trackIndex, fftSize: fftSize ?? 4096 });
+      if (!res.success) {
+        return { content: [{ type: "text", text: `Error: ${res.error}` }], isError: true };
+      }
+      return { content: [{ type: "text", text: JSON.stringify(res.data, null, 2) }] };
+    }
+  );
+}
+
+// apps/reaper-mcp-server/src/tools/transport.ts
+import { z as z4 } from "zod";
+function registerTransportTools(server) {
+  server.tool(
+    "play",
+    "Start playback in REAPER",
+    {},
+    async () => {
+      const res = await sendCommand("play");
+      if (!res.success) {
+        return { content: [{ type: "text", text: `Error: ${res.error}` }], isError: true };
+      }
+      return { content: [{ type: "text", text: "Playback started" }] };
+    }
+  );
+  server.tool(
+    "stop",
+    "Stop playback/recording in REAPER",
+    {},
+    async () => {
+      const res = await sendCommand("stop");
+      if (!res.success) {
+        return { content: [{ type: "text", text: `Error: ${res.error}` }], isError: true };
+      }
+      return { content: [{ type: "text", text: "Playback stopped" }] };
+    }
+  );
+  server.tool(
+    "record",
+    "Start recording in REAPER (arms must be set on target tracks)",
+    {},
+    async () => {
+      const res = await sendCommand("record");
+      if (!res.success) {
+        return { content: [{ type: "text", text: `Error: ${res.error}` }], isError: true };
+      }
+      return { content: [{ type: "text", text: "Recording started" }] };
+    }
+  );
+  server.tool(
+    "get_transport_state",
+    "Get current transport state: play/record/pause status, cursor positions, tempo, time signature",
+    {},
+    async () => {
+      const res = await sendCommand("get_transport_state");
+      if (!res.success) {
+        return { content: [{ type: "text", text: `Error: ${res.error}` }], isError: true };
+      }
+      return { content: [{ type: "text", text: JSON.stringify(res.data, null, 2) }] };
+    }
+  );
+  server.tool(
+    "set_cursor_position",
+    "Move the edit cursor to a specific position in seconds from project start",
+    {
+      position: z4.number().min(0).describe("Position in seconds from project start")
+    },
+    async ({ position }) => {
+      const res = await sendCommand("set_cursor_position", { position });
+      if (!res.success) {
+        return { content: [{ type: "text", text: `Error: ${res.error}` }], isError: true };
+      }
+      return { content: [{ type: "text", text: `Cursor moved to ${position}s` }] };
+    }
+  );
+}
+
+// apps/reaper-mcp-server/src/tools/discovery.ts
+import { z as z5 } from "zod";
+function registerDiscoveryTools(server) {
+  server.tool(
+    "list_available_fx",
+    "Enumerate all installed FX plugins in REAPER (VST, VST3, JS, CLAP, AU) with an optional category filter",
+    {
+      category: z5.string().optional().describe('Optional filter: e.g. "VST", "VST3", "JS", "AU", "CLAP"')
+    },
+    async ({ category }) => {
+      const res = await sendCommand("list_available_fx", { category });
+      if (!res.success) {
+        return { content: [{ type: "text", text: `Error: ${res.error}` }], isError: true };
+      }
+      return { content: [{ type: "text", text: JSON.stringify(res.data, null, 2) }] };
+    }
+  );
+  server.tool(
+    "search_fx",
+    "Search installed FX plugins by name (case-insensitive substring match)",
+    {
+      query: z5.string().min(1).describe("Search term to match against FX plugin names")
+    },
+    async ({ query }) => {
+      const res = await sendCommand("search_fx", { query });
+      if (!res.success) {
+        return { content: [{ type: "text", text: `Error: ${res.error}` }], isError: true };
+      }
+      return { content: [{ type: "text", text: JSON.stringify(res.data, null, 2) }] };
+    }
+  );
+}
+
+// apps/reaper-mcp-server/src/tools/presets.ts
+import { z as z6 } from "zod";
+function registerPresetTools(server) {
+  server.tool(
+    "get_fx_preset_list",
+    "List all available presets for a specific FX plugin on a track",
+    {
+      trackIndex: z6.number().int().min(0).describe("Zero-based track index"),
+      fxIndex: z6.number().int().min(0).describe("Zero-based FX index in the chain")
+    },
+    async ({ trackIndex, fxIndex }) => {
+      const res = await sendCommand("get_fx_preset_list", { trackIndex, fxIndex });
+      if (!res.success) {
+        return { content: [{ type: "text", text: `Error: ${res.error}` }], isError: true };
+      }
+      return { content: [{ type: "text", text: JSON.stringify(res.data, null, 2) }] };
+    }
+  );
+  server.tool(
+    "set_fx_preset",
+    "Apply a named preset to an FX plugin on a track",
+    {
+      trackIndex: z6.number().int().min(0).describe("Zero-based track index"),
+      fxIndex: z6.number().int().min(0).describe("Zero-based FX index in the chain"),
+      presetName: z6.string().min(1).describe("Exact preset name to apply")
+    },
+    async ({ trackIndex, fxIndex, presetName }) => {
+      const res = await sendCommand("set_fx_preset", { trackIndex, fxIndex, presetName });
+      if (!res.success) {
+        return { content: [{ type: "text", text: `Error: ${res.error}` }], isError: true };
+      }
+      return { content: [{ type: "text", text: `Applied preset "${presetName}" to FX ${fxIndex} on track ${trackIndex}` }] };
+    }
+  );
+}
+
+// apps/reaper-mcp-server/src/tools/snapshots.ts
+import { z as z7 } from "zod";
+function registerSnapshotTools(server) {
+  server.tool(
+    "snapshot_save",
+    "Save the current mixer state as a named snapshot. Uses SWS Snapshots if available, otherwise captures track volumes, pans, mutes, solos, and FX bypass states manually.",
+    {
+      name: z7.string().min(1).describe('Unique snapshot name (e.g. "before-compression", "v1-mix")'),
+      description: z7.string().optional().describe("Optional human-readable description")
+    },
+    async ({ name, description }) => {
+      const res = await sendCommand("snapshot_save", { name, description });
+      if (!res.success) {
+        return { content: [{ type: "text", text: `Error: ${res.error}` }], isError: true };
+      }
+      return { content: [{ type: "text", text: JSON.stringify(res.data, null, 2) }] };
+    }
+  );
+  server.tool(
+    "snapshot_restore",
+    "Restore a previously saved mixer snapshot by name",
+    {
+      name: z7.string().min(1).describe("Name of the snapshot to restore")
+    },
+    async ({ name }) => {
+      const res = await sendCommand("snapshot_restore", { name });
+      if (!res.success) {
+        return { content: [{ type: "text", text: `Error: ${res.error}` }], isError: true };
+      }
+      return { content: [{ type: "text", text: JSON.stringify(res.data, null, 2) }] };
+    }
+  );
+  server.tool(
+    "snapshot_list",
+    "List all saved mixer snapshots with names, descriptions, and timestamps",
+    {},
+    async () => {
+      const res = await sendCommand("snapshot_list", {});
+      if (!res.success) {
+        return { content: [{ type: "text", text: `Error: ${res.error}` }], isError: true };
+      }
+      return { content: [{ type: "text", text: JSON.stringify(res.data, null, 2) }] };
+    }
+  );
+}
+
+// apps/reaper-mcp-server/src/tools/routing.ts
+import { z as z8 } from "zod";
+function registerRoutingTools(server) {
+  server.tool(
+    "get_track_routing",
+    "Get sends, receives, and parent/folder information for a track \u2014 useful for understanding bus structure",
+    {
+      trackIndex: z8.number().int().min(0).describe("Zero-based track index")
+    },
+    async ({ trackIndex }) => {
+      const res = await sendCommand("get_track_routing", { trackIndex });
+      if (!res.success) {
+        return { content: [{ type: "text", text: `Error: ${res.error}` }], isError: true };
+      }
+      return { content: [{ type: "text", text: JSON.stringify(res.data, null, 2) }] };
+    }
+  );
+}
+
+// apps/reaper-mcp-server/src/tools/analysis.ts
+import { z as z9 } from "zod";
+function registerAnalysisTools(server) {
+  server.tool(
+    "read_track_lufs",
+    "Read ITU-R BS.1770 loudness data for a track. Auto-inserts the MCP LUFS Meter JSFX if not present. Returns integrated, short-term (3s), and momentary (400ms) LUFS plus true inter-sample peak levels. Audio must be playing to accumulate data.",
+    {
+      trackIndex: z9.number().int().min(0).describe("Zero-based track index")
+    },
+    async ({ trackIndex }) => {
+      const res = await sendCommand("read_track_lufs", { trackIndex });
+      if (!res.success) {
+        return { content: [{ type: "text", text: `Error: ${res.error}` }], isError: true };
+      }
+      return { content: [{ type: "text", text: JSON.stringify(res.data, null, 2) }] };
+    }
+  );
+  server.tool(
+    "read_track_correlation",
+    "Read stereo field correlation and M/S analysis for a track. Auto-inserts the MCP Correlation Meter JSFX if not present. Returns correlation coefficient (-1 to +1), stereo width, and mid/side levels. Audio must be playing to accumulate data.",
+    {
+      trackIndex: z9.number().int().min(0).describe("Zero-based track index")
+    },
+    async ({ trackIndex }) => {
+      const res = await sendCommand("read_track_correlation", { trackIndex });
+      if (!res.success) {
+        return { content: [{ type: "text", text: `Error: ${res.error}` }], isError: true };
+      }
+      return { content: [{ type: "text", text: JSON.stringify(res.data, null, 2) }] };
+    }
+  );
+  server.tool(
+    "read_track_crest",
+    "Read crest factor (peak-to-RMS ratio) for a track. Auto-inserts the MCP Crest Factor Meter JSFX if not present. Returns crest factor in dB (higher = more dynamic, lower = over-compressed), peak hold level, and RMS level. Audio must be playing to accumulate data.",
+    {
+      trackIndex: z9.number().int().min(0).describe("Zero-based track index")
+    },
+    async ({ trackIndex }) => {
+      const res = await sendCommand("read_track_crest", { trackIndex });
+      if (!res.success) {
+        return { content: [{ type: "text", text: `Error: ${res.error}` }], isError: true };
+      }
+      return { content: [{ type: "text", text: JSON.stringify(res.data, null, 2) }] };
+    }
+  );
+}
+
+// apps/reaper-mcp-server/src/server.ts
+function createServer() {
+  const server = new McpServer({
+    name: "reaper-mcp",
+    version: "0.1.0"
+  });
+  registerProjectTools(server);
+  registerTrackTools(server);
+  registerFxTools(server);
+  registerMeterTools(server);
+  registerTransportTools(server);
+  registerDiscoveryTools(server);
+  registerPresetTools(server);
+  registerSnapshotTools(server);
+  registerRoutingTools(server);
+  registerAnalysisTools(server);
+  return server;
+}
+
+// apps/reaper-mcp-server/src/main.ts
+import { copyFileSync, existsSync, mkdirSync, readdirSync, statSync } from "node:fs";
+import { join as join2, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+var __dirname = dirname(fileURLToPath(import.meta.url));
+function copyDirSync(src, dest) {
+  if (!existsSync(src)) return 0;
+  mkdirSync(dest, { recursive: true });
+  let count = 0;
+  for (const entry of readdirSync(src)) {
+    const srcPath = join2(src, entry);
+    const destPath = join2(dest, entry);
+    if (statSync(srcPath).isDirectory()) {
+      count += copyDirSync(srcPath, destPath);
+    } else {
+      copyFileSync(srcPath, destPath);
+      count++;
+    }
+  }
+  return count;
+}
+function installFile(src, dest, label) {
+  if (existsSync(src)) {
+    copyFileSync(src, dest);
+    console.log(`  Installed: ${label}`);
+    return true;
+  }
+  console.log(`  Not found: ${src}`);
+  return false;
+}
+async function setup() {
+  console.log("REAPER MCP Server \u2014 Setup\n");
+  const bridgeDir = await ensureBridgeDir();
+  console.log(`Bridge directory: ${bridgeDir}
+`);
+  const scriptsDir = getReaperScriptsPath();
+  mkdirSync(scriptsDir, { recursive: true });
+  const luaSrc = join2(__dirname, "..", "reaper", "mcp_bridge.lua");
+  const luaDest = join2(scriptsDir, "mcp_bridge.lua");
+  console.log("Installing Lua bridge...");
+  installFile(luaSrc, luaDest, "mcp_bridge.lua");
+  const effectsDir = getReaperEffectsPath();
+  mkdirSync(effectsDir, { recursive: true });
+  const jsfxFiles = [
+    "mcp_analyzer.jsfx",
+    "mcp_lufs_meter.jsfx",
+    "mcp_correlation_meter.jsfx",
+    "mcp_crest_factor.jsfx"
+  ];
+  console.log("\nInstalling JSFX analyzers...");
+  for (const jsfx of jsfxFiles) {
+    const src = join2(__dirname, "..", "reaper", jsfx);
+    const dest = join2(effectsDir, jsfx);
+    installFile(src, dest, jsfx);
+  }
+  console.log("\nSetup complete!\n");
+  console.log("Next steps:");
+  console.log("  1. Open REAPER");
+  console.log("  2. Actions > Show action list > Load ReaScript");
+  console.log(`  3. Select: ${luaDest}`);
+  console.log("  4. Run the script (it will keep running in background via defer loop)");
+  console.log("  5. Add reaper-mcp to your Claude Code config (see: reaper-mcp doctor)");
+}
+async function installSkills() {
+  console.log("REAPER MCP \u2014 Install AI Mix Engineer Skills\n");
+  const targetDir = process.cwd();
+  const knowledgeSrc = join2(__dirname, "..", "knowledge");
+  const knowledgeDest = join2(targetDir, "knowledge");
+  if (existsSync(knowledgeSrc)) {
+    const count = copyDirSync(knowledgeSrc, knowledgeDest);
+    console.log(`Installed knowledge base: ${count} files \u2192 ${knowledgeDest}`);
+  } else {
+    console.log("Knowledge base not found in package. Skipping.");
+  }
+  const rulesSrc = join2(__dirname, "..", "claude-rules");
+  const rulesDir = join2(targetDir, ".claude", "rules");
+  if (existsSync(rulesSrc)) {
+    const count = copyDirSync(rulesSrc, rulesDir);
+    console.log(`Installed Claude rules: ${count} files \u2192 ${rulesDir}`);
+  } else {
+    console.log("Claude rules not found in package. Skipping.");
+  }
+  const skillsSrc = join2(__dirname, "..", "claude-skills");
+  const skillsDir = join2(targetDir, ".claude", "skills");
+  if (existsSync(skillsSrc)) {
+    const count = copyDirSync(skillsSrc, skillsDir);
+    console.log(`Installed Claude skills: ${count} files \u2192 ${skillsDir}`);
+  } else {
+    console.log("Claude skills not found in package. Skipping.");
+  }
+  const mcpJsonPath = join2(targetDir, ".mcp.json");
+  if (!existsSync(mcpJsonPath)) {
+    const mcpConfig = JSON.stringify({
+      mcpServers: {
+        reaper: {
+          command: "npx",
+          args: ["@mthines/reaper-mcp", "serve"]
+        }
+      }
+    }, null, 2);
+    copyFileSync("/dev/null", mcpJsonPath);
+    const { writeFileSync } = await import("node:fs");
+    writeFileSync(mcpJsonPath, mcpConfig + "\n", "utf-8");
+    console.log(`
+Created: ${mcpJsonPath}`);
+  } else {
+    console.log(`
+.mcp.json already exists \u2014 add the reaper server config manually if needed.`);
+  }
+  console.log("\nDone! Claude Code now has mix engineer knowledge and REAPER MCP tools.");
+  console.log('Try asking: "Please gain stage my tracks" or "Roast my mix"');
+}
+async function doctor() {
+  console.log("REAPER MCP \u2014 System Check\n");
+  const bridgeRunning = await isBridgeRunning();
+  console.log(`Lua bridge:    ${bridgeRunning ? "\u2713 Connected" : "\u2717 Not detected"}`);
+  if (!bridgeRunning) {
+    console.log('  \u2192 Run "reaper-mcp setup" then load mcp_bridge.lua in REAPER');
+  }
+  const knowledgeExists = existsSync(join2(process.cwd(), "knowledge"));
+  console.log(`Knowledge base: ${knowledgeExists ? "\u2713 Found in project" : "\u2717 Not installed"}`);
+  if (!knowledgeExists) {
+    console.log('  \u2192 Run "reaper-mcp install-skills" in your project directory');
+  }
+  const mcpJsonExists = existsSync(join2(process.cwd(), ".mcp.json"));
+  console.log(`MCP config:    ${mcpJsonExists ? "\u2713 .mcp.json found" : "\u2717 .mcp.json missing"}`);
+  if (!mcpJsonExists) {
+    console.log('  \u2192 Run "reaper-mcp install-skills" to create .mcp.json');
+  }
+  console.log('\nTo check SWS Extensions, start REAPER and use the "list_available_fx" tool.');
+  console.log("SWS provides enhanced plugin discovery and snapshot support.\n");
+  process.exit(bridgeRunning && knowledgeExists && mcpJsonExists ? 0 : 1);
+}
+async function serve() {
+  const log = (...args) => console.error("[reaper-mcp]", ...args);
+  log("Starting REAPER MCP Server...");
+  await ensureBridgeDir();
+  const cleaned = await cleanupStaleFiles();
+  if (cleaned > 0) {
+    log(`Cleaned up ${cleaned} stale bridge files`);
+  }
+  const bridgeRunning = await isBridgeRunning();
+  if (!bridgeRunning) {
+    log("WARNING: Lua bridge does not appear to be running in REAPER.");
+    log("Commands will timeout until the bridge script is started.");
+    log('Run "reaper-mcp setup" for installation instructions.');
+  } else {
+    log("Lua bridge detected \u2014 connected to REAPER");
+  }
+  const server = createServer();
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  log("MCP server connected via stdio");
+}
+var command = process.argv[2];
+switch (command) {
+  case "setup":
+    setup().catch((err) => {
+      console.error("Setup failed:", err);
+      process.exit(1);
+    });
+    break;
+  case "install-skills":
+    installSkills().catch((err) => {
+      console.error("Install failed:", err);
+      process.exit(1);
+    });
+    break;
+  case "doctor":
+    doctor().catch((err) => {
+      console.error("Doctor failed:", err);
+      process.exit(1);
+    });
+    break;
+  case "status": {
+    (async () => {
+      const running = await isBridgeRunning();
+      console.log(`Bridge status: ${running ? "CONNECTED" : "NOT DETECTED"}`);
+      process.exit(running ? 0 : 1);
+    })();
+    break;
+  }
+  case "serve":
+  case void 0:
+    serve().catch((err) => {
+      console.error("[reaper-mcp] Fatal error:", err);
+      process.exit(1);
+    });
+    break;
+  default:
+    console.log(`reaper-mcp \u2014 AI-powered mixing for REAPER DAW
+
+Usage:
+  reaper-mcp                  Start MCP server (stdio mode)
+  reaper-mcp serve            Start MCP server (stdio mode)
+  reaper-mcp setup            Install Lua bridge + JSFX analyzers into REAPER
+  reaper-mcp install-skills   Install AI mix engineer knowledge into your project
+  reaper-mcp doctor           Check that everything is configured correctly
+  reaper-mcp status           Check if Lua bridge is running in REAPER
+
+Quick Start:
+  1. reaper-mcp setup            # install REAPER components
+  2. Load mcp_bridge.lua in REAPER (Actions > Load ReaScript > Run)
+  3. reaper-mcp install-skills   # install AI knowledge in your project
+  4. Open Claude Code \u2014 REAPER tools + mix engineer brain are ready
+`);
+    break;
+}
+process.on("SIGINT", () => {
+  console.error("[reaper-mcp] Interrupted");
+  process.exit(0);
+});
+process.on("SIGTERM", () => {
+  console.error("[reaper-mcp] Terminated");
+  process.exit(0);
+});
+//# sourceMappingURL=main.js.map