livepilot 1.1.0

package/remote_script/LivePilot/server.py

@@ -0,0 +1,286 @@
+"""
+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",
+    # clips
+    "create_clip", "delete_clip", "duplicate_clip", "fire_clip", "stop_clip",
+    "set_clip_name", "set_clip_color", "set_clip_loop", "set_clip_launch",
+    # 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",
+    # 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",
+])
+
+
+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 Exception:
+                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 Exception 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 Exception:
+                            pass
+                        try:
+                            client.close()
+                        except Exception:
+                            pass
+                        continue
+                    self._client_connected = True
+                self._log("Client connected from %s:%d" % addr)
+                try:
+                    self._handle_client(client)
+                except Exception as exc:
+                    self._log("Client error: %s" % exc)
+                finally:
+                    with self._client_lock:
+                        self._client_connected = False
+                    try:
+                        client.close()
+                    except Exception:
+                        pass
+                    self._log("Client disconnected")
+            except socket.timeout:
+                continue
+            except Exception:
+                if self._running:
+                    self._log("Accept error")
+                break
+
+        try:
+            self._server_socket.close()
+        except Exception:
+            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 Exception 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 Exception 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 Exception as exc:
+            self._log("Send error: %s" % exc)

package/remote_script/LivePilot/tracks.py

@@ -0,0 +1,229 @@
+"""
+LivePilot - Track domain handlers (12 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,
+        "clip_slots": clips,
+        "devices": devices,
+        "mixer": mixer,
+        "sends": sends,
+    }
+
+    # 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
+    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}

package/remote_script/LivePilot/transport.py

@@ -0,0 +1,147 @@
+"""
+LivePilot - Transport domain handlers (10 commands).
+"""
+
+from .router import register
+
+
+@register("get_session_info")
+def get_session_info(song, params):
+    """Return comprehensive session state."""
+    tracks_info = []
+    for i, track in enumerate(song.tracks):
+        tracks_info.append({
+            "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,
+        })
+
+    return_tracks_info = []
+    for i, track in enumerate(song.return_tracks):
+        return_tracks_info.append({
+            "index": i,
+            "name": track.name,
+            "color_index": track.color_index,
+            "mute": track.mute,
+            "solo": track.solo,
+        })
+
+    scenes_info = []
+    for i, scene in enumerate(song.scenes):
+        scenes_info.append({
+            "index": i,
+            "name": scene.name,
+            "color_index": scene.color_index,
+            "tempo": scene.tempo if scene.tempo > 0 else None,
+        })
+
+    return {
+        "tempo": song.tempo,
+        "signature_numerator": song.signature_numerator,
+        "signature_denominator": song.signature_denominator,
+        "is_playing": song.is_playing,
+        "song_length": song.song_length,
+        "current_song_time": song.current_song_time,
+        "loop": song.loop,
+        "loop_start": song.loop_start,
+        "loop_length": song.loop_length,
+        "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)),
+        "tracks": tracks_info,
+        "return_tracks": return_tracks_info,
+        "scenes": scenes_info,
+    }
+
+
+@register("set_tempo")
+def set_tempo(song, params):
+    """Set the song tempo in BPM."""
+    tempo = float(params["tempo"])
+    if tempo < 20 or tempo > 999:
+        raise ValueError("Tempo must be between 20 and 999 BPM")
+    song.tempo = tempo
+    return {"tempo": song.tempo}
+
+
+@register("set_time_signature")
+def set_time_signature(song, params):
+    """Set the song time signature."""
+    numerator = int(params["numerator"])
+    denominator = int(params["denominator"])
+    if numerator < 1 or numerator > 99:
+        raise ValueError("Numerator must be between 1 and 99")
+    if denominator not in (1, 2, 4, 8, 16):
+        raise ValueError("Denominator must be 1, 2, 4, 8, or 16")
+    song.signature_numerator = numerator
+    song.signature_denominator = denominator
+    return {
+        "signature_numerator": song.signature_numerator,
+        "signature_denominator": song.signature_denominator,
+    }
+
+
+@register("start_playback")
+def start_playback(song, params):
+    """Start playback from the beginning."""
+    song.start_playing()
+    return {"is_playing": True}
+
+
+@register("stop_playback")
+def stop_playback(song, params):
+    """Stop playback."""
+    song.stop_playing()
+    return {"is_playing": False}
+
+
+@register("continue_playback")
+def continue_playback(song, params):
+    """Continue playback from the current position."""
+    song.continue_playing()
+    return {"is_playing": True}
+
+
+@register("toggle_metronome")
+def toggle_metronome(song, params):
+    """Enable or disable the metronome."""
+    enabled = bool(params["enabled"])
+    song.metronome = enabled
+    return {"metronome": song.metronome}
+
+
+@register("set_session_loop")
+def set_session_loop(song, params):
+    """Enable/disable loop and optionally set loop start/length."""
+    song.loop = bool(params["enabled"])
+    if "loop_start" in params:
+        song.loop_start = float(params["loop_start"])
+    if "loop_length" in params:
+        song.loop_length = float(params["loop_length"])
+    return {
+        "loop": song.loop,
+        "loop_start": song.loop_start,
+        "loop_length": song.loop_length,
+    }
+
+
+@register("undo")
+def undo(song, params):
+    """Undo the last action."""
+    song.undo()
+    return {"undone": True}
+
+
+@register("redo")
+def redo(song, params):
+    """Redo the last undone action."""
+    song.redo()
+    return {"redone": True}