livepilot 1.9.9 → 1.9.12

package/mcp_server/__init__.py

@@ -1,2 +1,2 @@
 """LivePilot MCP Server — bridges MCP protocol to Ableton Live."""
-__version__ = "1.9.9"
+__version__ = "1.9.12"

package/mcp_server/connection.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 import json
 import os
 import socket
+import subprocess
 import threading
 import time
 import uuid
@@ -44,6 +45,33 @@ def _friendly_error(code: str, message: str, command_type: str) -> str:
     return " ".join(parts)
 
 
+def _identify_other_tcp_client(host: str, port: int) -> str | None:
+    """Return a short description of another established client on the Live port."""
+    try:
+        out = subprocess.check_output(
+            ["lsof", "-nP", f"-iTCP:{port}"],
+            text=True,
+            timeout=3,
+        )
+    except (subprocess.CalledProcessError, FileNotFoundError, ValueError, OSError):
+        return None
+
+    target = f"->{host}:{port}"
+    my_pid = os.getpid()
+    for line in out.splitlines()[1:]:
+        parts = line.split()
+        if len(parts) < 2 or target not in line or "(ESTABLISHED)" not in line:
+            continue
+        try:
+            pid = int(parts[1])
+        except ValueError:
+            continue
+        if pid == my_pid:
+            continue
+        return f"PID {pid} ({parts[0]})"
+    return None
+
+
 class AbletonConnection:
     """TCP client that sends JSON commands to the LivePilot Remote Script."""
 
@@ -185,7 +213,7 @@ class AbletonConnection:
             raise AbletonConnectionError(f"Failed to send command: {exc}") from exc
 
         # Read until newline, preserving any trailing bytes in _recv_buf
-        buf = getattr(self, "_recv_buf", b"")
+        buf = self._recv_buf
         try:
             while b"\n" not in buf:
                 chunk = self._socket.recv(4096)
@@ -194,9 +222,20 @@ class AbletonConnection:
                     self.disconnect()
                     raise AbletonConnectionError("Connection closed by Ableton")
                 buf += chunk
+                if len(buf) > 10 * 1024 * 1024:  # 10 MB
+                    self._recv_buf = b""
+                    self.disconnect()
+                    raise AbletonConnectionError("Response too large (>10 MB)")
         except socket.timeout as exc:
             self._recv_buf = buf
             self.disconnect()
+            other_client = _identify_other_tcp_client(self.host, self.port)
+            if other_client:
+                raise AbletonConnectionError(
+                    "Timeout waiting for response from Ableton. "
+                    f"Another LivePilot client appears to be connected on {self.host}:{self.port} "
+                    f"({other_client}). Disconnect the other client and retry."
+                ) from exc
             raise AbletonConnectionError(
                 f"Timeout waiting for response from Ableton ({RECV_TIMEOUT}s)"
             ) from exc

package/mcp_server/curves.py

@@ -366,11 +366,15 @@ def _brownian(duration: float, density: int, start: float = 0.5,
         step = drift / density + volatility * _det_random(i, seed)
         value += step
         # Soft boundary reflection (bounce off 0/1 until within range)
-        while value > 1.0 or value < 0.0:
+        for _ in range(100):
+            if 0.0 <= value <= 1.0:
+                break
             if value > 1.0:
                 value = 2.0 - value
             if value < 0.0:
                 value = -value
+        else:
+            value = max(0.0, min(1.0, value))
     return points
 
 

package/mcp_server/m4l_bridge.py

@@ -21,6 +21,50 @@ import time
 from typing import Any, Optional
 
 
+def _encode_string_arg(value: str) -> str:
+    """Encode a Python string arg into an ASCII-safe OSC payload.
+
+    The Max JS side decodes values with the ``b64:`` prefix back to UTF-8.
+    Keeping the wire payload ASCII-only avoids OSC/client issues with
+    non-ASCII file paths and device names.
+    """
+    encoded = base64.urlsafe_b64encode(value.encode("utf-8")).decode("ascii")
+    return "b64:" + encoded.rstrip("=")
+
+
+def _normalize_macos_path(path: str) -> str:
+    """Convert Max-style HFS-ish paths into POSIX paths when possible."""
+    if len(path) >= 3 and path[1] == ":" and path[2] in ("/", "\\"):
+        return path
+
+    colon = path.find(":")
+    slash = path.find("/")
+    if colon <= 0 or (slash != -1 and colon > slash):
+        return path
+
+    rest = path[colon + 1:]
+    if ":" in rest:
+        rest = rest.replace(":", "/")
+    if not rest.startswith("/"):
+        rest = "/" + rest.lstrip("/\\")
+    return rest
+
+
+def _normalize_bridge_payload(value: Any) -> Any:
+    """Normalize filesystem paths inside bridge payloads."""
+    if isinstance(value, dict):
+        normalized = {}
+        for key, item in value.items():
+            if key == "file_path" and isinstance(item, str):
+                normalized[key] = _normalize_macos_path(item)
+            else:
+                normalized[key] = _normalize_bridge_payload(item)
+        return normalized
+    if isinstance(value, list):
+        return [_normalize_bridge_payload(item) for item in value]
+    return value
+
+
 class SpectralCache:
     """Thread-safe cache for incoming spectral data from M4L.
 
@@ -97,6 +141,7 @@ class SpectralReceiver(asyncio.DatagramProtocol):
     def __init__(self, cache: SpectralCache):
         self.cache = cache
         self._chunks: dict[str, dict] = {}  # Reassembly buffer for chunked responses
+        self._chunk_times: dict[str, float] = {}  # Monotonic timestamp per chunk sequence
         self._chunk_id = 0
         self._response_callback: Optional[asyncio.Future] = None
         self._capture_future: Optional[asyncio.Future] = None
@@ -226,7 +271,7 @@ class SpectralReceiver(asyncio.DatagramProtocol):
             # URL-safe base64 decode (- and _ instead of + and /)
             padded = encoded + "=" * (-len(encoded) % 4)
             decoded = base64.urlsafe_b64decode(padded).decode('utf-8')
-            result = json.loads(decoded)
+            result = _normalize_bridge_payload(json.loads(decoded))
             if self._response_callback and not self._response_callback.done():
                 self._response_callback.set_result(result)
         except Exception as exc:
@@ -240,6 +285,7 @@ class SpectralReceiver(asyncio.DatagramProtocol):
         key = str(self._chunk_id)
         if key not in self._chunks:
             self._chunks[key] = {"parts": {}, "total": total}
+            self._chunk_times[key] = time.monotonic()
 
         self._chunks[key]["parts"][index] = encoded
 
@@ -249,14 +295,22 @@ class SpectralReceiver(asyncio.DatagramProtocol):
             for i in range(total):
                 full += self._chunks[key]["parts"][i]
             del self._chunks[key]
+            self._chunk_times.pop(key, None)
             self._handle_response(full)
 
+        # Evict incomplete chunk sequences older than 30 seconds
+        now = time.monotonic()
+        stale = [k for k, t in self._chunk_times.items() if now - t > 30.0]
+        for k in stale:
+            self._chunks.pop(k, None)
+            self._chunk_times.pop(k, None)
+
     def _handle_capture_complete(self, encoded: str) -> None:
         """Decode a /capture_complete OSC message and resolve _capture_future."""
         try:
             padded = encoded + "=" * (-len(encoded) % 4)
             decoded = base64.urlsafe_b64decode(padded).decode('utf-8')
-            result = json.loads(decoded)
+            result = _normalize_bridge_payload(json.loads(decoded))
             if self._capture_future and not self._capture_future.done():
                 self._capture_future.set_result(result)
         except Exception as exc:
@@ -315,36 +369,48 @@ class M4LBridge:
         if not self.cache.is_connected:
             return {"error": "LivePilot Analyzer not connected. Drop it on the master track."}
 
-        # Cancel any stale capture future before creating a new one
-        if self.receiver and self.receiver._capture_future and not self.receiver._capture_future.done():
-            self.receiver._capture_future.cancel()
-
-        loop = asyncio.get_running_loop()
-        future = loop.create_future()
-        if self.receiver:
-            self.receiver.set_capture_future(future)
-
-        osc_data = self._build_osc(command, args)
-        self._sock.sendto(osc_data, self._m4l_addr)
+        async with self._cmd_lock:
+            # Cancel any stale capture future before creating a new one
+            if self.receiver and self.receiver._capture_future and not self.receiver._capture_future.done():
+                self.receiver._capture_future.cancel()
 
-        try:
-            result = await asyncio.wait_for(future, timeout=timeout)
-            return result
-        except asyncio.TimeoutError:
-            # Clean up the dangling future
+            loop = asyncio.get_running_loop()
+            future = loop.create_future()
             if self.receiver:
-                self.receiver._capture_future = None
-            return {"error": "M4L capture timeout — device may be busy or removed"}
+                self.receiver.set_capture_future(future)
+
+            osc_data = self._build_osc(command, args)
+            self._sock.sendto(osc_data, self._m4l_addr)
 
-    def cancel_capture_future(self) -> None:
-        """Cancel any in-progress capture future (called by capture_stop)."""
-        if self.receiver and self.receiver._capture_future and not self.receiver._capture_future.done():
+            try:
+                result = await asyncio.wait_for(future, timeout=timeout)
+                return result
+            except asyncio.TimeoutError:
+                # Clean up the dangling future
+                if self.receiver:
+                    self.receiver._capture_future = None
+                return {"error": "M4L capture timeout — device may be busy or removed"}
+
+    async def cancel_capture_future(self) -> None:
+        """Cancel any in-progress capture future (called by capture_stop).
+
+        Does NOT acquire _cmd_lock — send_capture holds it during recording.
+        Cancelling the future causes send_capture's wait_for to raise
+        CancelledError, which releases the lock naturally.
+        """
+        if self.receiver and self.receiver._capture_future \
+                and not self.receiver._capture_future.done():
             self.receiver._capture_future.cancel()
             self.receiver._capture_future = None
 
     def _build_osc(self, address: str, args: tuple) -> bytes:
-        """Build a minimal OSC message."""
-        # Address string (null-terminated, padded to 4 bytes)
+        """Build a minimal OSC message.
+
+        OSC addresses are ASCII-only command names.
+        String arguments are encoded into an ASCII-safe ``b64:...`` payload
+        and decoded back to UTF-8 in the Max bridge.
+        """
+        # Address string — always ASCII (command names like "get_params")
         addr_bytes = address.encode('ascii') + b'\x00'
         while len(addr_bytes) % 4 != 0:
             addr_bytes += b'\x00'
@@ -361,7 +427,8 @@ class M4LBridge:
                 arg_data += struct.pack('>f', arg)
             elif isinstance(arg, str):
                 type_tags += "s"
-                s_bytes = arg.encode('ascii') + b'\x00'
+                encoded = _encode_string_arg(arg)
+                s_bytes = encoded.encode('ascii') + b'\x00'
                 while len(s_bytes) % 4 != 0:
                     s_bytes += b'\x00'
                 arg_data += s_bytes

package/mcp_server/server.py

@@ -3,7 +3,6 @@
 from contextlib import asynccontextmanager
 import asyncio
 import os
-import signal
 import subprocess
 
 from fastmcp import FastMCP, Context  # noqa: F401
@@ -12,12 +11,11 @@ from .connection import AbletonConnection
 from .m4l_bridge import SpectralCache, SpectralReceiver, M4LBridge
 
 
-def _kill_port_holder(port: int) -> None:
-    """Kill whichever process holds the given UDP port.
+def _identify_port_holder(port: int) -> str | None:
+    """Identify which process holds the given UDP port (for logging only).
 
-    Used to reclaim port 9880 when a stale duplicate server instance
-    is hogging it (common when both project .mcp.json and plugin
-    .mcp.json launch the server).
+    Returns a string like "PID 12345 (python3 mcp_server)" or None if
+    identification fails. Never kills or modifies the holder.
     """
     try:
         out = subprocess.check_output(
@@ -29,18 +27,17 @@ def _kill_port_holder(port: int) -> None:
         for pid_str in out.splitlines():
             pid = int(pid_str)
             if pid != my_pid:
-                # Only kill if it looks like a Python/LivePilot process
                 try:
                     cmdline = subprocess.check_output(
                         ["ps", "-p", str(pid), "-o", "command="],
                         text=True, timeout=2,
                     ).strip()
-                    if "mcp_server" in cmdline or "livepilot" in cmdline.lower():
-                        os.kill(pid, signal.SIGTERM)
+                    return f"{pid} ({cmdline[:60]})"
                 except (subprocess.CalledProcessError, FileNotFoundError):
-                    pass  # Can't verify — don't kill
+                    return str(pid)
+        return None
     except (subprocess.CalledProcessError, FileNotFoundError, ValueError):
-        pass  # lsof not found or no process — nothing to kill
+        return None
 
 
 @asynccontextmanager
@@ -60,28 +57,18 @@ async def lifespan(server):
             local_addr=('127.0.0.1', 9880),
         )
     except OSError:
-        # Port 9880 already bound — likely a duplicate server instance
-        # (project .mcp.json + plugin .mcp.json both launching).
-        # Kill the stale holder so this instance gets the port.
+        # Port 9880 already bound — another LivePilot instance is running.
+        # Do NOT kill the holder; degrade gracefully instead.
         import sys
+        holder_info = _identify_port_holder(9880)
         print(
-            "LivePilot: UDP port 9880 in use — reclaiming from stale instance",
+            "LivePilot: UDP port 9880 already in use%s — "
+            "analyzer/bridge tools will be unavailable. "
+            "Stop the other LivePilot instance to enable them."
+            % (f" (PID {holder_info})" if holder_info else ""),
             file=sys.stderr,
         )
-        _kill_port_holder(9880)
-        await asyncio.sleep(0.3)
-        try:
-            transport, _ = await loop.create_datagram_endpoint(
-                lambda: receiver,
-                local_addr=('127.0.0.1', 9880),
-            )
-        except OSError:
-            print(
-                "LivePilot: WARNING — could not bind UDP 9880, "
-                "analyzer tools will be unavailable",
-                file=sys.stderr,
-            )
-            transport = None
+        transport = None
 
     try:
         yield {
@@ -132,12 +119,20 @@ from .tools import perception   # noqa: F401, E402
 
 def _coerce_schema_property(prop: dict) -> None:
     """Widen a single JSON Schema property to also accept strings."""
-    if prop.get("type") in ("integer", "number"):
+    if prop.get("type") in ("integer", "number") and "anyOf" not in prop:
         original_type = prop.pop("type")
         prop["anyOf"] = [{"type": original_type}, {"type": "string"}]
     elif "anyOf" in prop:
+        # Skip if this anyOf was already coerced (contains both a numeric and string type)
+        variant_types = {v.get("type") for v in prop["anyOf"] if isinstance(v, dict)}
+        if "string" in variant_types and variant_types & {"integer", "number"}:
+            return
         for variant in prop["anyOf"]:
-            _coerce_schema_property(variant)
+            if isinstance(variant, dict):
+                _coerce_schema_property(variant)
+    # Recurse into array items so list[int]/list[float] params also accept strings
+    if "items" in prop and isinstance(prop["items"], dict):
+        _coerce_schema_property(prop["items"])
 
 
 def _get_all_tools():

package/mcp_server/tools/_perception_engine.py

@@ -77,6 +77,25 @@ def _normalize_to_lufs(
     return tmp_path
 
 
+# ---------------------------------------------------------------------------
+# True-peak helper
+# ---------------------------------------------------------------------------
+
+def _true_peak_dbtp(data: np.ndarray, sr: int) -> float:
+    """Estimate EBU R128 true peak via 4x oversampling.
+
+    Uses scipy's resample_poly for phase-accurate upsampling,
+    then measures the absolute peak of the oversampled signal.
+    Returns the result in dBTP (decibels relative to true peak).
+    """
+    from scipy.signal import resample_poly
+
+    # 4x oversample each channel independently
+    oversampled = resample_poly(data, up=4, down=1, axis=0)
+    peak_linear = float(np.max(np.abs(oversampled)))
+    return float(20.0 * np.log10(max(peak_linear, 1e-10)))
+
+
 # ---------------------------------------------------------------------------
 # compute_loudness
 # ---------------------------------------------------------------------------
@@ -89,8 +108,8 @@ def compute_loudness(file_path: str, detail: str = "summary") -> dict[str, Any]:
         detail: "summary" (default) or "full" (includes short_term_lufs array).
 
     Returns:
-        dict with integrated_lufs, sample_peak_dbfs, rms_dbfs, crest_factor_db,
-        lra_lu, meets_streaming, and optionally short_term_lufs.
+        dict with integrated_lufs, true_peak_dbtp, sample_peak_dbfs, rms_dbfs,
+        crest_factor_db, lra_lu, meets_streaming, and optionally short_term_lufs.
     """
     import pyloudnorm as pyln
 
@@ -110,12 +129,15 @@ def compute_loudness(file_path: str, detail: str = "summary") -> dict[str, Any]:
     peak_linear = float(np.max(np.abs(data)))
     sample_peak_dbfs = float(20.0 * np.log10(max(peak_linear, 1e-10)))
 
+    # True peak via 4x oversampling (EBU R128 compliant)
+    true_peak_dbtp = _true_peak_dbtp(data, sr)
+
     # RMS dBFS
     rms_linear = float(np.sqrt(np.mean(data ** 2)))
     rms_dbfs = float(20.0 * np.log10(max(rms_linear, 1e-10)))
 
     # Crest factor
-    crest_factor_db = sample_peak_dbfs - rms_dbfs
+    crest_factor_db = true_peak_dbtp - rms_dbfs
 
     # Short-term LUFS (3s window, 1s hop) — also used for LRA
     window_samples = int(sr * 3.0)
@@ -162,6 +184,7 @@ def compute_loudness(file_path: str, detail: str = "summary") -> dict[str, Any]:
 
     result: dict[str, Any] = {
         "integrated_lufs": round(integrated_lufs, 2),
+        "true_peak_dbtp": round(true_peak_dbtp, 2),
         "sample_peak_dbfs": round(sample_peak_dbfs, 2),
         "rms_dbfs": round(rms_dbfs, 2),
         "crest_factor_db": round(crest_factor_db, 2),

package/mcp_server/tools/_theory_engine.py

@@ -35,19 +35,20 @@ PHRYGIAN_PROFILE   = MAJOR_PROFILE[4:] + MAJOR_PROFILE[:4]
 LYDIAN_PROFILE     = MAJOR_PROFILE[5:] + MAJOR_PROFILE[:5]
 MIXOLYDIAN_PROFILE = MAJOR_PROFILE[7:] + MAJOR_PROFILE[:7]
 LOCRIAN_PROFILE    = MAJOR_PROFILE[11:] + MAJOR_PROFILE[:11]
+PHRYGIAN_DOMINANT_PROFILE = [6.35, 4.75, 1.75, 1.95, 4.9, 3.9, 1.8, 5.2, 3.6, 1.7, 3.4, 1.6]
 
 MODE_PROFILES = {
     'major': MAJOR_PROFILE, 'minor': MINOR_PROFILE,
     'dorian': DORIAN_PROFILE, 'phrygian': PHRYGIAN_PROFILE,
     'lydian': LYDIAN_PROFILE, 'mixolydian': MIXOLYDIAN_PROFILE,
-    'locrian': LOCRIAN_PROFILE,
+    'locrian': LOCRIAN_PROFILE, 'phrygian_dominant': PHRYGIAN_DOMINANT_PROFILE,
 }
 
 SCALES = {
     'major': [0, 2, 4, 5, 7, 9, 11], 'minor': [0, 2, 3, 5, 7, 8, 10],
     'dorian': [0, 2, 3, 5, 7, 9, 10], 'phrygian': [0, 1, 3, 5, 7, 8, 10],
     'lydian': [0, 2, 4, 6, 7, 9, 11], 'mixolydian': [0, 2, 4, 5, 7, 9, 10],
-    'locrian': [0, 1, 3, 5, 6, 8, 10],
+    'locrian': [0, 1, 3, 5, 6, 8, 10], 'phrygian_dominant': [0, 1, 4, 5, 7, 8, 10],
 }
 
 TRIAD_QUALITIES = {
@@ -58,6 +59,25 @@ TRIAD_QUALITIES = {
     'lydian':     ['major', 'major', 'minor', 'diminished', 'major', 'minor', 'minor'],
     'mixolydian': ['major', 'minor', 'diminished', 'major', 'minor', 'minor', 'major'],
     'locrian':    ['diminished', 'major', 'minor', 'minor', 'major', 'major', 'minor'],
+    'phrygian_dominant': ['major', 'major', 'diminished', 'minor', 'diminished', 'augmented', 'minor'],
+}
+
+MODE_ALIASES = {
+    'major': 'major',
+    'ionian': 'major',
+    'maj': 'major',
+    'minor': 'minor',
+    'aeolian': 'minor',
+    'min': 'minor',
+    'dorian': 'dorian',
+    'phrygian': 'phrygian',
+    'lydian': 'lydian',
+    'mixolydian': 'mixolydian',
+    'locrian': 'locrian',
+    'phrygian dominant': 'phrygian_dominant',
+    'phrygian_dominant': 'phrygian_dominant',
+    'phrygian-dominant': 'phrygian_dominant',
+    'hijaz': 'phrygian_dominant',
 }
 
 CHORD_PATTERNS = {
@@ -81,6 +101,15 @@ def pitch_name(midi: int) -> str:
     return NOTE_NAMES[midi % 12] + str(midi // 12 - 1)
 
 
+def _normalize_mode_name(mode: str) -> str:
+    """Normalize user-facing mode names into canonical scale ids."""
+    normalized = " ".join(mode.strip().lower().replace("_", " ").replace("-", " ").split())
+    canonical = MODE_ALIASES.get(normalized, normalized.replace(" ", "_"))
+    if canonical not in SCALES:
+        raise ValueError(f"Unknown mode: {mode}")
+    return canonical
+
+
 def parse_key(key_str: str) -> dict:
     """Parse key string -> {tonic: 0-11, tonic_name: str, mode: str}.
 
@@ -100,7 +129,8 @@ def parse_key(key_str: str) -> dict:
 
     parts = s.split()
     raw_tonic = parts[0]
-    mode = parts[1].lower() if len(parts) > 1 else 'major'
+    raw_mode = " ".join(parts[1:]) if len(parts) > 1 else 'major'
+    mode = _normalize_mode_name(raw_mode)
 
     # Normalize tonic: capitalize first letter
     tonic_name = raw_tonic[0].upper() + raw_tonic[1:]
@@ -117,17 +147,18 @@ def parse_key(key_str: str) -> dict:
 
 def get_scale_pitches(tonic: int, mode: str) -> list[int]:
     """Return pitch classes (0-11) for the scale."""
-    intervals = SCALES.get(mode, SCALES['major'])
+    intervals = SCALES[_normalize_mode_name(mode)]
     return [(tonic + iv) % 12 for iv in intervals]
 
 
 def build_chord(degree: int, tonic: int, mode: str) -> dict:
     """Build triad from scale degree (0-indexed)."""
+    mode = _normalize_mode_name(mode)
     scale = get_scale_pitches(tonic, mode)
     root = scale[degree % 7]
     third = scale[(degree + 2) % 7]
     fifth = scale[(degree + 4) % 7]
-    quality = TRIAD_QUALITIES.get(mode, TRIAD_QUALITIES['major'])[degree % 7]
+    quality = TRIAD_QUALITIES[mode][degree % 7]
     return {
         "root_pc": root,
         "pitch_classes": [root, third, fifth],