livepilot 1.9.23 → 1.10.0

package/remote_script/LivePilot/browser.py

@@ -1,5 +1,5 @@
 """
-LivePilot - Browser domain handlers (5 commands).
+LivePilot - Browser domain handlers (6 commands).
 """
 
 import Live
@@ -386,6 +386,61 @@ def load_browser_item(song, params):
     )
 
 
+_SCAN_MAX_ITERATIONS = 100000
+
+
+def _scan_recursive(item, results, depth, max_depth, max_per_category,
+                    _counter=None):
+    """Recursively collect loadable browser items with iteration cap."""
+    if _counter is None:
+        _counter = [0]
+    if depth > max_depth or len(results) >= max_per_category:
+        return
+    for child in item.children:
+        _counter[0] += 1
+        if _counter[0] > _SCAN_MAX_ITERATIONS or len(results) >= max_per_category:
+            return
+        if child.is_loadable:
+            entry = {"name": child.name, "is_loadable": True}
+            try:
+                entry["uri"] = child.uri
+            except AttributeError:
+                entry["uri"] = None
+            results.append(entry)
+        if child.is_folder:
+            _scan_recursive(
+                child, results, depth + 1, max_depth, max_per_category,
+                _counter
+            )
+            if len(results) >= max_per_category:
+                return
+
+
+@register("scan_browser_deep")
+def scan_browser_deep(song, params):
+    """Walk the entire browser tree and return all loadable items by category.
+
+    Parameters
+    ----------
+    max_per_category : int, optional
+        Maximum items to collect per top-level category (default 1000).
+    max_depth : int, optional
+        Maximum recursion depth into the browser tree (default 4).
+    """
+    max_per_category = int(params.get("max_per_category", 1000))
+    max_depth = int(params.get("max_depth", 4))
+    browser = _get_browser()
+    categories = _get_categories(browser)
+
+    result = {}
+    for cat_name, cat_item in categories.items():
+        items = []
+        _scan_recursive(cat_item, items, 0, max_depth, max_per_category)
+        result[cat_name] = items
+
+    return {"categories": result}
+
+
 @register("get_device_presets")
 def get_device_presets(song, params):
     """List available presets for a device type by searching the browser.

package/remote_script/LivePilot/devices.py

@@ -1,5 +1,5 @@
 """
-LivePilot - Device domain handlers (11 commands).
+LivePilot - Device domain handlers (12 commands).
 """
 
 import Live
@@ -46,7 +46,7 @@ def get_device_parameters(song, params):
 
     parameters = []
     for i, param in enumerate(device.parameters):
-        parameters.append({
+        info = {
             "index": i,
             "name": param.name,
             "value": param.value,
@@ -54,7 +54,13 @@ def get_device_parameters(song, params):
             "max": param.max,
             "is_quantized": param.is_quantized,
             "value_string": param.str_for_value(param.value),
-        })
+        }
+        # 12.2+ feature: native display_value
+        try:
+            info["display_value"] = param.display_value
+        except AttributeError:
+            pass
+        parameters.append(info)
     return {"parameters": parameters}
 
 
@@ -104,13 +110,19 @@ def set_device_parameter(song, params):
         raise ValueError("Must provide parameter_name or parameter_index")
 
     param.value = value
-    return {
+    result = {
         "name": param.name,
         "value": param.value,
         "value_string": param.str_for_value(param.value),
         "min": param.min,
         "max": param.max,
     }
+    # 12.2+: include display_value
+    try:
+        result["display_value"] = param.display_value
+    except AttributeError:
+        pass
+    return result
 
 
 @register("batch_set_parameters")
@@ -163,11 +175,17 @@ def batch_set_parameters(song, params):
                 )
 
         param.value = value
-        results.append({
+        result_entry = {
             "name": param.name,
             "value": param.value,
             "value_string": param.str_for_value(param.value),
-        })
+        }
+        # 12.2+: include display_value
+        try:
+            result_entry["display_value"] = param.display_value
+        except AttributeError:
+            pass
+        results.append(result_entry)
 
     return {"parameters": results}
 
@@ -408,6 +426,198 @@ def load_device_by_uri(song, params):
     )
 
 
+# ── Device name registry for insert_device (12.3+) ──────────────────────
+
+NATIVE_DEVICE_NAMES = frozenset({
+    # Instruments
+    "Analog", "Collision", "Drift", "Electric", "Drum Rack",
+    "Instrument Rack", "Meld", "Operator", "Sampler", "Simpler",
+    "Tension", "Wavetable",
+    # Audio Effects
+    "Align Delay", "Amp", "Audio Effect Rack", "Auto Filter",
+    "Auto Pan-Tremolo", "Auto Shift", "Beat Repeat", "Cabinet",
+    "Channel EQ", "Chorus-Ensemble", "Color Limiter", "Compressor",
+    "Convolution Reverb", "Corpus", "Delay", "Drum Buss",
+    "Dynamic Tube", "Echo", "EQ Eight", "EQ Three", "Erosion",
+    "External Audio Effect", "Flanger", "Frequency Shifter", "Gate",
+    "Glue Compressor", "Grain Delay", "Hybrid Reverb", "Limiter",
+    "Looper", "Multiband Dynamics", "Overdrive", "Pedal",
+    "Phaser-Flanger", "Pitch Hack", "Redux", "Re-Enveloper",
+    "Resonators", "Reverb", "Roar", "Saturator", "Shifter",
+    "Spectral Blur", "Spectral Resonator", "Spectral Time", "Tuner",
+    "Utility", "Vinyl Distortion", "Vocoder",
+    # MIDI Effects
+    "Arpeggiator", "Chord", "Expression Control", "MIDI Effect Rack",
+    "Note Echo", "Note Length", "Pitch", "Random", "Scale", "Strum",
+    "Velocity",
+})
+
+# Case-insensitive lookup for user convenience
+_DEVICE_NAME_LOOKUP = {name.lower(): name for name in NATIVE_DEVICE_NAMES}
+
+
+@register("insert_device")
+def insert_device(song, params):
+    """Insert a native Live device by name (12.3+ API).
+
+    Much faster than browser search — a single call with no state dependency.
+    Only works for native devices (not plugins or M4L).
+
+    Required: track_index, device_name
+    Optional: position (-1 = end of chain, default), chain_index + device_index (for rack chains)
+    """
+    from .version_detect import has_feature
+
+    if not has_feature("insert_device"):
+        raise RuntimeError(
+            "insert_device requires Live 12.3+. "
+            "Use find_and_load_device (browser search) instead."
+        )
+
+    track_index = int(params["track_index"])
+    device_name = str(params["device_name"])
+    position = int(params.get("position", -1))
+    chain_index = params.get("chain_index")
+
+    # Resolve canonical name (case-insensitive)
+    canonical = _DEVICE_NAME_LOOKUP.get(device_name.lower())
+    if canonical is None:
+        raise ValueError(
+            "Device '%s' is not a native Live device. "
+            "insert_device only supports native devices (not plugins or M4L). "
+            "Use find_and_load_device for plugins."
+            % device_name
+        )
+
+    track = get_track(song, track_index)
+
+    song.begin_undo_step()
+    try:
+        if chain_index is not None:
+            # 12.3+ Chain.insert_device — insert into a rack chain
+            chain_index = int(chain_index)
+            device_on_track = get_device(track, int(params.get("device_index", 0)))
+            chains = list(device_on_track.chains)
+            if chain_index < 0 or chain_index >= len(chains):
+                raise IndexError(
+                    "Chain index %d out of range (0..%d)"
+                    % (chain_index, len(chains) - 1)
+                )
+            chain = chains[chain_index]
+            if position >= 0:
+                device = chain.insert_device(canonical, position)
+            else:
+                device = chain.insert_device(canonical)
+        else:
+            # Track-level insertion
+            if position >= 0:
+                device = track.insert_device(canonical, position)
+            else:
+                device = track.insert_device(canonical)
+    finally:
+        song.end_undo_step()
+
+    # Read back the device info — use "loaded" key to match
+    # the convention expected by _postflight_loaded_device on MCP side
+    result = {
+        "loaded": device.name,
+        "class_name": device.class_name,
+        "track_index": track_index,
+        "parameter_count": len(list(device.parameters)),
+    }
+    if position >= 0:
+        result["position"] = position
+    return result
+
+
+@register("insert_rack_chain")
+def insert_rack_chain(song, params):
+    """Insert a new chain into an Instrument Rack, Audio Effect Rack, or Drum Rack (12.3+).
+
+    Required: track_index, device_index
+    Optional: position (-1 = end)
+    """
+    from .version_detect import has_feature
+
+    if not has_feature("insert_chain"):
+        raise RuntimeError(
+            "insert_rack_chain requires Live 12.3+."
+        )
+
+    track_index = int(params["track_index"])
+    device_index = int(params["device_index"])
+    position = int(params.get("position", -1))
+
+    track = get_track(song, track_index)
+    device = get_device(track, device_index)
+
+    if not device.can_have_chains:
+        raise ValueError(
+            "Device '%s' is not a rack — cannot insert chains"
+            % device.name
+        )
+
+    song.begin_undo_step()
+    try:
+        if position >= 0:
+            device.insert_chain(position)
+        else:
+            device.insert_chain()
+    finally:
+        song.end_undo_step()
+
+    chain_count = len(list(device.chains))
+    return {
+        "inserted": True,
+        "track_index": track_index,
+        "device_index": device_index,
+        "chain_count": chain_count,
+    }
+
+
+@register("set_drum_chain_note")
+def set_drum_chain_note(song, params):
+    """Set which MIDI note triggers a drum chain (12.3+).
+
+    Required: track_index, device_index, chain_index, note
+    note: MIDI note number (0-127), or -1 for 'All Notes'
+    """
+    from .version_detect import has_feature
+
+    if not has_feature("drum_chain_in_note"):
+        raise RuntimeError(
+            "set_drum_chain_note requires Live 12.3+."
+        )
+
+    track_index = int(params["track_index"])
+    device_index = int(params["device_index"])
+    chain_index = int(params["chain_index"])
+    note = int(params["note"])
+
+    if note < -1 or note > 127:
+        raise ValueError("note must be -1 (All Notes) or 0-127")
+
+    track = get_track(song, track_index)
+    device = get_device(track, device_index)
+
+    chains = list(device.chains)
+    if chain_index < 0 or chain_index >= len(chains):
+        raise IndexError(
+            "Chain index %d out of range (0..%d)"
+            % (chain_index, len(chains) - 1)
+        )
+
+    chain = chains[chain_index]
+    chain.in_note = note
+
+    return {
+        "track_index": track_index,
+        "device_index": device_index,
+        "chain_index": chain_index,
+        "in_note": note,
+    }
+
+
 @register("find_and_load_device")
 def find_and_load_device(song, params):
     """Find a device by name in the browser and load it onto a track.
@@ -420,6 +630,26 @@ def find_and_load_device(song, params):
     track = get_track(song, track_index)
     browser = _get_browser()
 
+    # 12.3+ fast path: try insert_device for native devices
+    from .version_detect import has_feature
+    if has_feature("insert_device"):
+        canonical = _DEVICE_NAME_LOOKUP.get(device_name)
+        if canonical is not None:
+            try:
+                song.begin_undo_step()
+                try:
+                    device = track.insert_device(canonical)
+                finally:
+                    song.end_undo_step()
+                return {
+                    "loaded": device.name,
+                    "class_name": device.class_name,
+                    "track_index": track_index,
+                    "parameter_count": len(list(device.parameters)),
+                }
+            except Exception:
+                pass  # Fall through to browser search
+
     MAX_ITERATIONS = 50000
     iterations = 0
 

package/remote_script/LivePilot/mixing.py

@@ -133,14 +133,15 @@ def get_track_meters(song, params):
             "index": idx,
             "name": track.name,
         }
-        if track.has_audio_output:
+        muted = bool(getattr(track, "mute", False))
+        if track.has_audio_output and not muted:
             entry["level"] = track.output_meter_level
             if include_stereo:
                 entry["left"] = track.output_meter_left
                 entry["right"] = track.output_meter_right
         else:
             entry["level"] = 0.0
-            entry["has_audio_output"] = False
+            entry["has_audio_output"] = bool(getattr(track, "has_audio_output", False))
             if include_stereo:
                 entry["left"] = 0.0
                 entry["right"] = 0.0
@@ -177,7 +178,11 @@ def get_mix_snapshot(song, params):
         tracks.append({
             "index": i,
             "name": track.name,
-            "meter_level": track.output_meter_level if track.has_audio_output else 0.0,
+            "meter_level": (
+                track.output_meter_level
+                if track.has_audio_output and not bool(getattr(track, "mute", False))
+                else 0.0
+            ),
             "volume": track.mixer_device.volume.value,
             "pan": track.mixer_device.panning.value,
             "mute": track.mute,

package/remote_script/LivePilot/server.py

@@ -255,7 +255,11 @@ class LivePilotServer(object):
         except AssertionError:
             # ControlSurface is disconnecting — return error instead of
             # running LOM calls on the TCP thread (which would be unsafe)
-            response_queue.put({
+            try:
+                self._command_queue.get_nowait()
+            except queue.Empty:
+                pass
+            self._send(client, {
                 "id": request_id,
                 "ok": False,
                 "error": {"code": "STATE_ERROR", "message": "Script is disconnecting"},

package/remote_script/LivePilot/transport.py

@@ -3,6 +3,7 @@ LivePilot - Transport domain handlers (10 commands).
 """
 
 from .router import register
+from .version_detect import version_string, get_api_features
 
 
 @register("get_session_info")
@@ -59,6 +60,8 @@ def get_session_info(song, params):
         "tracks": tracks_info,
         "return_tracks": return_tracks_info,
         "scenes": scenes_info,
+        "live_version": version_string(),
+        "api_features": get_api_features(),
     }
 
 

package/remote_script/LivePilot/version_detect.py

@@ -0,0 +1,78 @@
+"""
+LivePilot - Ableton Live version detection and feature flags.
+
+Detects the running Live version and provides feature availability checks.
+Used by handlers to conditionally use new APIs (12.1.10+, 12.2+, 12.3+).
+"""
+
+import Live
+
+# ── Feature version requirements ────────────────────────────────────────
+
+FEATURES = {
+    "create_midi_clip_arrangement": (12, 1, 10),
+    "looper_export": (12, 1, 0),
+    "tuning_system": (12, 1, 0),
+    "display_value": (12, 2, 0),
+    "clip_start_time_observable": (12, 2, 0),
+    "take_lanes_api": (12, 2, 0),
+    "insert_device": (12, 3, 0),
+    "insert_chain": (12, 3, 0),
+    "drum_chain_in_note": (12, 3, 0),
+    "stem_separation": (12, 3, 0),
+    "replace_sample_native": (12, 4, 0),
+}
+
+
+# ── Cached version ──────────────────────────────────────────────────────
+
+_cached_version = None
+
+
+def get_live_version():
+    """Return (major, minor, patch) of the running Live instance.
+
+    Uses Live.Application.get_application() to read version info.
+    Falls back to (12, 0, 0) if detection fails.
+    """
+    global _cached_version
+    if _cached_version is not None:
+        return _cached_version
+
+    try:
+        app = Live.Application.get_application()
+        major = app.get_major_version()
+        minor = app.get_minor_version()
+        # get_bugfix_version() was added later; fall back to 0
+        try:
+            patch = app.get_bugfix_version()
+        except AttributeError:
+            patch = 0
+        _cached_version = (int(major), int(minor), int(patch))
+    except Exception:
+        _cached_version = (12, 0, 0)
+
+    return _cached_version
+
+
+def has_feature(feature_name):
+    """Check if a feature is available in the running Live version.
+
+    Returns True if the detected version >= the feature's required version.
+    Returns False for unknown feature names (safe default).
+    """
+    required = FEATURES.get(feature_name)
+    if required is None:
+        return False
+    return get_live_version() >= required
+
+
+def get_api_features():
+    """Return a dict of all feature flags for the current version."""
+    return {name: has_feature(name) for name in FEATURES}
+
+
+def version_string():
+    """Return version as a dot-separated string, e.g. '12.3.6'."""
+    v = get_live_version()
+    return "%d.%d.%d" % v

package/scripts/sync_metadata.py

@@ -0,0 +1,132 @@
+#!/usr/bin/env python3
+"""Metadata sync — single source of truth for version and tool count.
+
+Reads version from package.json, tool count from test_tools_contract.py,
+and verifies all known locations are in sync.
+
+Usage:
+    python scripts/sync_metadata.py --check   # verify, exit 1 if stale
+    python scripts/sync_metadata.py --fix     # auto-fix stale references
+"""
+
+import json
+import re
+import sys
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[1]
+
+
+def get_version() -> str:
+    """Read version from package.json (source of truth)."""
+    pkg = json.loads((ROOT / "package.json").read_text())
+    return pkg["version"]
+
+
+def get_tool_count() -> int:
+    """Read tool count from test_tools_contract.py assertion."""
+    src = (ROOT / "tests" / "test_tools_contract.py").read_text()
+    match = re.search(r"assert len\(tools\) == (\d+)", src)
+    if match:
+        return int(match.group(1))
+    raise ValueError("Could not find tool count assertion in test_tools_contract.py")
+
+
+# Files that must contain the version string
+VERSION_FILES = [
+    "package.json",
+    "server.json",
+    "manifest.json",
+    "livepilot/.claude-plugin/plugin.json",
+    "livepilot/.Codex-plugin/plugin.json",
+    ".claude-plugin/marketplace.json",
+    "mcp_server/__init__.py",
+    "remote_script/LivePilot/__init__.py",
+    "CLAUDE.md",
+    "AGENTS.md",
+    "livepilot/skills/livepilot-core/references/overview.md",
+    "docs/M4L_BRIDGE.md",
+]
+
+# Files that must contain the tool count
+TOOL_COUNT_FILES = [
+    "README.md",
+    "package.json",
+    "server.json",
+    "CLAUDE.md",
+    "AGENTS.md",
+    "CONTRIBUTING.md",
+    "livepilot/.claude-plugin/plugin.json",
+    "livepilot/.Codex-plugin/plugin.json",
+    "livepilot/skills/livepilot-core/SKILL.md",
+    "livepilot/skills/livepilot-core/references/overview.md",
+    "docs/manual/index.md",
+    "docs/manual/tool-reference.md",
+    "docs/manual/tool-catalog.md",
+]
+
+
+def check_version(version: str) -> list[str]:
+    """Check all version files for staleness."""
+    issues = []
+    for rel_path in VERSION_FILES:
+        path = ROOT / rel_path
+        if not path.exists():
+            continue
+        content = path.read_text()
+        if version not in content:
+            # Find what version IS there
+            old = re.search(r"1\.\d+\.\d+", content)
+            old_ver = old.group(0) if old else "???"
+            if old_ver != version:
+                issues.append(f"  {rel_path}: has {old_ver}, expected {version}")
+    return issues
+
+
+def check_tool_count(count: int) -> list[str]:
+    """Check all tool count files for staleness."""
+    issues = []
+    count_str = str(count)
+    for rel_path in TOOL_COUNT_FILES:
+        path = ROOT / rel_path
+        if not path.exists():
+            continue
+        content = path.read_text()
+        # Look for "N tools" pattern
+        matches = re.findall(r"(\d+)\s+tools", content)
+        for m in matches:
+            if m != count_str and int(m) > 250:  # ignore subset counts like "210 tools"
+                issues.append(f"  {rel_path}: has '{m} tools', expected '{count_str} tools'")
+                break
+    return issues
+
+
+def main():
+    mode = sys.argv[1] if len(sys.argv) > 1 else "--check"
+
+    version = get_version()
+    tool_count = get_tool_count()
+
+    print(f"Source of truth: version={version}, tools={tool_count}")
+
+    version_issues = check_version(version)
+    count_issues = check_tool_count(tool_count)
+
+    all_issues = version_issues + count_issues
+
+    if all_issues:
+        print(f"\nFound {len(all_issues)} stale reference(s):")
+        for issue in all_issues:
+            print(issue)
+        if mode == "--check":
+            sys.exit(1)
+        elif mode == "--fix":
+            print("\n--fix mode not yet implemented. Fix manually.")
+            sys.exit(1)
+    else:
+        print("All metadata in sync.")
+        sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()