livepilot 1.9.9 → 1.9.12

package/remote_script/LivePilot/diagnostics.py

@@ -14,6 +14,16 @@ from .router import register
 _DEFAULT_NAME_PATTERNS = frozenset([
     "MIDI", "Audio", "Inst", "Return",
 ])
+_PLUGIN_CLASS_NAMES = frozenset(["PluginDevice", "AuPluginDevice"])
+_SAMPLE_DEPENDENT_DEVICE_NAMES = frozenset([
+    "idensity",
+    "tardigrain",
+    "koala sampler",
+    "burns audio granular",
+    "audiolayer",
+    "segments",
+    "segments (instr)",
+])
 
 
 def _looks_default_name(name):
@@ -29,6 +39,22 @@ def _looks_default_name(name):
     return False
 
 
+def _sample_dependent_device(name):
+    lowered = name.strip().lower()
+    for candidate in _SAMPLE_DEPENDENT_DEVICE_NAMES:
+        if candidate in lowered:
+            return True
+    return False
+
+
+def _safe_attr(obj, name, default=None):
+    """Read a Live attribute defensively — some track types omit properties."""
+    try:
+        return getattr(obj, name)
+    except Exception:
+        return default
+
+
 @register("get_session_diagnostics")
 def get_session_diagnostics(song, params):
     """Analyze the session and return a diagnostic report."""
@@ -57,19 +83,21 @@ def get_session_diagnostics(song, params):
     unnamed_tracks = []
     empty_tracks = []  # no clips at all
     no_device_midi_tracks = []  # MIDI tracks with no instruments
+    opaque_or_failed_plugins = []
+    sample_dependent_devices = []
     track_slots = []  # cached clip_slots per track (avoid re-evaluating LOM tuple)
 
     for i, track in enumerate(tracks):
         # Armed check
-        if track.arm:
+        if _safe_attr(track, "arm", False):
             armed_tracks.append({"index": i, "name": track.name})
 
         # Solo check
-        if track.solo:
+        if _safe_attr(track, "solo", False):
             soloed_tracks.append({"index": i, "name": track.name})
 
         # Muted tracks (informational, only flag if many)
-        if track.mute:
+        if _safe_attr(track, "mute", False):
             muted_tracks.append({"index": i, "name": track.name})
 
         # Unnamed / default name check
@@ -91,9 +119,33 @@ def get_session_diagnostics(song, params):
             empty_tracks.append({"index": i, "name": track.name})
 
         # MIDI track with no devices (no instrument loaded)
-        if track.has_midi_input and len(list(track.devices)) == 0:
+        if _safe_attr(track, "has_midi_input", False) and len(list(track.devices)) == 0:
             no_device_midi_tracks.append({"index": i, "name": track.name})
 
+        for j, device in enumerate(track.devices):
+            class_name = getattr(device, "class_name", "")
+            try:
+                parameter_count = len(list(device.parameters))
+            except Exception:
+                parameter_count = None
+
+            if class_name in _PLUGIN_CLASS_NAMES and parameter_count is not None and parameter_count <= 1:
+                opaque_or_failed_plugins.append({
+                    "track_index": i,
+                    "track_name": track.name,
+                    "device_index": j,
+                    "device_name": device.name,
+                    "parameter_count": parameter_count,
+                })
+
+            if _sample_dependent_device(device.name):
+                sample_dependent_devices.append({
+                    "track_index": i,
+                    "track_name": track.name,
+                    "device_index": j,
+                    "device_name": device.name,
+                })
+
     # Build issues from checks
     if armed_tracks:
         issues.append({
@@ -145,6 +197,30 @@ def get_session_diagnostics(song, params):
             "details": no_device_midi_tracks,
         })
 
+    if opaque_or_failed_plugins:
+        issues.append({
+            "type": "opaque_or_failed_plugins",
+            "severity": "warning",
+            "message": (
+                "%d plugin(s) expose <=1 host parameter. If silent after auditioning, "
+                "they likely failed to initialize. If audio is flowing, they are opaque to MCP control."
+                % len(opaque_or_failed_plugins)
+            ),
+            "details": opaque_or_failed_plugins,
+        })
+
+    if sample_dependent_devices:
+        issues.append({
+            "type": "sample_dependent_devices",
+            "severity": "info",
+            "message": (
+                "%d likely sample-dependent device(s) loaded — they may stay silent until source audio is loaded "
+                "inside the plugin UI."
+                % len(sample_dependent_devices)
+            ),
+            "details": sample_dependent_devices,
+        })
+
     # ── Scene-level checks ──────────────────────────────────────────────
 
     empty_scenes = []
@@ -171,7 +247,7 @@ def get_session_diagnostics(song, params):
 
     soloed_returns = []
     for i, track in enumerate(return_tracks):
-        if track.solo:
+        if _safe_attr(track, "solo", False):
             soloed_returns.append({"index": i, "name": track.name})
 
     if soloed_returns:

package/remote_script/LivePilot/router.py

@@ -51,6 +51,15 @@ def dispatch(song, command):
     if cmd_type is None:
         return error_response(request_id, "Missing 'type' field", INVALID_PARAM)
 
+    if params is None:
+        params = {}
+    elif not isinstance(params, dict):
+        return error_response(
+            request_id,
+            "'params' must be an object/dict",
+            INVALID_PARAM,
+        )
+
     # Built-in ping — no handler registration needed.
     if cmd_type == "ping":
         return success_response(request_id, {"pong": True})
@@ -65,7 +74,20 @@ def dispatch(song, command):
 
     try:
         result = handler(song, params)
+        if isinstance(result, dict) and "error" in result:
+            return error_response(
+                request_id,
+                result["error"],
+                result.get("code", INTERNAL),
+            )
         return success_response(request_id, result)
+    except KeyError as exc:
+        # Missing required parameter — report as INVALID_PARAM, not INTERNAL
+        return error_response(
+            request_id,
+            "Missing required parameter: %s" % str(exc),
+            INVALID_PARAM,
+        )
     except IndexError as exc:
         return error_response(request_id, str(exc), INDEX_ERROR)
     except ValueError as exc:

package/remote_script/LivePilot/server.py

@@ -82,6 +82,7 @@ class LivePilotServer(object):
         self._running = False
         self._server_socket = None
         self._thread = None
+        self._client_thread = None
         self._command_queue = queue.Queue()
         self._client_lock = threading.Lock()
         self._client_connected = False
@@ -106,6 +107,8 @@ class LivePilotServer(object):
                 pass
         if self._thread and self._thread.is_alive():
             self._thread.join(timeout=3)
+        if self._client_thread and self._client_thread.is_alive():
+            self._client_thread.join(timeout=3)
         self._log("Server stopped")
 
     # ── Logging ──────────────────────────────────────────────────────────
@@ -158,19 +161,12 @@ class LivePilotServer(object):
                             pass
                         continue
                     self._client_connected = True
-                self._log("Client connected from %s:%d" % addr)
-                try:
-                    self._handle_client(client)
-                except OSError as exc:
-                    self._log("Client error: %s" % exc)
-                finally:
-                    with self._client_lock:
-                        self._client_connected = False
-                    try:
-                        client.close()
-                    except OSError:
-                        pass
-                    self._log("Client disconnected")
+                self._client_thread = threading.Thread(
+                    target=self._run_client_session,
+                    args=(client, addr),
+                )
+                self._client_thread.daemon = True
+                self._client_thread.start()
             except socket.timeout:
                 continue
             except OSError:
@@ -183,6 +179,22 @@ class LivePilotServer(object):
         except OSError:
             pass
 
+    def _run_client_session(self, client, addr):
+        """Handle one active client without blocking new connection rejects."""
+        self._log("Client connected from %s:%d" % addr)
+        try:
+            self._handle_client(client)
+        except OSError as exc:
+            self._log("Client error: %s" % exc)
+        finally:
+            try:
+                client.close()
+            except OSError:
+                pass
+            with self._client_lock:
+                self._client_connected = False
+            self._log("Client disconnected")
+
     def _handle_client(self, client):
         """Read newline-delimited JSON from a connected client."""
         client.settimeout(1.0)
@@ -193,6 +205,9 @@ class LivePilotServer(object):
                 if not data:
                     break
                 buf += data.decode("utf-8", errors="replace")
+                if len(buf) > 4 * 1024 * 1024:  # 4 MB
+                    self._log("Client buffer overflow — disconnecting")
+                    break
                 while "\n" in buf:
                     line, buf = buf.split("\n", 1)
                     line = line.strip()
@@ -237,8 +252,14 @@ class LivePilotServer(object):
         try:
             self._cs.schedule_message(0, self._process_next_command)
         except AssertionError:
-            # Already on main thread — process directly
-            self._process_next_command()
+            # ControlSurface is disconnecting — return error instead of
+            # running LOM calls on the TCP thread (which would be unsafe)
+            response_queue.put({
+                "id": request_id,
+                "ok": False,
+                "error": {"code": "STATE_ERROR", "message": "Script is disconnecting"},
+            })
+            return
 
         # Wait for response from main thread
         try:
@@ -284,7 +305,8 @@ class LivePilotServer(object):
             try:
                 self._cs.schedule_message(1, send_response)  # ~100ms
             except AssertionError:
-                send_response()
+                # ControlSurface disconnecting — send result immediately
+                response_queue.put(result)
         else:
             response_queue.put(result)
             # Drain any remaining queued commands
@@ -296,7 +318,9 @@ class LivePilotServer(object):
             try:
                 self._cs.schedule_message(0, self._process_next_command)
             except AssertionError:
-                self._process_next_command()
+                # ControlSurface disconnecting — drop remaining commands
+                # rather than running LOM calls on the wrong thread
+                pass
 
     # ── Socket I/O ───────────────────────────────────────────────────────
 

package/remote_script/LivePilot/tracks.py

@@ -175,9 +175,14 @@ def duplicate_track(song, params):
             "Track index %d out of range (0..%d)"
             % (track_index, len(tracks) - 1)
         )
+    count_before = len(tracks)
     song.duplicate_track(track_index)
-    new_index = track_index + 1
-    return {"index": new_index, "name": list(song.tracks)[new_index].name}
+    all_tracks = list(song.tracks)
+    # For group tracks, Ableton duplicates the group + all children.
+    # The duplicate block starts right after the original group's last child.
+    added = len(all_tracks) - count_before
+    new_index = track_index + added
+    return {"index": new_index, "name": all_tracks[new_index].name}
 
 
 @register("set_track_name")

package/remote_script/LivePilot/transport.py

@@ -53,9 +53,9 @@ def get_session_info(song, params):
         "metronome": song.metronome,
         "record_mode": song.record_mode,
         "session_record": song.session_record,
-        "track_count": len(list(song.tracks)),
-        "return_track_count": len(list(song.return_tracks)),
-        "scene_count": len(list(song.scenes)),
+        "track_count": len(tracks_info),
+        "return_track_count": len(return_tracks_info),
+        "scene_count": len(scenes_info),
         "tracks": tracks_info,
         "return_tracks": return_tracks_info,
         "scenes": scenes_info,

package/requirements.txt

@@ -3,9 +3,11 @@ numpy>=1.24.0
 fastmcp>=3.0.0,<4.0.0
 midiutil>=1.2.1
 pretty_midi>=0.2.10
-opycleid>=0.5.1
 # v1.8 Perception Layer (offline analysis)
 pyloudnorm>=0.1.0
 soundfile>=0.12.0
 scipy>=1.11.0
 mutagen>=1.47.0
+
+# Optional: neo-Riemannian group theory (not required — harmony engine is pure Python)
+# pip install opycleid>=0.5.1