livepilot 1.9.8 → 1.9.11

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:
+            with self._client_lock:
+                self._client_connected = False
+            try:
+                client.close()
+            except OSError:
+                pass
+            self._log("Client disconnected")
+
     def _handle_client(self, client):
         """Read newline-delimited JSON from a connected client."""
         client.settimeout(1.0)

package/remote_script/LivePilot/tracks.py

@@ -344,8 +344,23 @@ def flatten_track(song, params):
         )
     song.begin_undo_step()
     try:
-        # flatten() is a method on the track, not the song
-        track.flatten()
+        flattened = False
+        try:
+            track.flatten()
+            flattened = True
+        except AttributeError:
+            pass
+        if not flattened:
+            try:
+                song.flatten_track(track_index)
+                flattened = True
+            except AttributeError:
+                pass
+        if not flattened:
+            raise ValueError(
+                "flatten() not available via ControlSurface API. "
+                "Use Ableton's Flatten command manually."
+            )
     finally:
         song.end_undo_step()
     return {