livepilot 1.23.3 → 1.23.5

package/mcp_server/user_corpus/wizard.py

@@ -0,0 +1,224 @@
+"""First-run setup wizard — detects sensible scan candidates on the user's
+filesystem and returns approval prompts the agent (in Claude Code) drives
+through conversation.
+
+The wizard does NOT scan anything. It surveys, returns candidates with
+file counts, and lets the calling agent confirm each with the user before
+adding to the manifest.
+"""
+
+from __future__ import annotations
+
+import platform
+from dataclasses import dataclass, asdict
+from pathlib import Path
+from typing import Iterable
+
+
+# ─── Candidate categories the wizard offers ─────────────────────────────────
+
+
+@dataclass
+class WizardCandidate:
+    """One scannable folder the wizard surfaces for approval."""
+    category: str              # "user_library_racks", "max_devices", "plugins", ...
+    suggested_id: str          # e.g. "user-library-racks"
+    type: str                  # scanner type_id
+    path: str
+    file_count: int            # estimated files (capped during enumeration)
+    sample_filenames: list[str]
+    description: str           # 1-2 sentence prompt the agent reads to the user
+    recommended_default: bool  # whether to auto-confirm (false = always ask)
+
+
+def survey_filesystem() -> list[WizardCandidate]:
+    """Inspect the OS-standard locations + return candidates for approval.
+
+    Does not write anything. Caller (skill/agent) walks each candidate and asks
+    the user "scan this? y/n", then calls corpus_add_source for each yes.
+    """
+    candidates: list[WizardCandidate] = []
+    if platform.system() == "Darwin":
+        candidates.extend(_macos_candidates())
+    elif platform.system() == "Windows":
+        candidates.extend(_windows_candidates())
+    else:
+        candidates.extend(_linux_candidates())
+    return [c for c in candidates if c.file_count > 0]
+
+
+def _count_files(root: Path, extensions: Iterable[str], cap: int = 5000) -> tuple[int, list[str]]:
+    """Count files matching any of the extensions under root. Return (count, samples).
+
+    Cap prevents pathological scans during the survey. Caller should still rescan
+    for real (the wizard is just for sizing + showing the user what's there).
+    """
+    if not root.exists():
+        return 0, []
+    exts = tuple(e.lower() for e in extensions)
+    count = 0
+    samples: list[str] = []
+    try:
+        for p in root.rglob("*"):
+            try:
+                if not p.is_file() and not p.is_dir():
+                    continue
+                # Bundle-style "files" (.amxd, .vst3) appear as dirs OR files
+                # depending on OS — count both
+                if p.suffix.lower() in exts:
+                    count += 1
+                    if len(samples) < 5:
+                        samples.append(p.name)
+                    if count >= cap:
+                        break
+            except (PermissionError, OSError):
+                continue
+    except (PermissionError, OSError):
+        pass
+    return count, samples
+
+
+def _macos_candidates() -> list[WizardCandidate]:
+    home = Path.home()
+    out: list[WizardCandidate] = []
+
+    # 1. User Library racks (.adg / .adv)
+    user_lib = home / "Music/Ableton/User Library/Presets"
+    if user_lib.exists():
+        n, samples = _count_files(user_lib, [".adg", ".adv"])
+        if n > 0:
+            out.append(WizardCandidate(
+                category="user_library_racks", suggested_id="user-library-racks",
+                type="adg", path=str(user_lib), file_count=n, sample_filenames=samples,
+                description=(
+                    f"Ableton User Library — {n} rack/effect presets (.adg/.adv). "
+                    "Indexes every saved chain you've made + third-party racks under "
+                    "your User Library. Good first scan."
+                ),
+                recommended_default=True,
+            ))
+
+    # 2. Max for Live devices (.amxd) — multiple plausible locations
+    for label, p in (
+        ("max_for_live_devices", home / "Documents/Max 9/Max for Live Devices"),
+        ("max_for_live_devices_v8", home / "Documents/Max 8/Max for Live Devices"),
+        ("user_library_m4l", home / "Music/Ableton/User Library/MAX MONTY/m4l_2024"),
+        ("user_library_m4l_alt", home / "Music/Ableton/User Library/Presets/Audio Effects/Max Audio Effect"),
+    ):
+        if p.exists():
+            n, samples = _count_files(p, [".amxd"])
+            if n > 0:
+                out.append(WizardCandidate(
+                    category="max_devices", suggested_id=label.replace("_", "-"),
+                    type="amxd", path=str(p), file_count=n, sample_filenames=samples,
+                    description=(
+                        f"Max for Live devices at {p.name} — {n} .amxd files. "
+                        "Captures device type (audio/instrument/midi), Max version, "
+                        "and any Live-exposed parameters."
+                    ),
+                    recommended_default=True,
+                ))
+
+    # 3. Plugin presets (.aupreset / .vstpreset / .fxp / .nksf)
+    for label, p in (
+        ("au_presets", home / "Library/Audio/Presets"),
+        ("vst3_presets", home / "Library/Audio/VST3 Presets"),
+    ):
+        if p.exists():
+            n, samples = _count_files(p, [".aupreset", ".vstpreset", ".fxp", ".fxb", ".nksf"])
+            if n > 0:
+                out.append(WizardCandidate(
+                    category="plugin_presets", suggested_id=label.replace("_", "-"),
+                    type="plugin-preset", path=str(p), file_count=n, sample_filenames=samples,
+                    description=(
+                        f"Plugin presets at {p.name} — {n} preset files. Captures "
+                        "plugin name + vendor + format. Param values are opaque per-plugin "
+                        "binary (same as PluginDevice in .als)."
+                    ),
+                    recommended_default=False,  # often noisy — opt-in
+                ))
+
+    # 4. Sample library (audio files) — .wav/.aif/.flac
+    # Note: corpus has no built-in sample scanner yet; these are advisory.
+    for label, p in (
+        ("apple_loops", Path("/Library/Audio/Apple Loops")),
+        ("user_apple_loops", home / "Library/Audio/Apple Loops"),
+        ("user_samples", home / "Music/Samples"),
+    ):
+        if p.exists():
+            n, _ = _count_files(p, [".wav", ".aif", ".aiff", ".flac"])
+            if n > 0:
+                out.append(WizardCandidate(
+                    category="samples_advisory", suggested_id=label.replace("_", "-"),
+                    type="sample",  # NOTE: scanner not yet implemented
+                    path=str(p), file_count=n, sample_filenames=[],
+                    description=(
+                        f"Sample library at {p.name} — {n} audio files. "
+                        "(Sample scanner is not yet implemented — this is a survey "
+                        "preview only. Skip for now or wait for the next build.)"
+                    ),
+                    recommended_default=False,
+                ))
+
+    # 5. Plugins are NOT a corpus_add_source — they're handled by
+    # corpus_detect_plugins. Surface as a separate "want to detect plugins?" step.
+    return out
+
+
+def _windows_candidates() -> list[WizardCandidate]:
+    home = Path.home()
+    out: list[WizardCandidate] = []
+    user_lib = home / "Documents" / "Ableton" / "User Library" / "Presets"
+    if user_lib.exists():
+        n, samples = _count_files(user_lib, [".adg", ".adv"])
+        if n > 0:
+            out.append(WizardCandidate(
+                category="user_library_racks", suggested_id="user-library-racks",
+                type="adg", path=str(user_lib), file_count=n, sample_filenames=samples,
+                description=f"Ableton User Library racks — {n} .adg/.adv presets.",
+                recommended_default=True,
+            ))
+    return out
+
+
+def _linux_candidates() -> list[WizardCandidate]:
+    return []  # Ableton Live isn't supported on Linux; corpus is mostly empty there
+
+
+# ─── Aggregate decision packet ──────────────────────────────────────────────
+
+
+def build_setup_proposal() -> dict:
+    """Return the full first-run setup proposal: candidates + plugin-detection prompt.
+
+    Caller (skill/agent) walks each item, confirms with user, then dispatches
+    corpus_add_source / corpus_detect_plugins as approved.
+    """
+    candidates = survey_filesystem()
+    return {
+        "candidates": [asdict(c) for c in candidates],
+        "candidate_count": len(candidates),
+        "categories": sorted({c.category for c in candidates}),
+        "plugin_detection_offer": {
+            "prompt": (
+                "Also detect installed VST3/AU/VST2/AAX plugins via "
+                "corpus_detect_plugins? This walks the OS-standard plugin "
+                "folders, parses each bundle's identity metadata, and writes "
+                "_inventory.json. Independent of the file scans above."
+            ),
+            "tool": "corpus_detect_plugins",
+            "recommended_default": True,
+        },
+        "instructions": (
+            "Walk the user through each candidate one at a time. For each, "
+            "summarize file_count + path + description, then ASK 'add this?' "
+            "and only call corpus_add_source on yes. After all candidates are "
+            "decided, ask about plugin_detection_offer separately. Finally "
+            "call corpus_scan() to index everything they approved."
+        ),
+        "do_not_scan": [
+            "Personal .als project folders unless the user explicitly points at one — "
+            "they're sensitive content that the user should opt into per-folder."
+        ],
+        "schema_version": 1,
+    }

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "livepilot",
-  "version": "1.23.3",
+  "version": "1.23.5",
   "mcpName": "io.github.dreamrec/livepilot",
-  "description": "Agentic production system for Ableton Live 12 \u2014 433 tools, 53 domains, 44 semantic moves. Device atlas (5264 devices, 120 enriched, 7 indexes), Splice intelligence (gRPC + GraphQL describe-a-sound + preview + collections + presets), 9-band spectral perception auto-loaded via ensure_analyzer_on_master, Creative Director skill, technique memory, 12 creative intelligence engines",
+  "description": "Agentic production system for Ableton Live 12 \u2014 453 tools, 54 domains, 44 semantic moves. Device atlas (5264 devices, 120 enriched, 7 indexes), Splice intelligence (gRPC + GraphQL describe-a-sound + preview + collections + presets), 9-band spectral perception auto-loaded via ensure_analyzer_on_master, Creative Director skill, technique memory, 12 creative intelligence engines",
   "author": "Pilot Studio",
   "license": "BSL-1.1",
   "type": "commonjs",

package/remote_script/LivePilot/__init__.py

@@ -5,7 +5,7 @@ Entry point for the ControlSurface. Ableton calls create_instance(c_instance)
 when this script is selected in Preferences > Link, Tempo & MIDI.
 """
 
-__version__ = "1.23.3"
+__version__ = "1.23.5"
 
 from _Framework.ControlSurface import ControlSurface
 from . import router

package/remote_script/LivePilot/browser.py

@@ -48,8 +48,13 @@ def _navigate_path(browser, path):
     if not parts:
         raise ValueError("Path cannot be empty")
 
-    # First part must be a category name
-    first = parts[0].lower()
+    # First part must be a category name (normalise common aliases first)
+    _path_aliases = {
+        "effects": "audio_effects", "fx": "audio_effects",
+        "audio_fx": "audio_effects", "audiofx": "audio_effects",
+        "midi_fx": "midi_effects", "midifx": "midi_effects",
+    }
+    first = _path_aliases.get(parts[0].lower(), parts[0].lower())
     if first not in categories:
         raise ValueError(
             "Unknown category '%s'. Available: %s"

package/remote_script/LivePilot/server.py

@@ -86,6 +86,12 @@ class LivePilotServer(object):
         self._command_queue = queue.Queue()
         self._client_lock = threading.Lock()
         self._client_connected = False
+        # Track the active client socket so we can close it from the accept
+        # loop when a new connection arrives. See _server_loop's kick-stale
+        # flow — without this, an unclean MCP-server restart leaves the
+        # Remote Script in a state where new connections get rejected until
+        # the old socket times out (often requiring an Ableton restart).
+        self._current_client = None
 
     # ── Public API ───────────────────────────────────────────────────────
 
@@ -138,30 +144,35 @@ class LivePilotServer(object):
         while self._running:
             try:
                 client, addr = self._server_socket.accept()
+                # Single-client design: a new connection means the previous one
+                # is dead. Close the stale socket and join its thread (outside
+                # the lock so the thread's finally block can acquire it), then
+                # accept the new connection. Without this, the server could
+                # reject reconnections for up to 1s after an unclean MCP-server
+                # restart — the old recv() loop hadn't yet observed EOF.
+                stale_thread = None
+                stale_client = None
+                with self._client_lock:
+                    if self._client_connected and self._current_client is not None:
+                        stale_client = self._current_client
+                        stale_thread = self._client_thread
+                        self._log(
+                            "Replacing stale client with new connection from %s:%d" % addr
+                        )
+                if stale_client is not None:
+                    try:
+                        stale_client.close()
+                    except OSError:
+                        pass
+                if stale_thread is not None and stale_thread.is_alive():
+                    # 2s is generous — the old recv() unblocks the moment we
+                    # close the socket above, then the thread's finally block
+                    # acquires the lock, resets _client_connected, and exits.
+                    stale_thread.join(timeout=2)
+
                 with self._client_lock:
-                    if self._client_connected:
-                        # Reject concurrent clients with an explicit message
-                        self._log("Rejected client from %s:%d (another client is connected)" % addr)
-                        try:
-                            reject = json.dumps({
-                                "id": "system",
-                                "ok": False,
-                                "error": {
-                                    "code": "STATE_ERROR",
-                                    "message": "Another client is already connected. "
-                                               "LivePilot accepts one client at a time. "
-                                               "Disconnect the current client first."
-                                }
-                            }) + "\n"
-                            client.sendall(reject.encode("utf-8"))
-                        except OSError:
-                            pass
-                        try:
-                            client.close()
-                        except OSError:
-                            pass
-                        continue
                     self._client_connected = True
+                    self._current_client = client
                     self._client_thread = threading.Thread(
                         target=self._run_client_session,
                         args=(client, addr),
@@ -194,6 +205,11 @@ class LivePilotServer(object):
                 pass
             with self._client_lock:
                 self._client_connected = False
+                # Only clear _current_client if it still points at us — the
+                # accept loop may have already replaced us with a new client
+                # (in which case _current_client is the new socket).
+                if self._current_client is client:
+                    self._current_client = None
             self._log("Client disconnected")
 
     def _handle_client(self, client):

package/remote_script/LivePilot/transport.py

@@ -11,16 +11,26 @@ def get_session_info(song, params):
     """Return comprehensive session state."""
     tracks_info = []
     for i, track in enumerate(song.tracks):
-        tracks_info.append({
+        track_data = {
             "index": i,
             "name": track.name,
             "color_index": track.color_index,
-            "has_midi_input": track.has_midi_input,
-            "has_audio_input": track.has_audio_input,
             "mute": track.mute,
             "solo": track.solo,
-            "arm": track.arm,
-        })
+        }
+        # Group tracks (and any Return tracks that leak into song.tracks)
+        # don't expose `arm` / `has_midi_input` / `has_audio_input`. The
+        # Live Object Model raises a RuntimeError on access — and crucially
+        # `hasattr()` returns True regardless, so we must use try/except.
+        try:
+            track_data["arm"] = track.arm
+            track_data["has_midi_input"] = track.has_midi_input
+            track_data["has_audio_input"] = track.has_audio_input
+        except Exception:
+            track_data["arm"] = None
+            track_data["has_midi_input"] = None
+            track_data["has_audio_input"] = None
+        tracks_info.append(track_data)
 
     return_tracks_info = []
     for i, track in enumerate(song.return_tracks):

package/requirements.txt

@@ -1,6 +1,6 @@
 # LivePilot MCP Server dependencies
-numpy>=1.24.0
-fastmcp>=3.0.0,<3.3.0  # pinned upper bound — _get_all_tools() accesses private internals
+numpy>=2.4.4
+fastmcp>=3.2.4,<3.3.0  # pinned upper bound — _get_all_tools() accesses private internals
 midiutil>=1.2.1
 pretty_midi>=0.2.11
 # v1.8 Perception Layer (offline analysis)
@@ -12,7 +12,7 @@ mutagen>=1.47.0
 # Without these, SpliceGRPCClient silently disables itself and search_samples
 # falls back to the SQLite sounds.db which only returns locally downloaded
 # samples (see docs/2026-04-14-bugs-discovered.md — P0-2).
-grpcio>=1.60.0
+grpcio>=1.80.0
 protobuf>=7.34.1
 
 # Development / testing (not required for runtime)

package/server.json

@@ -1,12 +1,12 @@
 {
   "$schema": "https://static.modelcontextprotocol.io/schemas/2025-12-11/server.schema.json",
   "name": "io.github.dreamrec/livepilot",
-  "description": "433-tool agentic MCP production system for Ableton Live 12 \u2014 53 domains, 44 semantic moves, device atlas (5264 devices), Splice intelligence (gRPC + GraphQL), 9-band spectral perception auto-loaded, Creative Director skill, technique memory, 12 creative engines",
+  "description": "453-tool agentic MCP production system for Ableton Live 12 \u2014 53 domains, 44 semantic moves, device atlas (5264 devices), Splice intelligence (gRPC + GraphQL), 9-band spectral perception auto-loaded, Creative Director skill, technique memory, 12 creative engines",
   "repository": {
     "url": "https://github.com/dreamrec/LivePilot",
     "source": "github"
   },
-  "version": "1.23.3",
+  "version": "1.23.5",
   "packages": [
     {
       "registryType": "npm",