laive-mcp 0.1.0

package/packages/live-bridge-remote-script/python/laive/fake_live.py

@@ -0,0 +1,168 @@
+from __future__ import absolute_import, print_function, unicode_literals
+
+
+class ListenerMixin(object):
+    def __init__(self):
+        self._listeners = {}
+
+    def _add_listener(self, name, callback):
+        self._listeners.setdefault(name, []).append(callback)
+
+    def _remove_listener(self, name, callback):
+        self._listeners[name] = [item for item in self._listeners.get(name, []) if item != callback]
+
+    def _notify(self, name):
+        for callback in list(self._listeners.get(name, [])):
+            callback()
+
+    def __getattr__(self, item):
+        if item.startswith("add_") and item.endswith("_listener"):
+            name = item[4:-9]
+            return lambda callback: self._add_listener(name, callback)
+        if item.startswith("remove_") and item.endswith("_listener"):
+            name = item[7:-9]
+            return lambda callback: self._remove_listener(name, callback)
+        raise AttributeError(item)
+
+
+class FakeParameter(object):
+    def __init__(self, name, value, minimum=0.0, maximum=1.0):
+        self.name = name
+        self._value = value
+        self.min = minimum
+        self.max = maximum
+        self.display_value = str(value)
+
+    @property
+    def value(self):
+        return self._value
+
+    @value.setter
+    def value(self, next_value):
+        self._value = next_value
+        self.display_value = str(next_value)
+
+
+class FakeDevice(object):
+    def __init__(self, name, parameters):
+        self.name = name
+        self.class_name = name
+        self.parameters = parameters
+
+
+class FakeClip(object):
+    def __init__(self, name="Clip 1", length=4):
+        self.name = name
+        self.length = length
+        self.is_playing = False
+        self.notes = []
+
+    def add_new_notes(self, notes):
+        self.notes.extend(notes)
+
+
+class FakeClipSlot(object):
+    def __init__(self):
+        self.clip = None
+
+    @property
+    def has_clip(self):
+        return self.clip is not None
+
+    def create_clip(self, length):
+        self.clip = FakeClip(length=length)
+
+    def preview_clip(self, length_beats, name=None):
+        preview = FakeClip(name=name or "Preview Clip", length=length_beats)
+        return preview
+
+
+class FakeTrack(object):
+    def __init__(self, name):
+        self.name = name
+        self.type = "midi"
+        self.arm = False
+        self.mute = False
+        self.solo = False
+        self.clip_slots = [FakeClipSlot() for _ in range(4)]
+        self.devices = [FakeDevice("Instrument", [FakeParameter("Macro 1", 0.5)])]
+
+
+class FakeScene(object):
+    def __init__(self, name):
+        self.name = name
+
+
+class FakeSong(ListenerMixin):
+    def __init__(self):
+        super(FakeSong, self).__init__()
+        self.name = "Fake Set"
+        self.live_version = "12.1.10"
+        self.signature_numerator = 4
+        self.signature_denominator = 4
+        self._tempo = 124.0
+        self._is_playing = False
+        self.is_recording = False
+        self.metronome = False
+        self.tracks = [FakeTrack("Drums"), FakeTrack("Bass")]
+        self.scenes = [FakeScene("Intro"), FakeScene("Drop")]
+
+    @property
+    def tempo(self):
+        return self._tempo
+
+    @tempo.setter
+    def tempo(self, next_value):
+        self._tempo = next_value
+        self._notify("tempo")
+
+    @property
+    def is_playing(self):
+        return self._is_playing
+
+    @is_playing.setter
+    def is_playing(self, next_value):
+        self._is_playing = bool(next_value)
+        self._notify("is_playing")
+
+    def start_playing(self):
+        self.is_playing = True
+
+    def stop_playing(self):
+        self.is_playing = False
+
+    def create_midi_track(self, index):
+        self.tracks.insert(index, FakeTrack("Track {0}".format(index + 1)))
+        self._notify("tracks")
+
+    def create_scene(self, index):
+        self.scenes.insert(index, FakeScene("Scene {0}".format(index + 1)))
+        self._notify("scenes")
+
+    def preview_track(self, index, name=None):
+        track = FakeTrack(name or "Track {0}".format(index + 1))
+        return track
+
+    def preview_scene(self, index, name=None):
+        return FakeScene(name or "Scene {0}".format(index + 1))
+
+
+class FakeCInstance(object):
+    def __init__(self, song=None):
+        self._song = song or FakeSong()
+        self.scheduled = []
+        self.logged = []
+        self.messages = []
+
+    def song(self):
+        return self._song
+
+    def schedule_message(self, _delay, callback):
+        self.scheduled.append(callback)
+        callback()
+
+    def log_message(self, message):
+        self.logged.append(message)
+
+    def show_message(self, message):
+        self.messages.append(message)

package/packages/live-bridge-remote-script/python/laive/listeners.py

@@ -0,0 +1,46 @@
+from __future__ import absolute_import, print_function, unicode_literals
+
+
+def _safe_call(logger, message):
+    if logger:
+        logger(message)
+
+
+class ListenerHub(object):
+    def __init__(self, live_access, event_sink, logger=None):
+        self._live_access = live_access
+        self._song = live_access.song
+        self._event_sink = event_sink
+        self._logger = logger
+        self._detach_steps = []
+
+    def attach(self):
+        self._attach_listener(self._song, "tempo", self._emit_transport_changed)
+        self._attach_listener(self._song, "is_playing", self._emit_transport_changed)
+        self._attach_listener(self._song, "tracks", self._emit_tracks_changed)
+        self._attach_listener(self._song, "scenes", self._emit_scenes_changed)
+
+    def detach(self):
+        while self._detach_steps:
+            callback = self._detach_steps.pop()
+            try:
+                callback()
+            except Exception as error:  # pragma: no cover - defensive cleanup
+                _safe_call(self._logger, "Listener detach failed: {0}".format(error))
+
+    def _attach_listener(self, subject, name, callback):
+        add_method = getattr(subject, "add_{0}_listener".format(name), None)
+        remove_method = getattr(subject, "remove_{0}_listener".format(name), None)
+        if not add_method or not remove_method:
+            return
+        add_method(callback)
+        self._detach_steps.append(lambda: remove_method(callback))
+
+    def _emit_transport_changed(self):
+        self._event_sink("transport.changed", self._live_access.get_song_state())
+
+    def _emit_tracks_changed(self):
+        self._event_sink("tracks.changed", {"tracks": self._live_access.get_tracks()})
+
+    def _emit_scenes_changed(self):
+        self._event_sink("state.changed", {"scenes": self._live_access.get_scenes()})

package/packages/live-bridge-remote-script/python/laive/live_access.py

@@ -0,0 +1,272 @@
+from __future__ import absolute_import, print_function, unicode_literals
+
+from .protocol import RequestError
+
+
+def _track_id(index):
+    return "track:{0}".format(index + 1)
+
+
+def _scene_id(index):
+    return "scene:{0}".format(index + 1)
+
+
+def _clip_id(track_id, slot_index):
+    return "clip:session:{0}:slot:{1}".format(track_id, slot_index + 1)
+
+
+def _device_id(track_id, device_index):
+    return "device:{0}:{1}".format(track_id, device_index + 1)
+
+
+def _parameter_id(device_id, parameter_index):
+    return "parameter:{0}:{1}".format(device_id, parameter_index + 1)
+
+
+class LiveSetAdapter(object):
+    def __init__(self, song):
+        self.song = song
+
+    @property
+    def live_version(self):
+        return getattr(self.song, "live_version", "unknown")
+
+    def capabilities(self):
+        return {
+            "read_state": True,
+            "set_transport": True,
+            "create_track": hasattr(self.song, "create_midi_track"),
+            "create_scene": hasattr(self.song, "create_scene"),
+            "create_clip": True,
+            "insert_notes": True,
+            "set_parameter": True,
+            "subscribe": True,
+        }
+
+    def get_song_state(self):
+        return {
+            "id": "song:current",
+            "name": getattr(self.song, "name", "Untitled Set"),
+            "tempo": getattr(self.song, "tempo", None),
+            "time_signature_numerator": getattr(self.song, "signature_numerator", None),
+            "time_signature_denominator": getattr(self.song, "signature_denominator", None),
+            "is_playing": bool(getattr(self.song, "is_playing", False)),
+            "is_recording": bool(getattr(self.song, "is_recording", False)),
+            "metronome": bool(getattr(self.song, "metronome", False)),
+        }
+
+    def get_tracks(self):
+        return [self._serialize_track(track, index) for index, track in enumerate(getattr(self.song, "tracks", []))]
+
+    def get_scenes(self):
+        return [self._serialize_scene(scene, index) for index, scene in enumerate(getattr(self.song, "scenes", []))]
+
+    def get_track(self, track_id):
+        track, index = self._find_track(track_id)
+        return self._serialize_track(track, index)
+
+    def get_clip(self, clip_id):
+        clip, track_id, slot_index = self._find_clip(clip_id)
+        return self._serialize_clip(clip, track_id, slot_index)
+
+    def get_device(self, device_id):
+        device, track_id, device_index = self._find_device(device_id)
+        return self._serialize_device(device, track_id, device_index)
+
+    def get_parameter(self, parameter_id):
+        parameter, device_id, parameter_index = self._find_parameter(parameter_id)
+        return self._serialize_parameter(parameter, device_id, parameter_index)
+
+    def set_tempo(self, value, dry_run=False):
+        tempo = float(value)
+        if tempo <= 0:
+            raise RequestError("invalid_argument", "tempo must be positive")
+        if not dry_run:
+            self.song.tempo = tempo
+        return {"target": "song.tempo", "applied": not dry_run, "value": tempo}
+
+    def set_parameter(self, parameter_id, value, dry_run=False):
+        parameter, device_id, parameter_index = self._find_parameter(parameter_id)
+        next_value = float(value)
+        if not dry_run:
+            parameter.value = next_value
+        return {
+            "target": parameter_id,
+            "applied": not dry_run,
+            "parameter": self._serialize_parameter(parameter, device_id, parameter_index),
+        }
+
+    def play(self, dry_run=False):
+        if not dry_run:
+            self.song.start_playing()
+        return {"target": "transport.play", "applied": not dry_run, "is_playing": True}
+
+    def stop(self, dry_run=False):
+        if not dry_run:
+            self.song.stop_playing()
+        return {"target": "transport.stop", "applied": not dry_run, "is_playing": False}
+
+    def create_track(self, kind="midi", name=None, dry_run=False):
+        if kind != "midi":
+            raise RequestError("unsupported_argument", "Only midi tracks are supported in the first pass")
+        index = len(getattr(self.song, "tracks", []))
+        if dry_run:
+            track = self.song.preview_track(index=index, name=name)
+        else:
+            self.song.create_midi_track(index)
+            track = self.song.tracks[index]
+            if name:
+                track.name = name
+        return {"applied": not dry_run, "track": self._serialize_track(track, index)}
+
+    def create_scene(self, name=None, dry_run=False):
+        index = len(getattr(self.song, "scenes", []))
+        if dry_run:
+            scene = self.song.preview_scene(index=index, name=name)
+        else:
+            self.song.create_scene(index)
+            scene = self.song.scenes[index]
+            if name:
+                scene.name = name
+        return {"applied": not dry_run, "scene": self._serialize_scene(scene, index)}
+
+    def create_clip(self, track_id, slot_index, length_beats=4, name=None, dry_run=False):
+        track, _track_index = self._find_track(track_id)
+        slot = self._find_clip_slot(track, slot_index)
+        if dry_run:
+            clip = slot.preview_clip(length_beats=length_beats, name=name)
+        else:
+            slot.create_clip(length_beats)
+            clip = slot.clip
+            if name:
+                clip.name = name
+        return {"applied": not dry_run, "clip": self._serialize_clip(clip, track_id, slot_index)}
+
+    def insert_notes(self, clip_id, notes, dry_run=False):
+        clip, track_id, slot_index = self._find_clip(clip_id)
+        if not dry_run:
+            if hasattr(clip, "add_new_notes"):
+                clip.add_new_notes(notes)
+            elif hasattr(clip, "set_notes"):
+                clip.set_notes(tuple(self._tuple_note(note) for note in notes))
+            else:
+                clip.notes.extend(notes)
+        note_count = len(notes)
+        clip_state = self._serialize_clip(clip, track_id, slot_index)
+        clip_state["note_count"] = len(getattr(clip, "notes", [])) if not dry_run else note_count
+        return {"applied": not dry_run, "clip": clip_state, "note_count": note_count}
+
+    def _serialize_track(self, track, index):
+        track_id = getattr(track, "id", None) or _track_id(index)
+        clip_slots = getattr(track, "clip_slots", [])
+        devices = getattr(track, "devices", [])
+        return {
+            "id": track_id,
+            "index": index,
+            "name": getattr(track, "name", "Track {0}".format(index + 1)),
+            "type": getattr(track, "type", "midi"),
+            "arm": bool(getattr(track, "arm", False)),
+            "mute": bool(getattr(track, "mute", False)),
+            "solo": bool(getattr(track, "solo", False)),
+            "session_clips": [
+                self._serialize_clip(slot.clip, track_id, slot_index)
+                for slot_index, slot in enumerate(clip_slots)
+                if getattr(slot, "has_clip", False)
+            ],
+            "devices": [self._serialize_device(device, track_id, device_index) for device_index, device in enumerate(devices)],
+        }
+
+    def _serialize_scene(self, scene, index):
+        return {
+            "id": getattr(scene, "id", None) or _scene_id(index),
+            "index": index,
+            "name": getattr(scene, "name", "Scene {0}".format(index + 1)),
+        }
+
+    def _serialize_clip(self, clip, track_id, slot_index):
+        return {
+            "id": getattr(clip, "id", None) or _clip_id(track_id, slot_index),
+            "slot_index": slot_index,
+            "name": getattr(clip, "name", "Clip {0}".format(slot_index + 1)),
+            "length_beats": getattr(clip, "length", None),
+            "is_playing": bool(getattr(clip, "is_playing", False)),
+            "notes": list(getattr(clip, "notes", [])),
+        }
+
+    def _serialize_device(self, device, track_id, device_index):
+        device_id = getattr(device, "id", None) or _device_id(track_id, device_index)
+        return {
+            "id": device_id,
+            "name": getattr(device, "name", "Device {0}".format(device_index + 1)),
+            "class_name": getattr(device, "class_name", "Device"),
+            "parameters": [
+                self._serialize_parameter(parameter, device_id, parameter_index)
+                for parameter_index, parameter in enumerate(getattr(device, "parameters", []))
+            ],
+        }
+
+    def _serialize_parameter(self, parameter, device_id, parameter_index):
+        return {
+            "id": getattr(parameter, "id", None) or _parameter_id(device_id, parameter_index),
+            "name": getattr(parameter, "name", "Parameter {0}".format(parameter_index + 1)),
+            "value": getattr(parameter, "value", None),
+            "min": getattr(parameter, "min", 0.0),
+            "max": getattr(parameter, "max", 1.0),
+            "display_value": getattr(parameter, "display_value", str(getattr(parameter, "value", ""))),
+        }
+
+    def _find_track(self, track_id):
+        for index, track in enumerate(getattr(self.song, "tracks", [])):
+            candidate = getattr(track, "id", None) or _track_id(index)
+            if candidate == track_id:
+                return track, index
+        raise RequestError("not_found", "Track not found: {0}".format(track_id))
+
+    def _find_clip_slot(self, track, slot_index):
+        if slot_index is None:
+            raise RequestError("invalid_argument", "slot_index is required")
+        clip_slots = getattr(track, "clip_slots", [])
+        if slot_index < 0 or slot_index >= len(clip_slots):
+            raise RequestError("not_found", "Clip slot not found: {0}".format(slot_index))
+        return clip_slots[slot_index]
+
+    def _find_clip(self, clip_id):
+        for track_index, track in enumerate(getattr(self.song, "tracks", [])):
+            track_id = getattr(track, "id", None) or _track_id(track_index)
+            for slot_index, slot in enumerate(getattr(track, "clip_slots", [])):
+                if not getattr(slot, "has_clip", False):
+                    continue
+                current_clip = slot.clip
+                candidate = getattr(current_clip, "id", None) or _clip_id(track_id, slot_index)
+                if candidate == clip_id:
+                    return current_clip, track_id, slot_index
+        raise RequestError("not_found", "Clip not found: {0}".format(clip_id))
+
+    def _find_device(self, device_id):
+        for track_index, track in enumerate(getattr(self.song, "tracks", [])):
+            track_id = getattr(track, "id", None) or _track_id(track_index)
+            for device_index, device in enumerate(getattr(track, "devices", [])):
+                candidate = getattr(device, "id", None) or _device_id(track_id, device_index)
+                if candidate == device_id:
+                    return device, track_id, device_index
+        raise RequestError("not_found", "Device not found: {0}".format(device_id))
+
+    def _find_parameter(self, parameter_id):
+        for track_index, track in enumerate(getattr(self.song, "tracks", [])):
+            track_id = getattr(track, "id", None) or _track_id(track_index)
+            for device_index, device in enumerate(getattr(track, "devices", [])):
+                device_id = getattr(device, "id", None) or _device_id(track_id, device_index)
+                for parameter_index, parameter in enumerate(getattr(device, "parameters", [])):
+                    candidate = getattr(parameter, "id", None) or _parameter_id(device_id, parameter_index)
+                    if candidate == parameter_id:
+                        return parameter, device_id, parameter_index
+        raise RequestError("not_found", "Parameter not found: {0}".format(parameter_id))
+
+    def _tuple_note(self, note):
+        return (
+            note.get("pitch", 60),
+            note.get("start_beats", 0.0),
+            note.get("duration_beats", 0.25),
+            note.get("velocity", 100),
+            bool(note.get("mute", False)),
+        )

package/packages/live-bridge-remote-script/python/laive/protocol.py

@@ -0,0 +1,87 @@
+from __future__ import absolute_import, print_function, unicode_literals
+
+import json
+import uuid
+from datetime import datetime, timezone
+
+
+PROTOCOL_VERSION = "0.1.0"
+
+
+class RequestError(Exception):
+    def __init__(self, code, message):
+        super(RequestError, self).__init__(message)
+        self.code = code
+
+
+def create_request(operation, target=None, arguments=None, dry_run=False, client_id="laive-client", request_id=None):
+    return {
+        "type": "request",
+        "request_id": request_id or str(uuid.uuid4()),
+        "timestamp": iso_now(),
+        "client_id": client_id,
+        "operation": operation,
+        "target": target,
+        "arguments": arguments or {},
+        "dry_run": bool(dry_run),
+    }
+
+
+def make_response(request_id, ok=True, result=None, error_code=None, error_message=None, live_version=None):
+    return {
+        "type": "response",
+        "request_id": request_id,
+        "timestamp": iso_now(),
+        "ok": bool(ok),
+        "result": result,
+        "error_code": error_code,
+        "error_message": error_message,
+        "bridge_version": PROTOCOL_VERSION,
+        "live_version": live_version,
+    }
+
+
+def make_error_response(request_id, error_code, error_message, live_version=None):
+    return make_response(
+        request_id=request_id,
+        ok=False,
+        result=None,
+        error_code=error_code,
+        error_message=error_message,
+        live_version=live_version,
+    )
+
+
+def make_event(topic, payload=None):
+    return {
+        "type": "event",
+        "topic": topic,
+        "payload": payload or {},
+        "timestamp": iso_now(),
+    }
+
+
+def encode_json_line(payload):
+    return json.dumps(payload, separators=(",", ":")) + "\n"
+
+
+class JsonLineParser(object):
+    def __init__(self):
+        self._buffer = ""
+
+    def push(self, chunk):
+        if isinstance(chunk, bytes):
+            chunk = chunk.decode("utf-8")
+        self._buffer += chunk
+        messages = []
+        while "\n" in self._buffer:
+            line, self._buffer = self._buffer.split("\n", 1)
+            line = line.strip()
+            if not line:
+                continue
+            messages.append(json.loads(line))
+        return messages
+
+
+def iso_now():
+    return datetime.now(timezone.utc).replace(microsecond=0).isoformat().replace("+00:00", "Z")