pulse5ctl 1.3.0__py3-none-any.whl

pulse5/ble.py

@@ -0,0 +1,142 @@
+from __future__ import annotations
+
+import asyncio
+import platform
+from contextlib import asynccontextmanager
+from dataclasses import dataclass
+from typing import AsyncIterator, Callable
+
+from bleak import BleakClient, BleakScanner
+from bleak.backends.device import BLEDevice
+from bleak.backends.scanner import AdvertisementData
+
+from pulse5.protocol.constants import PulseConstants as C
+
+
+@dataclass
+class DiscoveredDevice:
+    address: str
+    name: str
+    rssi: int
+
+
+async def _find_connected_peripherals(scanner: BleakScanner) -> list[DiscoveredDevice]:
+    if platform.system() != "Darwin":
+        return []
+    try:
+        import CoreBluetooth
+
+        cbmgr = scanner._backend._manager
+        service = CoreBluetooth.CBUUID.UUIDWithString_(C.SERVICE_UUID)
+        peripherals = cbmgr.central_manager.retrieveConnectedPeripheralsWithServices_(
+            [service]
+        )
+        results = []
+        for p in peripherals:
+            name = str(p.name()) if p.name() else "JBL Pulse 5"
+            uuid = str(p.identifier())
+            results.append(DiscoveredDevice(address=uuid, name=name, rssi=0))
+        return results
+    except Exception:
+        return []
+
+
+async def scan(timeout: float = 5.0) -> list[DiscoveredDevice]:
+    devices: dict[str, DiscoveredDevice] = {}
+
+    def callback(device: BLEDevice, adv: AdvertisementData) -> None:
+        name = adv.local_name or device.name or ""
+        has_service = C.SERVICE_UUID.lower() in [s.lower() for s in (adv.service_uuids or [])]
+        is_jbl = has_service or name.startswith(C.DEVICE_NAME_PREFIX)
+        if is_jbl:
+            devices[device.address] = DiscoveredDevice(
+                address=device.address,
+                name=name or "Unknown",
+                rssi=adv.rssi if adv.rssi is not None else -100,
+            )
+
+    scanner = BleakScanner(detection_callback=callback)
+    await scanner.start()
+
+    for dev in await _find_connected_peripherals(scanner):
+        devices[dev.address] = dev
+
+    await asyncio.sleep(timeout)
+    await scanner.stop()
+
+    return sorted(devices.values(), key=lambda d: d.rssi, reverse=True)
+
+
+async def _resolve_device(address: str) -> BLEDevice | str:
+    if platform.system() != "Darwin":
+        return address
+    try:
+        from Foundation import NSUUID
+
+        scanner = BleakScanner(service_uuids=[C.SERVICE_UUID])
+        await scanner.start()
+        await asyncio.sleep(0.5)
+
+        cbmgr = scanner._backend._manager
+        cm = cbmgr.central_manager
+
+        ns_uuid = NSUUID.alloc().initWithUUIDString_(address)
+        peripherals = cm.retrievePeripheralsWithIdentifiers_([ns_uuid])
+
+        await scanner.stop()
+
+        if peripherals and len(peripherals) > 0:
+            peripheral = peripherals[0]
+            return BLEDevice(
+                address=str(peripheral.identifier()),
+                name=str(peripheral.name()) if peripheral.name() else "JBL Pulse 5",
+                details=(peripheral, cbmgr),
+            )
+    except Exception:
+        pass
+    return address
+
+
+@asynccontextmanager
+async def connect(address: str) -> AsyncIterator[BleakClient]:
+    last_error: Exception | None = None
+    device = await _resolve_device(address)
+
+    for attempt in range(C.MAX_RECONNECT_ATTEMPTS):
+        try:
+            client = BleakClient(device)
+            await client.connect()
+            try:
+                yield client
+            finally:
+                if client.is_connected:
+                    await client.disconnect()
+            return
+        except Exception as e:
+            last_error = e
+            if attempt < C.MAX_RECONNECT_ATTEMPTS - 1:
+                delay = C.BASE_RECONNECT_DELAY * (2 ** attempt)
+                await asyncio.sleep(delay)
+
+    raise ConnectionError(
+        f"Failed to connect after {C.MAX_RECONNECT_ATTEMPTS} attempts: {last_error}"
+    )
+
+
+async def write(client: BleakClient, data: bytes) -> None:
+    char = client.services.get_characteristic(C.WRITE_CHAR_UUID)
+    if char is None:
+        raise RuntimeError(f"Write characteristic {C.WRITE_CHAR_UUID} not found")
+    response = "write" in char.properties
+    await client.write_gatt_char(char, data, response=response)
+
+
+async def subscribe(client: BleakClient, callback: Callable[[bytearray], None]) -> None:
+    char = client.services.get_characteristic(C.READ_CHAR_UUID)
+    if char is None:
+        raise RuntimeError(f"Read characteristic {C.READ_CHAR_UUID} not found")
+
+    def handler(_sender: int, data: bytearray) -> None:
+        callback(data)
+
+    await client.start_notify(char, handler)

pulse5/cli.py

@@ -0,0 +1,155 @@
+from __future__ import annotations
+
+import asyncio
+import sys
+
+import click
+
+from pulse5 import ble, config
+from pulse5.protocol.codec import PulseCodec
+from pulse5.protocol.models import PATTERN_BY_NAME, THEME_BY_NAME, ColorEffect
+
+
+def _run(coro):
+    return asyncio.run(coro)
+
+
+def _get_address(address: str | None) -> str:
+    if address:
+        return address
+    saved = config.get_saved_device()
+    if saved:
+        return saved[0]
+    click.echo("Error: No device specified. Run 'pulse5 scan' first or pass --address.", err=True)
+    sys.exit(1)
+
+
+@click.group()
+@click.option("--address", "-a", default=None, help="Device BLE address.")
+@click.pass_context
+def cli(ctx: click.Context, address: str | None) -> None:
+    """Control JBL Pulse 5 speaker LEDs over Bluetooth."""
+    ctx.ensure_object(dict)
+    ctx.obj["address"] = address
+
+
+@cli.command()
+@click.option("--timeout", "-t", default=5.0, help="Scan duration in seconds.")
+def scan(timeout: float) -> None:
+    """Discover nearby JBL Pulse 5 speakers."""
+
+    async def _scan():
+        click.echo(f"Scanning for {timeout}s...")
+        devices = await ble.scan(timeout=timeout)
+        if not devices:
+            click.echo("No JBL Pulse 5 speakers found.")
+            return
+        click.echo(f"Found {len(devices)} device(s):\n")
+        for d in devices:
+            click.echo(f"  {d.name}")
+            click.echo(f"    Address: {d.address}")
+            click.echo(f"    RSSI:    {d.rssi} dBm")
+            click.echo()
+        best = devices[0]
+        config.save_device(best.address, best.name)
+        click.echo(f"Saved '{best.name}' ({best.address}) as default device.")
+
+    _run(_scan())
+
+
+@cli.command()
+@click.argument("level", type=click.IntRange(20, 80))
+@click.pass_context
+def brightness(ctx: click.Context, level: int) -> None:
+    """Set brightness level (20-80)."""
+    address = _get_address(ctx.obj["address"])
+
+    async def _cmd():
+        async with ble.connect(address) as client:
+            await ble.write(client, PulseCodec.set_led_brightness(level))
+            click.echo(f"Brightness set to {level}.")
+
+    _run(_cmd())
+
+
+@cli.command()
+@click.argument("name", type=click.Choice(list(THEME_BY_NAME.keys()), case_sensitive=False))
+@click.pass_context
+def theme(ctx: click.Context, name: str) -> None:
+    """Set LED theme."""
+    address = _get_address(ctx.obj["address"])
+    t = THEME_BY_NAME[name.lower()]
+
+    async def _cmd():
+        async with ble.connect(address) as client:
+            await ble.write(client, PulseCodec.switch_package(t.value))
+            click.echo(f"Theme set to {t.display_name}.")
+
+    _run(_cmd())
+
+
+@cli.command()
+@click.argument("name", type=click.Choice(list(PATTERN_BY_NAME.keys()), case_sensitive=False))
+@click.pass_context
+def pattern(ctx: click.Context, name: str) -> None:
+    """Set an LED pattern."""
+    address = _get_address(ctx.obj["address"])
+    p = PATTERN_BY_NAME[name.lower()]
+    t = p.theme
+    all_pats = [pat.value for pat in t.patterns]
+    ordered = [p.value] + [v for v in all_pats if v != p.value]
+
+    async def _cmd():
+        async with ble.connect(address) as client:
+            await ble.write(client, PulseCodec.set_led_package(
+                package_id=t.value,
+                active_patterns=[p.value],
+                all_patterns=ordered,
+                color_effect=ColorEffect.COLOR_LOOP.value,
+                red=0xFF, green=0xFF, blue=0xFF,
+            ))
+            click.echo(f"Pattern set to {p.display_name}.")
+
+    _run(_cmd())
+
+
+@cli.command()
+@click.pass_context
+def status(ctx: click.Context) -> None:
+    """Query current speaker state."""
+    address = _get_address(ctx.obj["address"])
+
+    async def _cmd():
+        results: dict[str, object] = {}
+
+        def on_notify(data: bytearray) -> None:
+            brt = PulseCodec.parse_brightness_state(data)
+            if brt is not None:
+                results["brightness"] = brt
+            thm = PulseCodec.parse_selected_theme(data)
+            if thm is not None:
+                results["theme"] = thm
+
+        async with ble.connect(address) as client:
+            await ble.subscribe(client, on_notify)
+            await ble.write(client, PulseCodec.request_led_brightness())
+            await asyncio.sleep(0.5)
+            await ble.write(client, PulseCodec.request_led_package_info())
+            await asyncio.sleep(0.5)
+
+        click.echo("Speaker Status:")
+        if "brightness" in results:
+            brt = results["brightness"]
+            click.echo(f"  Brightness: {brt.level}")
+        if "theme" in results:
+            click.echo(f"  Theme:      {results['theme'].display_name}")
+
+    _run(_cmd())
+
+
+def main() -> None:
+    cli()
+
+
+if __name__ == "__main__":
+    main()

pulse5/config.py

@@ -0,0 +1,44 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+CONFIG_DIR = Path.home() / ".config" / "pulse5"
+CONFIG_FILE = CONFIG_DIR / "config.json"
+
+
+def _load() -> dict:
+    if CONFIG_FILE.exists():
+        try:
+            return json.loads(CONFIG_FILE.read_text())
+        except (json.JSONDecodeError, OSError):
+            return {}
+    return {}
+
+
+def _save(data: dict) -> None:
+    CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+    CONFIG_FILE.write_text(json.dumps(data, indent=2) + "\n")
+
+
+def get_saved_device() -> tuple[str, str] | None:
+    data = _load()
+    addr = data.get("address")
+    name = data.get("name")
+    if addr:
+        return (addr, name or "Unknown")
+    return None
+
+
+def save_device(address: str, name: str) -> None:
+    data = _load()
+    data["address"] = address
+    data["name"] = name
+    _save(data)
+
+
+def clear_device() -> None:
+    data = _load()
+    data.pop("address", None)
+    data.pop("name", None)
+    _save(data)

pulse5/mcp_server.py

@@ -0,0 +1,62 @@
+from __future__ import annotations
+
+import asyncio
+import sys
+
+from mcp.server.fastmcp import FastMCP
+
+mcp = FastMCP("pulse5")
+
+
+async def _run_pulse5(*args: str) -> str:
+    proc = await asyncio.create_subprocess_exec(
+        sys.executable, "-m", "pulse5.cli", *args,
+        stdout=asyncio.subprocess.PIPE,
+        stderr=asyncio.subprocess.PIPE,
+        stdin=asyncio.subprocess.DEVNULL,
+        start_new_session=True,
+    )
+    stdout, stderr = await proc.communicate()
+    output = stdout.decode().strip()
+    if proc.returncode != 0:
+        err = stderr.decode().strip()
+        return f"Failed: {err or output or f'exit code {proc.returncode}'}"
+    return output or "Done."
+
+
+@mcp.tool()
+async def pulse5_scan(timeout: float = 5) -> str:
+    """Discover nearby JBL Pulse 5 speakers via BLE."""
+    return await _run_pulse5("scan", "--timeout", str(timeout))
+
+
+@mcp.tool()
+async def pulse5_brightness(level: int) -> str:
+    """Set speaker LED brightness (20-80)."""
+    return await _run_pulse5("brightness", str(level))
+
+
+@mcp.tool()
+async def pulse5_theme(name: str) -> str:
+    """Set LED theme. Options: nature, party, spiritual, cocktail, weather."""
+    return await _run_pulse5("theme", name)
+
+
+@mcp.tool()
+async def pulse5_pattern(name: str) -> str:
+    """Set LED pattern. Options: campfire, northern lights, sea wave, universe, strobe, equalizer, geometry, spin, rainbow, dynamic wave, lava, focus, sky sunny, rain, snow, thunder, cloud, fruit gin, mojito, tequila, cherry."""
+    return await _run_pulse5("pattern", name)
+
+
+@mcp.tool()
+async def pulse5_status() -> str:
+    """Query current speaker state (brightness, theme)."""
+    return await _run_pulse5("status")
+
+
+def main() -> None:
+    mcp.run()
+
+
+if __name__ == "__main__":
+    main()

pulse5/protocol/codec.py

@@ -0,0 +1,110 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from pulse5.protocol.constants import PulseConstants as C
+from pulse5.protocol.models import LEDTheme
+
+
+@dataclass
+class Response:
+    command_id: int
+    payload: bytes
+
+
+@dataclass
+class BrightnessState:
+    level: int
+    body_light_on: bool
+    projection_on: bool
+
+
+class PulseCodec:
+
+    @staticmethod
+    def request_speaker_info() -> bytes:
+        return bytes([C.HEADER, C.CMD_REQ_SPEAKER_INFO, 0x00])
+
+    @staticmethod
+    def switch_package(package_id: int) -> bytes:
+        return bytes([C.HEADER, C.CMD_SWITCH_LED_PACKAGE, 0x01, package_id])
+
+    @staticmethod
+    def set_led_brightness(level: int, body_light: bool = True, projection: bool = True) -> bytes:
+        clamped = min(max(level, C.MIN_BRIGHTNESS), C.MAX_BRIGHTNESS)
+        return bytes([
+            C.HEADER,
+            C.CMD_SET_LED_BRIGHTNESS,
+            0x03,
+            clamped,
+            1 if body_light else 0,
+            1 if projection else 0,
+        ])
+
+    @staticmethod
+    def request_led_brightness() -> bytes:
+        return bytes([C.HEADER, C.CMD_REQ_LED_BRIGHTNESS, 0x00])
+
+    @staticmethod
+    def request_led_package_info() -> bytes:
+        return bytes([C.HEADER, C.CMD_REQ_LED_PACKAGE_INFO, 0x00])
+
+    @staticmethod
+    def set_led_package(
+        package_id: int,
+        active_patterns: list[int],
+        all_patterns: list[int],
+        color_effect: int,
+        red: int,
+        green: int,
+        blue: int,
+    ) -> bytes:
+        all_count = len(all_patterns)
+        active_count = len(active_patterns)
+        length = all_count + 7
+
+        data = bytearray([
+            C.HEADER,
+            C.CMD_SET_LED_PACKAGE,
+            length,
+            package_id,
+            active_count,
+            all_count,
+        ])
+        data.extend(all_patterns)
+        data.extend([color_effect, red, green, blue])
+        return bytes(data)
+
+    @staticmethod
+    def parse(data: bytes | bytearray) -> Response | None:
+        if len(data) < 3 or data[0] != C.HEADER:
+            return None
+        command_id = data[1]
+        length = data[2]
+        payload = bytes(data[3 : 3 + length])
+        return Response(command_id=command_id, payload=payload)
+
+    @staticmethod
+    def parse_brightness_state(data: bytes | bytearray) -> BrightnessState | None:
+        response = PulseCodec.parse(data)
+        if response is None or response.command_id != C.CMD_RET_LED_BRIGHTNESS:
+            return None
+        if len(response.payload) < 3:
+            return None
+        return BrightnessState(
+            level=response.payload[0],
+            body_light_on=response.payload[1] != 0,
+            projection_on=response.payload[2] != 0,
+        )
+
+    @staticmethod
+    def parse_selected_theme(data: bytes | bytearray) -> LEDTheme | None:
+        response = PulseCodec.parse(data)
+        if response is None or response.command_id != C.CMD_RET_LED_PACKAGE_INFO:
+            return None
+        if len(response.payload) < 2:
+            return None
+        try:
+            return LEDTheme(response.payload[1])
+        except ValueError:
+            return None

pulse5/protocol/constants.py

@@ -0,0 +1,26 @@
+class PulseConstants:
+    SERVICE_UUID = "65786365-6c70-6f69-6e74-2e636f6d0000"
+    WRITE_CHAR_UUID = "65786365-6c70-6f69-6e74-2e636f6d0002"
+    READ_CHAR_UUID = "65786365-6c70-6f69-6e74-2e636f6d0001"
+
+    HEADER = 0xAA
+
+    CMD_REQ_SPEAKER_INFO = 0x11
+
+    CMD_REQ_LED_PACKAGE_INFO = 0x83
+    CMD_RET_LED_PACKAGE_INFO = 0x84
+    CMD_SET_LED_PACKAGE = 0x85
+
+    CMD_SET_LED_BRIGHTNESS = 0x8A
+    CMD_REQ_LED_BRIGHTNESS = 0x8B
+    CMD_RET_LED_BRIGHTNESS = 0x8C
+
+    CMD_SWITCH_LED_PACKAGE = 0x90
+
+    MIN_BRIGHTNESS = 20
+    MAX_BRIGHTNESS = 80
+
+    DEVICE_NAME_PREFIX = "JBL"
+
+    MAX_RECONNECT_ATTEMPTS = 3
+    BASE_RECONNECT_DELAY = 1.0

pulse5/protocol/models.py

@@ -0,0 +1,138 @@
+from enum import IntEnum
+
+
+class LEDTheme(IntEnum):
+    NATURE = 0x01
+    PARTY = 0x02
+    SPIRITUAL = 0x03
+    COCKTAIL = 0x04
+    WEATHER = 0x05
+    CANVAS = 0xC1
+
+    @property
+    def display_name(self) -> str:
+        return _THEME_NAMES[self]
+
+    @property
+    def patterns(self) -> list["LEDPattern"]:
+        return list(_THEME_PATTERNS[self])
+
+
+class LEDPattern(IntEnum):
+    CAMPFIRE = 0x01
+    NORTHERN_LIGHTS = 0x02
+    SEA_WAVE = 0x03
+    UNIVERSE = 0x04
+    STROBE = 0x05
+    EQUALIZER = 0x06
+    GEOMETRY = 0x07
+    SPIN = 0x08
+    RAINBOW = 0x09
+    DYNAMIC_WAVE = 0x0A
+    LAVA = 0x0B
+    FOCUS = 0x0C
+    SKY_SUNNY = 0x0D
+    RAIN = 0x0E
+    SNOW = 0x0F
+    THUNDER = 0x10
+    CLOUD = 0x11
+    FRUIT_GIN = 0x13
+    MOJITO = 0x14
+    TEQUILA = 0x15
+    CHERRY = 0x16
+
+    @property
+    def display_name(self) -> str:
+        return _PATTERN_NAMES[self]
+
+    @property
+    def theme(self) -> LEDTheme:
+        return _PATTERN_TO_THEME[self]
+
+
+class ColorEffect(IntEnum):
+    STATIC = 0
+    COLOR_LOOP = 1
+
+
+_THEME_NAMES: dict[LEDTheme, str] = {
+    LEDTheme.NATURE: "Nature",
+    LEDTheme.PARTY: "Party",
+    LEDTheme.SPIRITUAL: "Spiritual",
+    LEDTheme.COCKTAIL: "Cocktail",
+    LEDTheme.WEATHER: "Weather",
+    LEDTheme.CANVAS: "Canvas",
+}
+
+_PATTERN_NAMES: dict[LEDPattern, str] = {
+    LEDPattern.CAMPFIRE: "Campfire",
+    LEDPattern.NORTHERN_LIGHTS: "Northern Lights",
+    LEDPattern.SEA_WAVE: "Sea Wave",
+    LEDPattern.UNIVERSE: "Universe",
+    LEDPattern.STROBE: "Strobe",
+    LEDPattern.EQUALIZER: "Equalizer",
+    LEDPattern.GEOMETRY: "Geometry",
+    LEDPattern.SPIN: "Spin",
+    LEDPattern.RAINBOW: "Rainbow",
+    LEDPattern.DYNAMIC_WAVE: "Dynamic Wave",
+    LEDPattern.LAVA: "Lava",
+    LEDPattern.FOCUS: "Focus",
+    LEDPattern.SKY_SUNNY: "Sky Sunny",
+    LEDPattern.RAIN: "Rain",
+    LEDPattern.SNOW: "Snow",
+    LEDPattern.THUNDER: "Thunder",
+    LEDPattern.CLOUD: "Cloud",
+    LEDPattern.FRUIT_GIN: "Fruit Gin",
+    LEDPattern.MOJITO: "Mojito",
+    LEDPattern.TEQUILA: "Tequila",
+    LEDPattern.CHERRY: "Cherry",
+}
+
+_THEME_PATTERNS: dict[LEDTheme, tuple[LEDPattern, ...]] = {
+    LEDTheme.NATURE: (
+        LEDPattern.CAMPFIRE,
+        LEDPattern.NORTHERN_LIGHTS,
+        LEDPattern.SEA_WAVE,
+        LEDPattern.UNIVERSE,
+    ),
+    LEDTheme.PARTY: (
+        LEDPattern.STROBE,
+        LEDPattern.EQUALIZER,
+        LEDPattern.GEOMETRY,
+        LEDPattern.SPIN,
+        LEDPattern.RAINBOW,
+    ),
+    LEDTheme.SPIRITUAL: (
+        LEDPattern.DYNAMIC_WAVE,
+        LEDPattern.LAVA,
+        LEDPattern.FOCUS,
+    ),
+    LEDTheme.COCKTAIL: (
+        LEDPattern.FRUIT_GIN,
+        LEDPattern.MOJITO,
+        LEDPattern.TEQUILA,
+        LEDPattern.CHERRY,
+    ),
+    LEDTheme.WEATHER: (
+        LEDPattern.SKY_SUNNY,
+        LEDPattern.RAIN,
+        LEDPattern.SNOW,
+        LEDPattern.THUNDER,
+        LEDPattern.CLOUD,
+    ),
+    LEDTheme.CANVAS: (),
+}
+
+_PATTERN_TO_THEME: dict[LEDPattern, LEDTheme] = {
+    pattern: theme
+    for theme, patterns in _THEME_PATTERNS.items()
+    for pattern in patterns
+}
+
+THEME_BY_NAME: dict[str, LEDTheme] = {
+    t.display_name.lower(): t for t in LEDTheme if t != LEDTheme.CANVAS
+}
+
+PATTERN_BY_NAME: dict[str, LEDPattern] = {
+    p.display_name.lower(): p for p in LEDPattern
+}

pulse5ctl-1.3.0.dist-info/METADATA

@@ -0,0 +1,9 @@
+Metadata-Version: 2.4
+Name: pulse5ctl
+Version: 1.3.0
+Summary: CLI & MCP server for JBL Pulse 5 LED control over BLE
+License-Expression: MIT
+Requires-Python: >=3.10
+Requires-Dist: bleak>=0.21.0
+Requires-Dist: click>=8.0
+Requires-Dist: mcp>=1.2.0

pulse5ctl-1.3.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+pulse5/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pulse5/ble.py,sha256=mrzRYnPxgwbwa0be7iTwapEiFeo0ldOVc0GF9nryml8,4576
+pulse5/cli.py,sha256=Wu2H6c3g1u7WMlvRAcij9UT5cNx8M-E7QKEGmMAjDtM,4748
+pulse5/config.py,sha256=4L43kgetpn9-3pSHSzcnLfJzJy50QZtgyh-jjNjB-3c,975
+pulse5/mcp_server.py,sha256=mQ25VIN48s4PhPGyrzoiPV2Vci21ZOU-QE8jP01uF6I,1767
+pulse5/protocol/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pulse5/protocol/codec.py,sha256=sUxj-2eOg5dff2SgjykDDxwuF65ofxoeTZptN1gQQHM,3161
+pulse5/protocol/constants.py,sha256=V1sjUnfb6nWh_1cOrR5SEuQQ9kTmDjM3-VoSYHgD2pM,639
+pulse5/protocol/models.py,sha256=VhxbBVcaTyPFsW1xs1_BhYbmAa8gf0DfEg72tQN7W9I,3244
+pulse5ctl-1.3.0.dist-info/METADATA,sha256=Bw_I0f3RH70LBH0_zQRrltVlyS9h5DlB0s5yeu4dYhE,245
+pulse5ctl-1.3.0.dist-info/WHEEL,sha256=YCfwYGOYMi5Jhw2fU4yNgwErybb2IX5PEwBKV4ZbdBo,91
+pulse5ctl-1.3.0.dist-info/entry_points.txt,sha256=U_wLDZvVUsrOyVHqKQSMR6Hl_c1ivmPoDIFlXjxP4Ps,79
+pulse5ctl-1.3.0.dist-info/top_level.txt,sha256=a9CWBETAUNB6nQBWtQbs2cPi-_oF9WuJGo9W69ctXiQ,7
+pulse5ctl-1.3.0.dist-info/RECORD,,

pulse5ctl-1.3.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

pulse5ctl-1.3.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+pulse5 = pulse5.cli:main
+pulse5-mcp = pulse5.mcp_server:main

pulse5ctl-1.3.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+pulse5