livepilot 1.0.0

package/remote_script/LivePilot/server.py

@@ -0,0 +1,293 @@
+"""
+LivePilot - TCP server with thread-safe command queue.
+
+Runs a background daemon thread that accepts JSON-over-TCP connections.
+Commands are forwarded to Ableton's main thread via schedule_message,
+and responses are returned through per-command Queue objects.
+"""
+
+import socket
+import threading
+import json
+
+import queue
+
+from . import router
+
+# ── Commands that modify Live state (need settle delay) ──────────────────────
+
+WRITE_COMMANDS = frozenset([
+    # transport
+    "set_tempo", "set_time_signature", "start_playback", "stop_playback",
+    "continue_playback", "toggle_metronome", "set_session_loop", "undo", "redo",
+    # tracks
+    "create_midi_track", "create_audio_track", "create_return_track",
+    "delete_track", "duplicate_track", "set_track_name", "set_track_color",
+    "set_track_mute", "set_track_solo", "set_track_arm", "stop_track_clips",
+    "set_group_fold", "set_track_input_monitoring",
+    # clips
+    "create_clip", "delete_clip", "duplicate_clip", "fire_clip", "stop_clip",
+    "set_clip_name", "set_clip_color", "set_clip_loop", "set_clip_launch",
+    "set_clip_warp_mode",
+    # notes
+    "add_notes", "remove_notes", "remove_notes_by_id", "modify_notes",
+    "duplicate_notes", "transpose_notes", "quantize_clip",
+    # devices
+    "set_device_parameter", "batch_set_parameters", "toggle_device",
+    "delete_device", "load_device_by_uri", "find_and_load_device",
+    "set_chain_volume", "set_simpler_playback_mode",
+    # scenes
+    "create_scene", "delete_scene", "duplicate_scene", "fire_scene",
+    "set_scene_name", "set_scene_color", "set_scene_tempo",
+    # mixing
+    "set_track_volume", "set_track_pan", "set_track_send",
+    "set_master_volume", "set_track_routing",
+    # browser
+    "load_browser_item",
+    # arrangement
+    "jump_to_time", "jump_to_cue", "capture_midi", "start_recording",
+    "stop_recording", "toggle_cue_point", "back_to_arranger",
+    "create_arrangement_clip", "add_arrangement_notes",
+    "remove_arrangement_notes", "remove_arrangement_notes_by_id",
+    "modify_arrangement_notes", "duplicate_arrangement_notes",
+    "transpose_arrangement_notes", "set_arrangement_automation",
+    "set_arrangement_clip_name",
+])
+
+
+class LivePilotServer(object):
+    """TCP server that bridges JSON commands to Ableton's main thread.
+
+    Single-client by design: only one client can be connected at a time.
+    All commands must execute on Ableton's main thread (Live Object Model
+    is not thread-safe), so serialized client access prevents race conditions.
+    Additional connection attempts are rejected with a clear error message.
+    """
+
+    def __init__(self, control_surface, host="127.0.0.1", port=9878):
+        self._cs = control_surface
+        self._host = host
+        self._port = port
+        self._running = False
+        self._server_socket = None
+        self._thread = None
+        self._command_queue = queue.Queue()
+        self._client_lock = threading.Lock()
+        self._client_connected = False
+
+    # ── Public API ───────────────────────────────────────────────────────
+
+    def start(self):
+        """Start the background listener thread."""
+        self._running = True
+        self._thread = threading.Thread(target=self._server_loop)
+        self._thread.daemon = True
+        self._thread.start()
+        self._log("Server started on %s:%d" % (self._host, self._port))
+
+    def stop(self):
+        """Shutdown the server gracefully."""
+        self._running = False
+        if self._server_socket:
+            try:
+                self._server_socket.close()
+            except OSError:
+                pass
+        if self._thread and self._thread.is_alive():
+            self._thread.join(timeout=3)
+        self._log("Server stopped")
+
+    # ── Logging ──────────────────────────────────────────────────────────
+
+    def _log(self, message):
+        try:
+            self._cs.log_message("[LivePilot] " + str(message))
+        except Exception:
+            pass
+
+    # ── Background thread ────────────────────────────────────────────────
+
+    def _server_loop(self):
+        """Runs in a daemon thread.  Accepts one client at a time."""
+        try:
+            self._server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+            self._server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+            self._server_socket.bind((self._host, self._port))
+            self._server_socket.listen(2)
+            self._server_socket.settimeout(1.0)
+            self._log("Listening on %s:%d" % (self._host, self._port))
+        except OSError as exc:
+            self._log("Failed to bind: %s" % exc)
+            return
+
+        while self._running:
+            try:
+                client, addr = self._server_socket.accept()
+                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._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")
+            except socket.timeout:
+                continue
+            except OSError:
+                if self._running:
+                    self._log("Accept error")
+                break
+
+        try:
+            self._server_socket.close()
+        except OSError:
+            pass
+
+    def _handle_client(self, client):
+        """Read newline-delimited JSON from a connected client."""
+        client.settimeout(1.0)
+        buf = ""
+        while self._running:
+            try:
+                data = client.recv(4096)
+                if not data:
+                    break
+                buf += data.decode("utf-8", errors="replace")
+                while "\n" in buf:
+                    line, buf = buf.split("\n", 1)
+                    line = line.strip()
+                    if line:
+                        self._process_line(client, line)
+            except socket.timeout:
+                continue
+            except OSError as exc:
+                self._log("Recv error: %s" % exc)
+                break
+
+    def _process_line(self, client, line):
+        """Parse one JSON command, queue it for main thread, wait for result."""
+        try:
+            command = json.loads(line)
+        except (ValueError, TypeError) as exc:
+            resp = {
+                "id": "unknown",
+                "ok": False,
+                "error": {"code": "INVALID_PARAM", "message": "Bad JSON: %s" % exc},
+            }
+            self._send(client, resp)
+            return
+
+        request_id = command.get("id", "unknown")
+        cmd_type = command.get("type", "")
+
+        # Determine timeout based on read vs write
+        is_write = cmd_type in WRITE_COMMANDS
+        timeout = 15 if is_write else 10
+
+        # Per-command response queue
+        response_queue = queue.Queue()
+        self._command_queue.put((command, response_queue))
+
+        # Schedule processing on Ableton's main thread
+        try:
+            self._cs.schedule_message(0, self._process_next_command)
+        except AssertionError:
+            # Already on main thread — process directly
+            self._process_next_command()
+
+        # Wait for response from main thread
+        try:
+            resp = response_queue.get(timeout=timeout)
+        except queue.Empty:
+            resp = {
+                "id": request_id,
+                "ok": False,
+                "error": {"code": "TIMEOUT", "message": "Command timed out after %ds" % timeout},
+            }
+
+        self._send(client, resp)
+
+    # ── Main thread execution ────────────────────────────────────────────
+
+    def _process_next_command(self):
+        """Called on Ableton's main thread via schedule_message.
+        Processes one command from the queue."""
+        try:
+            command, response_queue = self._command_queue.get_nowait()
+        except queue.Empty:
+            return
+
+        cmd_type = command.get("type", "")
+        is_write = cmd_type in WRITE_COMMANDS
+
+        try:
+            song = self._cs.song()
+            result = router.dispatch(song, command)
+        except Exception as exc:
+            result = {
+                "id": command.get("id", "unknown"),
+                "ok": False,
+                "error": {"code": "INTERNAL", "message": str(exc)},
+            }
+
+        if is_write:
+            # Schedule response after 100ms settle delay for write operations
+            def send_response():
+                response_queue.put(result)
+                # Drain any remaining queued commands
+                self._drain_queue()
+            try:
+                self._cs.schedule_message(1, send_response)  # ~100ms
+            except AssertionError:
+                send_response()
+        else:
+            response_queue.put(result)
+            # Drain any remaining queued commands
+            self._drain_queue()
+
+    def _drain_queue(self):
+        """Process any remaining commands in the queue."""
+        if not self._command_queue.empty():
+            try:
+                self._cs.schedule_message(0, self._process_next_command)
+            except AssertionError:
+                self._process_next_command()
+
+    # ── Socket I/O ───────────────────────────────────────────────────────
+
+    def _send(self, client, response):
+        """Send a JSON response to the client."""
+        from .utils import serialize_json
+        try:
+            client.sendall(serialize_json(response).encode("utf-8"))
+        except OSError as exc:
+            self._log("Send error: %s" % exc)

package/remote_script/LivePilot/tracks.py

@@ -0,0 +1,268 @@
+"""
+LivePilot - Track domain handlers (14 commands).
+"""
+
+from .router import register
+from .utils import get_track
+
+
+@register("get_track_info")
+def get_track_info(song, params):
+    """Return detailed info for a single track."""
+    track_index = int(params["track_index"])
+    track = get_track(song, track_index)
+
+    # Clip slots
+    clips = []
+    for i, slot in enumerate(track.clip_slots):
+        clip_info = {
+            "index": i,
+            "has_clip": slot.has_clip,
+        }
+        if slot.has_clip and slot.clip:
+            clip = slot.clip
+            clip_info.update({
+                "name": clip.name,
+                "color_index": clip.color_index,
+                "length": clip.length,
+                "is_playing": clip.is_playing,
+                "is_recording": clip.is_recording,
+                "looping": clip.looping,
+                "loop_start": clip.loop_start,
+                "loop_end": clip.loop_end,
+                "start_marker": clip.start_marker,
+                "end_marker": clip.end_marker,
+            })
+        clips.append(clip_info)
+
+    # Devices
+    devices = []
+    for i, device in enumerate(track.devices):
+        dev_info = {
+            "index": i,
+            "name": device.name,
+            "class_name": device.class_name,
+            "is_active": device.is_active,
+        }
+        dev_params = []
+        for j, param in enumerate(device.parameters):
+            dev_params.append({
+                "index": j,
+                "name": param.name,
+                "value": param.value,
+                "min": param.min,
+                "max": param.max,
+                "is_quantized": param.is_quantized,
+            })
+        dev_info["parameters"] = dev_params
+        devices.append(dev_info)
+
+    # Mixer info
+    mixer = {
+        "volume": track.mixer_device.volume.value,
+        "panning": track.mixer_device.panning.value,
+    }
+
+    # Sends
+    sends = []
+    for i, send in enumerate(track.mixer_device.sends):
+        sends.append({
+            "index": i,
+            "name": send.name,
+            "value": send.value,
+            "min": send.min,
+            "max": send.max,
+        })
+
+    result = {
+        "index": track_index,
+        "name": track.name,
+        "color_index": track.color_index,
+        "mute": track.mute,
+        "solo": track.solo,
+        "is_foldable": track.is_foldable,
+        "is_grouped": track.is_grouped,
+        "clip_slots": clips,
+        "devices": devices,
+        "mixer": mixer,
+        "sends": sends,
+    }
+
+    if track.is_foldable:
+        result["fold_state"] = bool(track.fold_state)
+
+    # Regular tracks have arm and input type; return tracks get null values
+    if track_index >= 0:
+        result["arm"] = track.arm
+        result["has_midi_input"] = track.has_midi_input
+        result["has_audio_input"] = track.has_audio_input
+        result["current_monitoring_state"] = track.current_monitoring_state
+    else:
+        result["arm"] = None
+        result["has_midi_input"] = None
+        result["has_audio_input"] = None
+        result["is_return_track"] = True
+
+    return result
+
+
+@register("create_midi_track")
+def create_midi_track(song, params):
+    """Create a new MIDI track at the given index."""
+    index = int(params.get("index", -1))
+    song.create_midi_track(index)
+    # The new track is at the requested index (or end if -1)
+    if index == -1:
+        new_index = len(list(song.tracks)) - 1
+    else:
+        new_index = index
+    track = list(song.tracks)[new_index]
+    if "name" in params:
+        track.name = str(params["name"])
+    if "color_index" in params:
+        track.color_index = int(params["color_index"])
+    return {"index": new_index, "name": track.name}
+
+
+@register("create_audio_track")
+def create_audio_track(song, params):
+    """Create a new audio track at the given index."""
+    index = int(params.get("index", -1))
+    song.create_audio_track(index)
+    if index == -1:
+        new_index = len(list(song.tracks)) - 1
+    else:
+        new_index = index
+    track = list(song.tracks)[new_index]
+    if "name" in params:
+        track.name = str(params["name"])
+    if "color_index" in params:
+        track.color_index = int(params["color_index"])
+    return {"index": new_index, "name": track.name}
+
+
+@register("create_return_track")
+def create_return_track(song, params):
+    """Create a new return track."""
+    song.create_return_track()
+    return_tracks = list(song.return_tracks)
+    new_index = len(return_tracks) - 1
+    return {"index": new_index, "name": return_tracks[new_index].name}
+
+
+@register("delete_track")
+def delete_track(song, params):
+    """Delete a track by index."""
+    track_index = int(params["track_index"])
+    tracks = list(song.tracks)
+    if track_index < 0 or track_index >= len(tracks):
+        raise IndexError(
+            "Track index %d out of range (0..%d)"
+            % (track_index, len(tracks) - 1)
+        )
+    song.delete_track(track_index)
+    return {"deleted": track_index}
+
+
+@register("duplicate_track")
+def duplicate_track(song, params):
+    """Duplicate a track by index."""
+    track_index = int(params["track_index"])
+    tracks = list(song.tracks)
+    if track_index < 0 or track_index >= len(tracks):
+        raise IndexError(
+            "Track index %d out of range (0..%d)"
+            % (track_index, len(tracks) - 1)
+        )
+    song.duplicate_track(track_index)
+    new_index = track_index + 1
+    return {"index": new_index, "name": list(song.tracks)[new_index].name}
+
+
+@register("set_track_name")
+def set_track_name(song, params):
+    """Rename a track."""
+    track_index = int(params["track_index"])
+    track = get_track(song, track_index)
+    track.name = str(params["name"])
+    return {"index": track_index, "name": track.name}
+
+
+@register("set_track_color")
+def set_track_color(song, params):
+    """Set a track's color."""
+    track_index = int(params["track_index"])
+    track = get_track(song, track_index)
+    track.color_index = int(params["color_index"])
+    return {"index": track_index, "color_index": track.color_index}
+
+
+@register("set_track_mute")
+def set_track_mute(song, params):
+    """Mute or unmute a track."""
+    track_index = int(params["track_index"])
+    track = get_track(song, track_index)
+    track.mute = bool(params["mute"])
+    return {"index": track_index, "mute": track.mute}
+
+
+@register("set_track_solo")
+def set_track_solo(song, params):
+    """Solo or unsolo a track."""
+    track_index = int(params["track_index"])
+    track = get_track(song, track_index)
+    track.solo = bool(params["solo"])
+    return {"index": track_index, "solo": track.solo}
+
+
+@register("set_track_arm")
+def set_track_arm(song, params):
+    """Arm or disarm a track for recording."""
+    track_index = int(params["track_index"])
+    if track_index < 0:
+        raise ValueError("Cannot arm a return track")
+    track = get_track(song, track_index)
+    track.arm = bool(params["arm"])
+    return {"index": track_index, "arm": track.arm}
+
+
+@register("stop_track_clips")
+def stop_track_clips(song, params):
+    """Stop all clips on a track."""
+    track_index = int(params["track_index"])
+    track = get_track(song, track_index)
+    track.stop_all_clips()
+    return {"index": track_index, "stopped": True}
+
+
+@register("set_group_fold")
+def set_group_fold(song, params):
+    """Fold or unfold a group track."""
+    track_index = int(params["track_index"])
+    track = get_track(song, track_index)
+    if not track.is_foldable:
+        raise ValueError("Track %d is not a group track" % track_index)
+    track.fold_state = int(bool(params["folded"]))
+    return {
+        "index": track_index,
+        "folded": bool(track.fold_state),
+    }
+
+
+@register("set_track_input_monitoring")
+def set_track_input_monitoring(song, params):
+    """Set input monitoring state for a track (0=In, 1=Auto, 2=Off)."""
+    track_index = int(params["track_index"])
+    if track_index < 0:
+        raise ValueError("Cannot set input monitoring on a return track")
+    track = get_track(song, track_index)
+    state = int(params["state"])
+    if state not in (0, 1, 2):
+        raise ValueError(
+            "Invalid monitoring state %d. Valid: 0=In, 1=Auto, 2=Off" % state
+        )
+    track.current_monitoring_state = state
+    return {
+        "index": track_index,
+        "monitoring_state": track.current_monitoring_state,
+    }