@mthines/reaper-mcp 0.10.0 → 0.11.0

package/main.js

@@ -131,6 +131,91 @@ function getTimeoutCounter() {
   }
   return _timeoutCounter;
 }
+var _handlerDurationHistogram = null;
+var _pickupDurationHistogram = null;
+function getHandlerDurationHistogram() {
+  if (!_handlerDurationHistogram) {
+    _handlerDurationHistogram = getMeter().createHistogram(
+      "mcp.bridge.handler.duration",
+      {
+        description: "Time Lua spent executing the command handler inside REAPER",
+        unit: "ms",
+        advice: {
+          explicitBucketBoundaries: [
+            0.1,
+            0.25,
+            0.5,
+            1,
+            2,
+            5,
+            10,
+            25,
+            50,
+            100,
+            250,
+            500
+          ]
+        }
+      }
+    );
+  }
+  return _handlerDurationHistogram;
+}
+function getPickupDurationHistogram() {
+  if (!_pickupDurationHistogram) {
+    _pickupDurationHistogram = getMeter().createHistogram(
+      "mcp.bridge.pickup.duration",
+      {
+        description: "Time from Node writing the command file to Lua picking it up (defer cycle latency)",
+        unit: "ms",
+        advice: {
+          explicitBucketBoundaries: [
+            1,
+            2,
+            5,
+            10,
+            16,
+            33,
+            50,
+            100,
+            200,
+            500,
+            1e3
+          ]
+        }
+      }
+    );
+  }
+  return _pickupDurationHistogram;
+}
+var _deferP50Ms = 0;
+var _deferP95Ms = 0;
+var _scanAvgMs = 0;
+var _scanMaxMs = 0;
+function updateDeferStats(p50, p95) {
+  _deferP50Ms = p50;
+  _deferP95Ms = p95;
+}
+function updateScanStats(avg, max) {
+  _scanAvgMs = avg;
+  _scanMaxMs = max;
+}
+function registerBridgeGauges() {
+  getMeter().createObservableGauge("mcp.bridge.defer.interval", {
+    description: "REAPER defer loop interval (p50/p95 over last 100 cycles)",
+    unit: "ms"
+  }).addCallback((obs) => {
+    obs.observe(_deferP50Ms, { percentile: "p50" });
+    obs.observe(_deferP95Ms, { percentile: "p95" });
+  });
+  getMeter().createObservableGauge("mcp.bridge.scan.duration", {
+    description: "Time Lua spends per main_loop scan cycle (avg/max over last 100 scans)",
+    unit: "ms"
+  }).addCallback((obs) => {
+    obs.observe(_scanAvgMs, { percentile: "avg" });
+    obs.observe(_scanMaxMs, { percentile: "max" });
+  });
+}
 
 // apps/reaper-mcp-server/src/bridge.ts
 import { randomUUID } from "node:crypto";
@@ -224,9 +309,29 @@ async function sendCommand(type, params = {}, timeoutMs = DEFAULT_TIMEOUT_MS) {
           const tCleanup = now();
           await Promise.allSettled([unlink(commandPath), unlink(responsePath)]);
           if (profiling) t["cleanup"] = now() - tCleanup;
+          const rawResponse = response;
+          const handlerMs = rawResponse["_handlerMs"];
+          const pickupMs = rawResponse["_pickupMs"];
+          const deferCycle = rawResponse["_deferCycle"];
           const durationMs2 = Date.now() - startMs;
           const succeeded = response.success;
           span.setAttribute("mcp.response.success", succeeded);
+          if (handlerMs != null) {
+            span.setAttribute("mcp.bridge.handler_ms", handlerMs);
+            getHandlerDurationHistogram().record(handlerMs, {
+              command_type: type,
+              success: String(succeeded)
+            });
+          }
+          if (pickupMs != null) {
+            span.setAttribute("mcp.bridge.pickup_ms", pickupMs);
+            getPickupDurationHistogram().record(pickupMs, {
+              command_type: type
+            });
+          }
+          if (deferCycle != null) {
+            span.setAttribute("mcp.bridge.defer_cycle", deferCycle);
+          }
           if (!succeeded) {
             span.setStatus({ code: SpanStatusCode.ERROR, message: response.error ?? "Bridge error" });
             span.setAttribute("mcp.response.error", response.error ?? "unknown");
@@ -333,6 +438,69 @@ function getReaperEffectsPath() {
 function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
+async function readBridgeEvents() {
+  const eventsPath = join2(getBridgeDir(), "bridge_events.jsonl");
+  let content;
+  try {
+    content = await readFile(eventsPath, "utf-8");
+  } catch {
+    return;
+  }
+  await writeFile(eventsPath, "", "utf-8").catch(() => {
+  });
+  const lines = content.split("\n").filter((l) => l.trim() !== "");
+  for (const line of lines) {
+    try {
+      const evt = JSON.parse(line);
+      console.error(JSON.stringify({ msg: "bridge_event", ...evt }));
+    } catch {
+    }
+  }
+}
+var _diagnosticsTimer = null;
+var _eventsTimer = null;
+function startDiagnosticsPoller(intervalMs = 6e4) {
+  if (_diagnosticsTimer) return;
+  _diagnosticsTimer = setInterval(async () => {
+    try {
+      const res = await sendCommand(
+        "_bridge_diagnostics",
+        {},
+        5e3
+      );
+      if (res.success && res.data) {
+        const d = res.data;
+        if (d.deferIntervals) {
+          updateDeferStats(d.deferIntervals.p50Ms, d.deferIntervals.p95Ms);
+        }
+        if (d.scanDurations) {
+          updateScanStats(d.scanDurations.avgMs, d.scanDurations.maxMs);
+        }
+      }
+    } catch {
+    }
+  }, intervalMs);
+}
+function startEventsPoller(intervalMs = 3e4) {
+  if (_eventsTimer) return;
+  readBridgeEvents().catch(() => {
+  });
+  _eventsTimer = setInterval(
+    () => readBridgeEvents().catch(() => {
+    }),
+    intervalMs
+  );
+}
+function stopPollers() {
+  if (_diagnosticsTimer) {
+    clearInterval(_diagnosticsTimer);
+    _diagnosticsTimer = null;
+  }
+  if (_eventsTimer) {
+    clearInterval(_eventsTimer);
+    _eventsTimer = null;
+  }
+}
 
 // apps/reaper-mcp-server/src/tools/project.ts
 function registerProjectTools(server) {
@@ -2086,6 +2254,9 @@ async function doctor() {
 async function serve() {
   const log = (...args) => console.error("[reaper-mcp]", ...args);
   await initTelemetry();
+  registerBridgeGauges();
+  startDiagnosticsPoller();
+  startEventsPoller();
   log("Starting REAPER MCP Server...");
   log(`Entry: ${fileURLToPath2(import.meta.url)}`);
   const tracer = getTracer();
@@ -2195,18 +2366,22 @@ Tip: install globally for shorter commands:
 }
 process.on("SIGINT", () => {
   console.error("[reaper-mcp] Interrupted");
+  stopPollers();
   shutdownTelemetry().finally(() => process.exit(0));
 });
 process.on("SIGTERM", () => {
   console.error("[reaper-mcp] Terminated");
+  stopPollers();
   shutdownTelemetry().finally(() => process.exit(0));
 });
 process.on("uncaughtException", (err) => {
   console.error("[reaper-mcp] Uncaught exception:", err);
+  stopPollers();
   shutdownTelemetry().finally(() => process.exit(1));
 });
 process.on("unhandledRejection", (reason) => {
   console.error("[reaper-mcp] Unhandled rejection:", reason);
+  stopPollers();
   shutdownTelemetry().finally(() => process.exit(1));
 });
 //# sourceMappingURL=main.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mthines/reaper-mcp",
-  "version": "0.10.0",
+  "version": "0.11.0",
   "type": "module",
   "description": "MCP server for controlling REAPER DAW — real-time mixing, FX control, and frequency analysis for AI agents",
   "license": "MIT",

package/reaper/mcp_bridge.lua

@@ -231,6 +231,22 @@ local function write_file(path, content)
   return true
 end
 
+-- =============================================================================
+-- Telemetry event logging
+-- =============================================================================
+
+local EVENTS_LOG = bridge_dir .. "bridge_events.jsonl"
+
+local function log_event(event_type, payload)
+  local f = io.open(EVENTS_LOG, "a")
+  if not f then return end
+  payload = payload or {}
+  payload.ts = os.time() * 1000
+  payload.type = event_type
+  f:write(json_encode(payload) .. "\n")
+  f:close()
+end
+
 local function file_exists(path)
   local f = io.open(path, "r")
   if f then f:close() return true end
@@ -2788,12 +2804,18 @@ local function process_command(filename)
   -- Dispatch to handler
   local handler = handlers[cmd.type]
   local response = {}
+  local handler_ms = 0
 
   if handler then
+    local handler_start = reaper.time_precise()
     local ok, data_or_err, err_msg = pcall(handler, cmd.params or {})
+    handler_ms = (reaper.time_precise() - handler_start) * 1000
+
     if not ok then
       -- pcall caught a Lua runtime error — handler crashed
-      response = { id = cmd.id, success = false, error = "Handler error: " .. tostring(data_or_err), timestamp = os.time() * 1000 }
+      local err_str = tostring(data_or_err)
+      log_event("handler_error", { commandType = cmd.type, commandId = cmd.id, error = err_str })
+      response = { id = cmd.id, success = false, error = "Handler error: " .. err_str, timestamp = os.time() * 1000 }
     elseif err_msg then
       -- Handler returned (nil, errorString)
       response = { id = cmd.id, success = false, error = err_msg, timestamp = os.time() * 1000 }
@@ -2802,6 +2824,7 @@ local function process_command(filename)
       response = { id = cmd.id, success = true, data = data_or_err, timestamp = os.time() * 1000 }
     end
   else
+    log_event("handler_unknown", { commandType = cmd.type, commandId = cmd.id })
     response = {
       id = cmd.id,
       success = false,
@@ -2810,6 +2833,9 @@ local function process_command(filename)
     }
   end
 
+  -- Add handler timing to response (rounded to microsecond precision)
+  response._handlerMs = math.floor(handler_ms * 1000 + 0.5) / 1000
+
   -- Add pickup timing to response for profiling
   if cmd.timestamp then
     response._pickupMs = math.floor((pickup_time - (cmd.timestamp / 1000)) * 1000 + 0.5)
@@ -2887,5 +2913,11 @@ reaper.ShowConsoleMsg("MCP Bridge: Polling every " .. (POLL_INTERVAL * 1000) ..
 -- Write initial heartbeat
 write_heartbeat()
 
+-- Log bridge start event for OTel consumption
+log_event("bridge_start", { reaperVersion = reaper.GetAppVersion(), bridgeDir = bridge_dir })
+
+-- Register shutdown handler
+reaper.atexit(function() log_event("bridge_stop", {}) end)
+
 -- Start the loop
 main_loop()