socketry 0.1.0__py3-none-any.whl

socketry/__init__.py

@@ -0,0 +1,6 @@
+"""Python API and CLI for controlling Jackery portable power stations."""
+
+from socketry.client import Client
+from socketry.properties import MODEL_NAMES, PROPERTIES, Setting
+
+__all__ = ["Client", "MODEL_NAMES", "PROPERTIES", "Setting"]

socketry/__main__.py

@@ -0,0 +1,5 @@
+"""Allow running with ``python -m socketry``."""
+
+from socketry.cli import app
+
+app()

socketry/_constants.py

@@ -0,0 +1,52 @@
+"""Internal constants extracted from the decompiled Jackery APK."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+API_BASE = "https://iot.jackeryapp.com/v1"
+
+MQTT_HOST = "emqx.jackeryapp.com"
+MQTT_PORT = 8883
+
+RSA_PUBLIC_KEY_B64 = (
+    "MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCVmzgJy/4XolxPnkfu32YtJqYG"
+    "FLYqf9/rnVgURJED+8J9J3Pccd6+9L97/+7COZE5OkejsgOkqeLNC9C3r5mhpE4z"
+    "k/HStss7Q8/5DqkGD1annQ+eoICo3oi0dITZ0Qll56Dowb8lXi6WHViVDdih/oeU"
+    "wVJY89uJNtTWrz7t7QIDAQAB"
+)
+
+# Self-signed CA cert for emqx.jackeryapp.com (from APK res/raw/ca.crt)
+CA_CERT_PEM = """\
+-----BEGIN CERTIFICATE-----
+MIIDtTCCAp2gAwIBAgIJAPvYSRLMmPACMA0GCSqGSIb3DQEBCwUAMHAxCzAJBgNV
+BAYTAkNOMRIwEAYDVQQIDAlHdWFuZ2RvbmcxETAPBgNVBAcMCFNoZW56aGVuMRQw
+EgYDVQQKDAtqYWNrZXJ5LmNvbTELMAkGA1UECwwCY2ExFzAVBgNVBAMMDmNhLmph
+Y2tlcnkuY29tMCAXDTIyMTIyMzEwMTc0N1oYDzIwNzcwOTI1MTAxNzQ3WjBwMQsw
+CQYDVQQGEwJDTjESMBAGA1UECAwJR3Vhbmdkb25nMREwDwYDVQQHDAhTaGVuemhl
+bjEUMBIGA1UECgwLamFja2VyeS5jb20xCzAJBgNVBAsMAmNhMRcwFQYDVQQDDA5j
+YS5qYWNrZXJ5LmNvbTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAOrf
+QltVp+PDphQ20tfQbCh/YlqIAK8VkIcYXq7DlVsX1HGl5x+6UkEahzLRtZFaWRkH
+HiHSvol8I+cvq6BHte0VsjKAzl7Mae7P/UyQXwpgNa+hliZHoEqflghzYvxjlZeP
+eOGGcHxg1p2M8+PeNWkX5VkVTSYi/abDz86+D5y1gq7S8n+tYk1WhKFHvIrfX3nN
+4QXfDO7vAQMd1uc6YdDqRanWjxIgOSDk9B+Mblz0TxCR+hnuDDQpAE4ONjByjArS
+MC/QS8BIq/TL6nixzA8y0vOHySmuOLfuhFpNoO2mujhBGN/Dmq/pZwmsKSK91PxE
+dn3YO8N8q7flHd/Qw4UCAwEAAaNQME4wHQYDVR0OBBYEFL/rQk0x4WclVgw3WLsl
+YH3k0dvgMB8GA1UdIwQYMBaAFL/rQk0x4WclVgw3WLslYH3k0dvgMAwGA1UdEwQF
+MAMBAf8wDQYJKoZIhvcNAQELBQADggEBALZM+xA4bUnO/7/0giZ3xUPEKzwFDp4G
+5UPI/5grLYxp38t2M84tlJ94W/HKH+f1CYbJ6m28dSZfWtnRzQ3Tgq0whrsmYiK9
+1Txcl3HPBiL7yAn3yE8DjHV+S2eSnN0o26/rcXCe+9bghSqqGaVDOJyk+Fm4l17e
+Hzx99PvPGkpGUglun3UEp/Vp5ZUl9uDYT813HJ9jK80i1MDlzBJWmg7gzh27/Qls
+UJLtYvgsxiBKAnK8YkAyu51Jm8uLz1BZ1RANf22vv0QUTW+SGdgc5Q1h610G9N1i
+4BaijfWnto9ka32QKgZA0gHXsT3wiwdbEow0lp7y40aiXq4kazDT7ws=
+-----END CERTIFICATE-----
+"""
+
+CRED_DIR = Path.home() / ".config" / "socketry"
+CRED_FILE = CRED_DIR / "credentials.json"
+
+APP_HEADERS: dict[str, str] = {
+    "platform": "2",
+    "app_version": "1.2.0",
+    "Content-Type": "application/x-www-form-urlencoded",
+}

socketry/_crypto.py

@@ -0,0 +1,51 @@
+"""Internal cryptographic helpers for Jackery API authentication."""
+
+from __future__ import annotations
+
+import base64
+import uuid
+
+from Crypto.Cipher import AES, PKCS1_v1_5
+from Crypto.PublicKey import RSA
+from Crypto.Util.Padding import pad
+
+
+def aes_ecb_encrypt(plaintext: bytes, key: bytes) -> bytes:
+    """AES/ECB/PKCS5Padding encryption (used for HTTP login body)."""
+    cipher = AES.new(key, AES.MODE_ECB)
+    result: bytes = cipher.encrypt(pad(plaintext, AES.block_size))
+    return result
+
+
+def rsa_encrypt(plaintext: bytes, pub_key_b64: str) -> bytes:
+    """RSA/ECB/PKCS1Padding encryption (used for encrypting AES key)."""
+    der = base64.b64decode(pub_key_b64)
+    key = RSA.import_key(der)
+    cipher = PKCS1_v1_5.new(key)
+    result: bytes = cipher.encrypt(plaintext)
+    return result
+
+
+def aes_cbc_encrypt(plaintext: bytes, key: bytes, iv: bytes) -> bytes:
+    """AES/CBC/PKCS5Padding encryption (used for MQTT password derivation)."""
+    cipher = AES.new(key, AES.MODE_CBC, iv)
+    result: bytes = cipher.encrypt(pad(plaintext, AES.block_size))
+    return result
+
+
+def derive_mqtt_password(username: str, mqtt_password_b64: str) -> str:
+    """Derive the MQTT connection password from the stored mqttPassWord.
+
+    The app does: AES/CBC/PKCS5Padding(username, key=b64decode(mqttPassWord), iv=key[:16])
+    then base64-encodes the result and sends it as the MQTT password string.
+    """
+    key = base64.b64decode(mqtt_password_b64)
+    iv = key[:16]
+    encrypted = aes_cbc_encrypt(username.encode("utf-8"), key, iv)
+    return base64.b64encode(encrypted).decode("ascii")
+
+
+def get_mac_id() -> str:
+    """Generate a stable MAC-like identifier for this machine."""
+    node = uuid.getnode()
+    return ":".join(f"{(node >> (8 * i)) & 0xFF:02x}" for i in range(5, -1, -1))

socketry/cli.py

@@ -0,0 +1,275 @@
+"""Thin CLI wrapper over :class:`socketry.Client`."""
+
+from __future__ import annotations
+
+import json
+import sys
+
+import typer
+
+from socketry.client import Client
+from socketry.properties import GROUP_TITLES, MODEL_NAMES, PROPERTIES, Setting, resolve
+
+app = typer.Typer(help="Control Jackery power stations.", invoke_without_command=True)
+
+_by_id: dict[str, Setting] = {s.id: s for s in PROPERTIES}
+
+
+@app.callback()
+def main(ctx: typer.Context) -> None:
+    """Control Jackery power stations."""
+    if ctx.invoked_subcommand is None:
+        typer.echo(ctx.get_help())
+        raise typer.Exit(0)
+
+
+def _print_json(obj: object) -> None:
+    """Print JSON — syntax-highlighted when stdout is a TTY, compact otherwise."""
+    if sys.stdout.isatty():
+        try:
+            from rich.console import Console
+            from rich.syntax import Syntax
+
+            Console().print(Syntax(json.dumps(obj, indent=2), "json"))
+        except ImportError:
+            typer.echo(json.dumps(obj, indent=2))
+    else:
+        typer.echo(json.dumps(obj))
+
+
+def _ensure_client() -> Client:
+    """Load saved credentials or exit with an error."""
+    try:
+        return Client.from_saved()
+    except FileNotFoundError:
+        typer.echo("No saved credentials. Run `socketry login` first.", err=True)
+        raise typer.Exit(1) from None
+
+
+# ---------------------------------------------------------------------------
+# Commands
+# ---------------------------------------------------------------------------
+
+
+@app.command()
+def login(
+    email: str = typer.Option(..., prompt=True, help="Jackery account email"),
+    password: str = typer.Option(
+        ..., prompt=True, hide_input=True, help="Jackery account password"
+    ),
+) -> None:
+    """Authenticate with Jackery and save credentials locally."""
+    typer.echo(f"Logging in as {email}...")
+    client = Client.login(email, password)
+    client.save_credentials()
+    n = len(client.devices)
+    typer.echo(
+        f"Logged in. {n} device(s) found. Selected: {client.device_name} (SN: {client.device_sn})"
+    )
+
+
+@app.command()
+def devices() -> None:
+    """List all devices (owned and shared). Refreshes from API."""
+    client = _ensure_client()
+    typer.echo("Fetching devices...")
+    all_devices = client.fetch_devices()
+    if not all_devices:
+        typer.echo("No devices found.", err=True)
+        raise typer.Exit(1)
+
+    client.save_credentials()
+
+    selected_sn = client.device_sn
+    for i, dev in enumerate(all_devices):
+        marker = "*" if dev["devSn"] == selected_sn else " "
+        model = MODEL_NAMES.get(int(str(dev.get("modelCode", 0) or 0)), "Unknown model")
+        shared = f" (shared by {dev['sharedBy']})" if dev.get("shared") else ""
+        typer.echo(f"  {marker} [{i}] {dev['devName']} — {model}{shared}")
+        typer.echo(f"        SN: {dev['devSn']}")
+
+    typer.echo("\n  * = selected.  Use `socketry select <index>` to change.")
+
+
+@app.command()
+def select(index: int) -> None:
+    """Select the active device by index (see ``devices`` for the list)."""
+    client = _ensure_client()
+    try:
+        dev = client.select_device(index)
+    except IndexError as e:
+        typer.echo(str(e), err=True)
+        raise typer.Exit(1) from None
+    client.save_credentials()
+    model = MODEL_NAMES.get(int(str(dev.get("modelCode", 0) or 0)), "Unknown model")
+    typer.echo(f"Selected: {dev['devName']} — {model} (SN: {dev['devSn']})")
+
+
+@app.command("get", context_settings={"help_option_names": ["-h", "--help"]})
+def get_property(
+    ctx: typer.Context,
+    name: str | None = typer.Argument(None, help="Property name or raw key"),
+    as_json: bool = typer.Option(False, "--json", "-j", help="Output as JSON"),
+) -> None:
+    """Query device properties.
+
+    \b
+    Without arguments, shows all properties grouped.
+    With a property name, shows just that value.
+    Accepts CLI names (battery, ac) and raw keys (rb, oac).
+    """
+    client = _ensure_client()
+
+    try:
+        data = client.get_all_properties()
+    except (ValueError, RuntimeError) as e:
+        typer.echo(str(e), err=True)
+        raise typer.Exit(1) from None
+
+    if not data:
+        typer.echo("No properties returned.", err=True)
+        raise typer.Exit(1)
+
+    props = data.get("properties") or data
+    if not isinstance(props, dict):
+        typer.echo("Unexpected response format.", err=True)
+        raise typer.Exit(1)
+
+    # Single property query
+    if name is not None:
+        s = resolve(name)
+        if s is None:
+            typer.echo(f"Unknown property '{name}'.", err=True)
+            raise typer.Exit(1)
+        if s.id not in props:
+            typer.echo(f"Property '{name}' ({s.id}) not reported by device.", err=True)
+            raise typer.Exit(1)
+        raw = props[s.id]
+        if as_json:
+            _print_json({s.id: raw})
+        else:
+            typer.echo(f"{s.name}: {s.format_value(raw)}")
+        return
+
+    # All properties
+    if as_json:
+        _print_json(props)
+        return
+
+    is_tty = sys.stdout.isatty()
+
+    if is_tty:
+        typer.echo(typer.style(client.device_name, bold=True))
+    else:
+        typer.echo(client.device_name)
+
+    device_meta = data.get("device")
+    if isinstance(device_meta, dict):
+        online = device_meta.get("onlineStatus")
+        if online is not None:
+            typer.echo(f"  Online: {'yes' if online == 1 else 'no'}")
+
+    shown: set[str] = set()
+    for group in ("battery", "io", "settings", "power"):
+        group_settings = [s for s in PROPERTIES if s.group == group and s.id in props]
+        if not group_settings:
+            continue
+        title = GROUP_TITLES[group]
+        if is_tty:
+            typer.echo(f"\n  {typer.style(title, bold=True)}")
+        else:
+            typer.echo(f"\n  {title}")
+        for s in group_settings:
+            raw = props[s.id]
+            formatted = s.format_value(raw)
+            if is_tty:
+                typer.echo(f"    {typer.style(f'{s.name} ({s.slug})', fg='cyan')}: {formatted}")
+            else:
+                typer.echo(f"    {s.name} ({s.slug}): {formatted}")
+            shown.add(s.id)
+
+    # Remaining unknown keys
+    remaining = {k: v for k, v in props.items() if k not in shown}
+    if remaining:
+        if is_tty:
+            typer.echo(f"\n  {typer.style('Other', bold=True)}")
+        else:
+            typer.echo("\n  Other")
+        for k, v in remaining.items():
+            s = _by_id.get(k)
+            if s:
+                label = f"{s.name} ({s.slug})"
+                formatted = s.format_value(v)
+            else:
+                label = k
+                formatted = str(v)
+            if is_tty:
+                typer.echo(f"    {typer.style(label, fg='cyan')}: {formatted}")
+            else:
+                typer.echo(f"    {label}: {formatted}")
+
+
+@app.command("set", context_settings={"help_option_names": ["-h", "--help"]})
+def set_setting(
+    ctx: typer.Context,
+    setting: str | None = typer.Argument(None, help="Setting name"),
+    value: str | None = typer.Argument(None, help="Value to set"),
+    wait: bool = typer.Option(False, "--wait", "-w", help="Wait for device confirmation"),
+    verbose: bool = typer.Option(False, "--verbose", "-v", help="Show MQTT traffic"),
+) -> None:
+    """Change a device setting via MQTT.
+
+    \b
+    Settings (named values):
+      ac, dc, usb, car, ac-in, dc-in    on | off
+      light                              off | low | high | sos
+      charge-speed                       fast | mute
+      battery-protection                 full | eco
+      sfc, ups                           on | off
+
+    \b
+    Settings (integer values):
+      screen-timeout, auto-shutdown, energy-saving
+    """
+    if setting is None:
+        typer.echo(ctx.get_help())
+        raise typer.Exit(0)
+
+    s = resolve(setting)
+    if s is None or not s.writable:
+        writable = [p for p in PROPERTIES if p.writable]
+        names = ", ".join(p.slug for p in writable)
+        if s and not s.writable:
+            typer.echo(f"Property '{setting}' is read-only. Writable: {names}", err=True)
+        else:
+            typer.echo(f"Unknown setting '{setting}'. Available: {names}", err=True)
+        raise typer.Exit(1)
+
+    if value is None:
+        if s.values:
+            typer.echo(f"Setting '{s.slug}' expects a value: {' | '.join(s.values)}")
+        else:
+            typer.echo(f"Setting '{s.slug}' expects a value: <integer>")
+        raise typer.Exit(0)
+
+    client = _ensure_client()
+    typer.echo(f"Setting {s.slug} to {value}...")
+
+    try:
+        result = client.set_property(setting, value, wait=wait, verbose=verbose)
+    except (KeyError, ValueError) as e:
+        typer.echo(str(e), err=True)
+        raise typer.Exit(1) from None
+
+    if wait:
+        if result and isinstance(result, dict):
+            for k, v in result.items():
+                rs = _by_id.get(k)
+                if rs:
+                    typer.echo(f"  {rs.name}: {rs.format_value(v)}")
+                else:
+                    typer.echo(f"  {k}: {v}")
+        else:
+            typer.echo("No response from device (timeout).", err=True)
+    else:
+        typer.echo(f"Command sent to {client.device_name}.")

socketry/client.py

@@ -0,0 +1,520 @@
+"""Jackery power station API client.
+
+Provides programmatic access to Jackery power stations via their cloud
+HTTP API and MQTT broker. The :class:`Client` class is the main entry point::
+
+    from socketry import Client
+
+    client = Client.login("email@example.com", "password")
+    props = client.get_all_properties()
+    client.set_property("ac", "on", wait=True)
+"""
+
+from __future__ import annotations
+
+import base64
+import json
+import os
+import secrets
+import ssl
+import tempfile
+import time
+
+import paho.mqtt.client as mqtt
+import requests
+
+from socketry._constants import (
+    API_BASE,
+    APP_HEADERS,
+    CA_CERT_PEM,
+    CRED_DIR,
+    CRED_FILE,
+    MQTT_HOST,
+    MQTT_PORT,
+    RSA_PUBLIC_KEY_B64,
+)
+from socketry._crypto import (
+    aes_ecb_encrypt,
+    derive_mqtt_password,
+    get_mac_id,
+    rsa_encrypt,
+)
+from socketry.properties import Setting, resolve
+
+
+class Client:
+    """Jackery power station API client.
+
+    Use :meth:`login` to authenticate, or :meth:`from_saved` to load
+    previously saved credentials.
+    """
+
+    def __init__(self, credentials: dict[str, object]) -> None:
+        self._creds = credentials
+
+    # ------------------------------------------------------------------
+    # Construction
+    # ------------------------------------------------------------------
+
+    @classmethod
+    def login(cls, email: str, password: str) -> Client:
+        """Authenticate with Jackery and return a new client.
+
+        Credentials are **not** saved automatically — call
+        :meth:`save_credentials` to persist them.
+        """
+        creds = _http_login(email, password)
+        return cls(creds)
+
+    @classmethod
+    def from_saved(cls) -> Client:
+        """Load a client from previously saved credentials.
+
+        Raises :class:`FileNotFoundError` if no credentials file exists.
+        """
+        if not CRED_FILE.exists():
+            raise FileNotFoundError(
+                f"No saved credentials at {CRED_FILE}. Call Client.login() first."
+            )
+        creds = json.loads(CRED_FILE.read_text())
+        return cls(creds)
+
+    def save_credentials(self) -> None:
+        """Persist credentials to ``~/.config/socketry/credentials.json``."""
+        CRED_DIR.mkdir(parents=True, exist_ok=True)
+        CRED_FILE.write_text(json.dumps(self._creds, indent=2))
+        CRED_FILE.chmod(0o600)
+
+    # ------------------------------------------------------------------
+    # Properties
+    # ------------------------------------------------------------------
+
+    @property
+    def device_sn(self) -> str:
+        """Serial number of the currently selected device."""
+        return str(self._creds.get("deviceSn", ""))
+
+    @property
+    def device_name(self) -> str:
+        """Display name of the currently selected device."""
+        return str(self._creds.get("deviceName", self.device_sn))
+
+    @property
+    def device_id(self) -> str:
+        """Internal device ID (used for HTTP property queries)."""
+        return str(self._creds.get("deviceId", ""))
+
+    @property
+    def devices(self) -> list[dict[str, object]]:
+        """Cached list of all devices (owned + shared)."""
+        devs = self._creds.get("devices")
+        if isinstance(devs, list):
+            return devs
+        return []
+
+    @property
+    def token(self) -> str:
+        """Current JWT auth token."""
+        return str(self._creds.get("token", ""))
+
+    # ------------------------------------------------------------------
+    # Device management
+    # ------------------------------------------------------------------
+
+    def fetch_devices(self) -> list[dict[str, object]]:
+        """Refresh the device list from the API.
+
+        Updates the internal cache and returns all devices.
+        """
+        all_devices = _fetch_all_devices(self.token)
+        self._creds["devices"] = all_devices
+        return all_devices
+
+    def select_device(self, index: int) -> dict[str, object]:
+        """Select the active device by index.
+
+        Raises :class:`IndexError` if the index is out of range.
+        """
+        devs = self.devices
+        if not devs:
+            raise IndexError("No cached device list. Call fetch_devices() first.")
+        if index < 0 or index >= len(devs):
+            raise IndexError(f"Invalid index {index}. Must be 0..{len(devs) - 1}.")
+        dev = devs[index]
+        self._creds["deviceSn"] = dev["devSn"]
+        self._creds["deviceId"] = dev["devId"]
+        self._creds["deviceName"] = dev["devName"]
+        return dev
+
+    # ------------------------------------------------------------------
+    # Status (HTTP)
+    # ------------------------------------------------------------------
+
+    def get_all_properties(self) -> dict[str, object]:
+        """Fetch the full property map for the active device.
+
+        Returns the raw ``data`` dict from the HTTP API, containing
+        ``device`` metadata and ``properties`` map.
+        """
+        if not self.device_id:
+            raise ValueError("No deviceId. Call login() or select_device() first.")
+        return _fetch_device_properties(self.token, self.device_id)
+
+    def get_property(self, name: str) -> tuple[Setting, object]:
+        """Fetch a single property by slug or raw key.
+
+        Returns ``(setting, raw_value)``.
+
+        Raises :class:`KeyError` if the property is unknown or not
+        reported by the device.
+        """
+        setting = resolve(name)
+        if setting is None:
+            raise KeyError(f"Unknown property '{name}'.")
+        data = self.get_all_properties()
+        props = data.get("properties") or data
+        if not isinstance(props, dict) or setting.id not in props:
+            raise KeyError(f"Property '{name}' ({setting.id}) not reported by device.")
+        return setting, props[setting.id]
+
+    # ------------------------------------------------------------------
+    # Control (MQTT)
+    # ------------------------------------------------------------------
+
+    def set_property(
+        self,
+        name: str,
+        value: str | int,
+        *,
+        wait: bool = False,
+        verbose: bool = False,
+    ) -> dict[str, object] | None:
+        """Change a device setting via MQTT.
+
+        Args:
+            name: Setting slug or raw key (e.g. ``"ac"``, ``"oac"``).
+            value: Named value (``"on"``, ``"off"``) or integer.
+            wait: If ``True``, wait for device confirmation.
+            verbose: If ``True``, log MQTT traffic.
+
+        Returns:
+            The device response body if *wait* is ``True`` and the device
+            responds, otherwise ``None``.
+
+        Raises:
+            KeyError: If the setting is unknown.
+            ValueError: If the setting is read-only or the value is invalid.
+        """
+        setting = resolve(name)
+        if setting is None:
+            raise KeyError(f"Unknown setting '{name}'.")
+        if not setting.writable:
+            raise ValueError(f"Property '{name}' is read-only.")
+
+        int_value = _resolve_value(setting, value)
+        body: dict[str, object] = {setting.prop_key: int_value}
+        assert setting.action_id is not None
+
+        if wait:
+            result = _publish_and_wait(self._creds, setting.action_id, body, verbose=verbose)
+            if result is not None:
+                resp = result.get("body")
+                if isinstance(resp, dict):
+                    return resp
+            return None
+        else:
+            _publish_command(self._creds, setting.action_id, body)
+            return None
+
+
+# ---------------------------------------------------------------------------
+# Private helpers
+# ---------------------------------------------------------------------------
+
+
+def _resolve_value(setting: Setting, value: str | int) -> int:
+    """Convert a user-facing value to the integer used in MQTT commands."""
+    if isinstance(value, int):
+        return value
+    if setting.values is not None:
+        if value not in setting.values:
+            raise ValueError(
+                f"Invalid value '{value}' for {setting.slug}. "
+                f"Expected: {' | '.join(setting.values)}"
+            )
+        return setting.values.index(value)
+    try:
+        return int(value)
+    except ValueError:
+        raise ValueError(
+            f"Invalid value '{value}' for {setting.slug}. Expected an integer."
+        ) from None
+
+
+def _http_login(email: str, password: str) -> dict[str, object]:
+    """Perform the encrypted HTTP login and return credentials."""
+    mac_id = get_mac_id()
+    login_bean = json.dumps(
+        {
+            "account": email,
+            "password": password,
+            "loginType": 2,
+            "registerAppId": "com.hbxn.jackery",
+            "macId": mac_id,
+        },
+        separators=(",", ":"),
+    )
+
+    # Generate random AES key: 16 bytes -> base64 -> 24-char string.
+    # The app uses this base64 STRING's bytes (24 bytes, AES-192) as the actual
+    # AES key material for encrypting the body AND as the RSA plaintext.
+    aes_key_str = base64.b64encode(secrets.token_bytes(16)).decode("ascii")
+    aes_key_bytes = aes_key_str.encode("utf-8")  # 24 bytes
+
+    encrypted_body = aes_ecb_encrypt(login_bean.encode("utf-8"), aes_key_bytes)
+    aes_encrypt_data = base64.b64encode(encrypted_body).decode("ascii")
+
+    encrypted_key = rsa_encrypt(aes_key_bytes, RSA_PUBLIC_KEY_B64)
+    rsa_for_aes_key = base64.b64encode(encrypted_key).decode("ascii")
+
+    resp = requests.post(
+        f"{API_BASE}/auth/login",
+        params={"aesEncryptData": aes_encrypt_data, "rsaForAesKey": rsa_for_aes_key},
+        headers=APP_HEADERS,
+        timeout=15,
+    )
+    resp.raise_for_status()
+    body = resp.json()
+    if body.get("code") != 0:
+        msg = body.get("msg", "unknown error")
+        raise RuntimeError(f"Login failed: {msg}")
+
+    data = body["data"]
+    token = body["token"]
+
+    all_devices = _fetch_all_devices(token)
+    if not all_devices:
+        raise RuntimeError("No owned or shared devices found.")
+
+    device = all_devices[0]
+    return {
+        "userId": data["userId"],
+        "mqttPassWord": data["mqttPassWord"],
+        "token": token,
+        "deviceSn": device["devSn"],
+        "deviceId": device["devId"],
+        "deviceName": device["devName"],
+        "email": email,
+        "macId": mac_id,
+        "devices": all_devices,
+    }
+
+
+def _fetch_all_devices(token: str) -> list[dict[str, object]]:
+    """Fetch all devices (owned + shared) using the given auth token."""
+    auth_headers = {**APP_HEADERS, "token": token}
+    all_devices: list[dict[str, object]] = []
+
+    # Owned devices
+    dev_resp = requests.get(f"{API_BASE}/device/bind/list", headers=auth_headers, timeout=15)
+    dev_resp.raise_for_status()
+    for d in dev_resp.json().get("data") or []:
+        all_devices.append(
+            {
+                "devSn": d["devSn"],
+                "devName": d.get("devNickname") or d.get("devName") or d["devSn"],
+                "devId": d.get("devId", ""),
+                "modelCode": d.get("modelCode", 0),
+                "shared": False,
+            }
+        )
+
+    # Shared devices
+    shared_resp = requests.get(f"{API_BASE}/device/bind/shared", headers=auth_headers, timeout=15)
+    shared_resp.raise_for_status()
+    shared_data = shared_resp.json().get("data") or {}
+    for share in shared_data.get("receive", []):
+        mgr_resp = requests.post(
+            f"{API_BASE}/device/bind/share/list",
+            data={
+                "bindUserId": str(share["bindUserId"]),
+                "level": str(share["level"]),
+            },
+            headers=auth_headers,
+            timeout=15,
+        )
+        mgr_resp.raise_for_status()
+        for d in mgr_resp.json().get("data", []):
+            all_devices.append(
+                {
+                    "devSn": d["devSn"],
+                    "devName": d.get("devNickname") or d.get("devName") or d["devSn"],
+                    "devId": d.get("devId", ""),
+                    "modelCode": d.get("modelCode", 0),
+                    "shared": True,
+                    "sharedBy": share.get("userName", ""),
+                }
+            )
+
+    return all_devices
+
+
+def _fetch_device_properties(token: str, device_id: str) -> dict[str, object]:
+    """Fetch full property map for a device via HTTP API."""
+    auth_headers = {**APP_HEADERS, "token": token}
+    resp = requests.get(
+        f"{API_BASE}/device/property",
+        params={"deviceId": device_id},
+        headers=auth_headers,
+        timeout=15,
+    )
+    resp.raise_for_status()
+    body = resp.json()
+    if body.get("code") != 0:
+        msg = body.get("msg", "unknown error")
+        raise RuntimeError(f"Property fetch failed: {msg}")
+    return body.get("data") or {}
+
+
+# ---------------------------------------------------------------------------
+# MQTT
+# ---------------------------------------------------------------------------
+
+
+def _make_mqtt_client(creds: dict[str, object]) -> tuple[mqtt.Client, str]:
+    """Create a configured MQTT client. Returns (client, ca_temp_path)."""
+    user_id = creds["userId"]
+    mac_id = str(creds.get("macId") or get_mac_id())
+    mqtt_pw_b64 = str(creds["mqttPassWord"])
+
+    client_id = f"{user_id}@APP"
+    username = f"{user_id}@{mac_id}"
+    password = derive_mqtt_password(username, mqtt_pw_b64)
+
+    ca_fd, ca_path = tempfile.mkstemp(suffix=".pem")
+    os.write(ca_fd, CA_CERT_PEM.encode())
+    os.close(ca_fd)
+
+    client = mqtt.Client(
+        callback_api_version=mqtt.CallbackAPIVersion.VERSION2,  # type: ignore[attr-defined]
+        client_id=client_id,
+        protocol=mqtt.MQTTv311,
+    )
+    client.username_pw_set(username, password)
+
+    ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
+    ctx.load_verify_locations(ca_path)
+    client.tls_set_context(ctx)
+
+    return client, ca_path
+
+
+def _connect_and_wait(client: mqtt.Client, timeout: float = 5) -> None:
+    """Connect to the MQTT broker and block until connected."""
+    client.connect(MQTT_HOST, MQTT_PORT, keepalive=10)
+    client.loop_start()
+    deadline = time.time() + timeout
+    while not client.is_connected() and time.time() < deadline:
+        time.sleep(0.05)
+    if not client.is_connected():
+        raise ConnectionError("Failed to connect to MQTT broker.")
+
+
+def _build_command_payload(device_sn: str, action_id: int, body: dict[str, object] | str) -> str:
+    """Build the JSON command payload for MQTT publish."""
+    ts = int(time.time() * 1000)
+    return json.dumps(
+        {
+            "deviceSn": device_sn,
+            "id": ts,
+            "version": 0,
+            "messageType": "DevicePropertyChange",
+            "actionId": action_id,
+            "timestamp": ts,
+            "body": body,
+        },
+        separators=(",", ":"),
+    )
+
+
+def _publish_command(creds: dict[str, object], action_id: int, body: dict[str, object]) -> None:
+    """Connect to the MQTT broker and publish a device command."""
+    user_id = creds["userId"]
+    device_sn = str(creds["deviceSn"])
+    topic = f"hb/app/{user_id}/command"
+    payload = _build_command_payload(device_sn, action_id, body)
+
+    client, ca_path = _make_mqtt_client(creds)
+    try:
+        _connect_and_wait(client)
+        info = client.publish(topic, payload, qos=1)
+        info.wait_for_publish(timeout=5)
+        client.disconnect()
+        client.loop_stop()
+    finally:
+        os.unlink(ca_path)
+
+
+def _publish_and_wait(
+    creds: dict[str, object],
+    action_id: int,
+    body: dict[str, object],
+    timeout: float = 10,
+    verbose: bool = False,
+) -> dict[str, object] | None:
+    """Publish a command and wait for a DevicePropertyChange response."""
+    user_id = creds["userId"]
+    device_sn = str(creds["deviceSn"])
+    cmd_topic = f"hb/app/{user_id}/command"
+    dev_topic = f"hb/app/{user_id}/device"
+    payload = _build_command_payload(device_sn, action_id, body)
+
+    result: dict[str, object] | None = None
+    done = False
+
+    def on_connect(
+        client: mqtt.Client,
+        _ud: object,
+        _flags: object,
+        rc: int,
+        _props: object = None,
+    ) -> None:
+        if rc == 0:
+            client.subscribe(dev_topic, qos=1)
+
+    def on_message(
+        client: mqtt.Client,
+        _ud: object,
+        msg: mqtt.MQTTMessage,
+    ) -> None:
+        nonlocal result, done
+        try:
+            data = json.loads(msg.payload)
+        except json.JSONDecodeError:
+            return
+        if data.get("deviceSn") != device_sn:
+            return
+        msg_type = data.get("messageType", "")
+        if msg_type == "DevicePropertyChange" and isinstance(data.get("body"), dict):
+            resp_body = data["body"]
+            if list(resp_body.keys()) == ["messageId"]:
+                return
+            result = data
+            done = True
+
+    client, ca_path = _make_mqtt_client(creds)
+    client.on_connect = on_connect
+    client.on_message = on_message
+    try:
+        _connect_and_wait(client)
+        time.sleep(0.2)
+        client.publish(cmd_topic, payload, qos=1)
+        deadline = time.time() + timeout
+        while not done and time.time() < deadline:
+            time.sleep(0.1)
+        client.disconnect()
+        client.loop_stop()
+    finally:
+        os.unlink(ca_path)
+
+    return result

socketry/properties.py

@@ -0,0 +1,161 @@
+"""Device property definitions — single source of truth for Jackery protocol keys."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+@dataclass
+class Setting:
+    """A device property definition.
+
+    Maps between raw protocol keys (e.g. ``oac``), CLI-friendly slugs
+    (e.g. ``ac``), and human-readable labels (e.g. ``AC output``).
+    """
+
+    id: str
+    """Raw key from the API (``oac``, ``rb``, ``sltb``)."""
+
+    slug: str
+    """CLI name (``ac``, ``battery``, ``screen-timeout``)."""
+
+    name: str
+    """Human-readable label."""
+
+    group: str
+    """Display group (``battery``, ``io``, ``settings``, ``power``, ``other``)."""
+
+    action_id: int | None = None
+    """MQTT action ID; ``None`` = read-only."""
+
+    values: list[str] | None = None
+    """Enum values (index = int value); ``None`` = integer."""
+
+    unit: str = ""
+    """Suffix for display (``%``, ``W``, ``Hz``, ``C``, ``h``)."""
+
+    scale: float = 1.0
+    """Divide raw value by this for display."""
+
+    decimals: int = 1
+    """Decimal places when *scale* != 1."""
+
+    write_id: str | None = None
+    """Override property key for MQTT writes (e.g. ``slt`` for ``sltb``)."""
+
+    @property
+    def writable(self) -> bool:
+        """Whether this property can be set via MQTT."""
+        return self.action_id is not None
+
+    @property
+    def prop_key(self) -> str:
+        """The property key to use in MQTT command bodies."""
+        return self.write_id or self.id
+
+    def format_value(self, raw: object) -> str:
+        """Format a raw property value for human display."""
+        if self.values is not None:
+            try:
+                idx = int(str(raw))
+                if 0 <= idx < len(self.values):
+                    label: str = self.values[idx]
+                    if set(self.values) == {"on", "off"}:
+                        return label.upper()
+                    return label
+            except (ValueError, TypeError):
+                pass
+            return str(raw)
+        if isinstance(raw, (int, float)):
+            if self.unit == "h" and raw == 0:
+                return "--"
+            if self.scale != 1:
+                return f"{raw / self.scale:.{self.decimals}f}{self.unit}"
+            if self.unit:
+                return f"{raw}{self.unit}"
+        return str(raw)
+
+
+# Model code -> human-readable name (from ha/c.java)
+MODEL_NAMES: dict[int, str] = {
+    1: "Explorer 3000 Pro",
+    2: "Explorer 2000 Plus",
+    4: "Explorer 300 Plus",
+    5: "Explorer 1000 Plus",
+    6: "Explorer 700 Plus",
+    7: "Explorer 280 Plus",
+    8: "Explorer 1000 Pro2",
+    9: "Explorer 600 Plus",
+    10: "Explorer 240",
+    12: "Explorer 2000",
+}
+
+GROUP_TITLES: dict[str, str] = {
+    "battery": "Battery & Power",
+    "io": "I/O State",
+    "settings": "Settings",
+    "power": "AC / Power Detail",
+    "other": "Other",
+}
+
+
+PROPERTIES: list[Setting] = [
+    # Battery & Power
+    Setting("rb", "battery", "Battery", "battery", unit="%"),
+    Setting("bt", "battery-temp", "Battery temp", "battery", unit="C", scale=10),
+    Setting("bs", "battery-state", "Battery state", "battery"),
+    Setting("ip", "input-power", "Input power", "battery", unit="W"),
+    Setting("op", "output-power", "Output power", "battery", unit="W"),
+    Setting("it", "input-time", "Input time remaining", "battery", unit="h", scale=10),
+    Setting("ot", "output-time", "Output time remaining", "battery", unit="h", scale=10),
+    # I/O State
+    Setting("oac", "ac", "AC output", "io", action_id=4, values=["off", "on"]),
+    Setting("odc", "dc", "DC output", "io", action_id=1, values=["off", "on"]),
+    Setting("odcu", "usb", "USB output", "io", action_id=2, values=["off", "on"]),
+    Setting("odcc", "car", "Car output", "io", action_id=3, values=["off", "on"]),
+    Setting("iac", "ac-in", "AC input", "io", action_id=5, values=["off", "on"]),
+    Setting("idc", "dc-in", "DC input", "io", action_id=6, values=["off", "on"]),
+    Setting("lm", "light", "Light mode", "io", action_id=7, values=["off", "low", "high", "sos"]),
+    Setting("wss", "wireless", "Wireless charging", "io", values=["off", "on"]),
+    # Settings
+    Setting(
+        "cs", "charge-speed", "Charge speed", "settings", action_id=10, values=["fast", "mute"]
+    ),
+    Setting("ast", "auto-shutdown", "Auto shutdown", "settings", action_id=9),
+    Setting("pm", "energy-saving", "Energy saving", "settings", action_id=12),
+    Setting(
+        "lps",
+        "battery-protection",
+        "Battery protection",
+        "settings",
+        action_id=11,
+        values=["full", "eco"],
+    ),
+    Setting("sfc", "sfc", "Super fast charge", "settings", action_id=13, values=["off", "on"]),
+    Setting("ups", "ups", "UPS mode", "settings", action_id=14, values=["off", "on"]),
+    Setting("sltb", "screen-timeout", "Screen timeout", "settings", action_id=8, write_id="slt"),
+    # AC / Power Detail
+    Setting("acip", "ac-input-power", "AC input power", "power", unit="W"),
+    Setting("cip", "car-input-power", "Car input power", "power", unit="W"),
+    Setting("acov", "ac-voltage", "AC output voltage", "power", unit="V", scale=10, decimals=0),
+    Setting("acohz", "ac-freq", "AC output freq", "power", unit="Hz"),
+    Setting("acps", "ac-power", "AC power", "power", unit="W"),
+    Setting("acpss", "ac-power-2", "AC power (secondary)", "power", unit="W"),
+    Setting("acpsp", "ac-socket-power", "AC socket power", "power", unit="W"),
+    # Other / Alarms
+    Setting("ec", "error-code", "Error code", "other"),
+    Setting("ta", "temp-alarm", "Temp alarm", "other"),
+    Setting("pal", "power-alarm", "Power alarm", "other"),
+    Setting("pmb", "power-mode-battery", "Power mode battery", "other"),
+    Setting("tt", "total-temp", "Total temp", "other"),
+    Setting("ss", "system-status", "System status", "other"),
+    Setting("pc", "power-capacity", "Power capacity", "other"),
+]
+
+_by_slug: dict[str, Setting] = {s.slug: s for s in PROPERTIES}
+_by_id: dict[str, Setting] = {s.id: s for s in PROPERTIES}
+
+
+def resolve(name: str) -> Setting | None:
+    """Look up a Setting by slug or raw property key."""
+    return _by_slug.get(name) or _by_id.get(name)

socketry-0.1.0.dist-info/METADATA

@@ -0,0 +1,213 @@
+Metadata-Version: 2.4
+Name: socketry
+Version: 0.1.0
+Summary: Python API and CLI for controlling Jackery portable power stations
+Author: Jesus Lopez
+Author-email: Jesus Lopez <jesus@jesusla.com>
+License-Expression: MIT
+Requires-Dist: typer>=0.9
+Requires-Dist: paho-mqtt>=2.0
+Requires-Dist: requests>=2.31
+Requires-Dist: pycryptodome>=3.19
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+
+# socketry
+
+[![CI](https://github.com/jlopez/socketry/actions/workflows/ci.yml/badge.svg)](https://github.com/jlopez/socketry/actions/workflows/ci.yml)
+![Python](https://img.shields.io/badge/python-3.11%20%7C%203.12%20%7C%203.13-blue)
+
+Python API and CLI for controlling Jackery portable power stations.
+
+Reverse-engineered from the Jackery Android APK (v1.0.7) and iOS app (v1.2.0).
+Communicates via Jackery's cloud MQTT broker and HTTP API — no modifications to
+the device or its firmware.
+
+## Quick start
+
+```bash
+uvx --from git+https://github.com/jlopez/socketry socketry login --email you@example.com --password 'yourpass'
+uvx --from git+https://github.com/jlopez/socketry socketry get
+```
+
+Or install it once and use `socketry` directly:
+
+```bash
+uv tool install git+https://github.com/jlopez/socketry
+socketry login --email you@example.com --password 'yourpass'
+socketry get
+```
+
+## Supported devices
+
+All 10 models in the current Jackery app share the same protocol:
+
+| Model | Code |
+|-------|------|
+| Explorer 3000 Pro | 1 |
+| Explorer 2000 Plus | 2 |
+| Explorer 300 Plus | 4 |
+| Explorer 1000 Plus | 5 |
+| Explorer 700 Plus | 6 |
+| Explorer 280 Plus | 7 |
+| Explorer 1000 Pro2 | 8 |
+| Explorer 600 Plus | 9 |
+| Explorer 240 | 10 |
+| Explorer 2000 | 12 |
+
+Properties and MQTT action IDs are exhaustive for this APK version. Unknown
+properties returned by newer firmware are displayed as raw key/value pairs.
+
+## Install
+
+```bash
+# Install as a CLI tool (from GitHub)
+uv tool install git+https://github.com/jlopez/socketry
+
+# Or from PyPI (once published)
+uv tool install socketry
+
+# Or install as a library
+pip install socketry
+```
+
+## CLI usage
+
+### Login
+
+```bash
+# Authenticates and discovers all devices (owned + shared with you)
+socketry login --email you@example.com --password 'yourpass'
+
+# List devices and select the active one
+socketry devices
+socketry select 0
+```
+
+Credentials are saved to `~/.config/socketry/credentials.json` (mode 0600).
+
+### Reading properties (`get`)
+
+```bash
+# All properties (colored + grouped on a TTY)
+socketry get
+
+# Single property — by CLI name or raw protocol key
+socketry get battery          # Battery: 85%
+socketry get rb               # Battery: 85% (same thing)
+socketry get ac               # AC output: ON
+
+# JSON output (indented on TTY, compact when piped)
+socketry get --json
+socketry get ac --json        # {"oac": 1}
+socketry get --json | jq .rb  # pipe-friendly
+```
+
+Available properties:
+
+| Group | Names |
+|-------|-------|
+| Battery & Power | `battery`, `battery-temp`, `battery-state`, `input-power`, `output-power`, `input-time`, `output-time` |
+| I/O State | `ac`, `dc`, `usb`, `car`, `ac-in`, `dc-in`, `light`, `wireless` |
+| Settings | `charge-speed`, `auto-shutdown`, `energy-saving`, `battery-protection`, `sfc`, `ups`, `screen-timeout` |
+| AC / Power Detail | `ac-input-power`, `car-input-power`, `ac-voltage`, `ac-freq`, `ac-power`, `ac-power-2`, `ac-socket-power` |
+| Other / Alarms | `error-code`, `temp-alarm`, `power-alarm`, `power-mode-battery`, `total-temp`, `system-status`, `power-capacity` |
+
+Raw protocol keys (`rb`, `oac`, `bt`, ...) are also accepted.
+
+### Changing settings (`set`)
+
+```bash
+# I/O toggles
+socketry set ac on
+socketry set dc off
+socketry set usb on
+socketry set car off
+
+# Light
+socketry set light high       # off | low | high | sos
+
+# Device settings
+socketry set charge-speed mute      # fast | mute
+socketry set battery-protection eco # full | eco
+socketry set ups on
+socketry set sfc on
+
+# Integer settings
+socketry set screen-timeout 30
+socketry set auto-shutdown 60
+socketry set energy-saving 30
+
+# Wait for device confirmation
+socketry set ac on --wait
+
+# Show available settings
+socketry set
+socketry set light            # "expects a value: off | low | high | sos"
+```
+
+Writable settings:
+
+| Setting | Values | Description |
+|---------|--------|-------------|
+| `ac` | on / off | AC output |
+| `dc` | on / off | DC output |
+| `usb` | on / off | USB output |
+| `car` | on / off | Car (12V) output |
+| `ac-in` | on / off | AC input |
+| `dc-in` | on / off | DC input |
+| `light` | off / low / high / sos | Light mode |
+| `screen-timeout` | integer | Screen timeout |
+| `auto-shutdown` | integer | Auto shutdown timer |
+| `charge-speed` | fast / mute | Charge speed mode |
+| `battery-protection` | full / eco | Battery protection level |
+| `energy-saving` | integer | Energy saving timeout |
+| `sfc` | on / off | Super fast charge |
+| `ups` | on / off | UPS mode |
+
+## Library usage
+
+```python
+from socketry import Client
+
+# Authenticate (or load saved credentials)
+client = Client.login("email@example.com", "password")
+client.save_credentials()
+
+# Or load previously saved credentials
+client = Client.from_saved()
+
+# List and select devices
+devices = client.fetch_devices()
+client.select_device(0)
+
+# Read properties
+props = client.get_all_properties()
+setting, value = client.get_property("battery")
+print(f"{setting.name}: {setting.format_value(value)}")
+
+# Control
+client.set_property("ac", "on")
+result = client.set_property("light", "high", wait=True)
+```
+
+## How it works
+
+```
+socketry ──HTTP──> iot.jackeryapp.com    (login, device list, properties)
+socketry ──MQTT──> emqx.jackeryapp.com  (device control via encrypted TLS)
+```
+
+Login uses AES-192/ECB + RSA-1024 encrypted HTTP POST. Device control commands
+are published over MQTT (TLS 1.2 with a self-signed CA). Status polling uses the
+HTTP property endpoint. See [docs/protocol.md](docs/protocol.md) for the full
+protocol specification.
+
+## Roadmap
+
+- [ ] MQTT real-time monitor (subscribe to live property changes)
+- [ ] Token auto-refresh (JWT expires ~30 days)
+
+## License
+
+MIT

socketry-0.1.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+socketry/__init__.py,sha256=49C2S5Yg06VgoISgCM4fkXHAL1DVIVNfkvuh7fpo_mE,237
+socketry/__main__.py,sha256=Xbzkpml_p65fp0cPshuA4gKjSllCRpKcSm6q1oK1XPc,86
+socketry/_constants.py,sha256=KqJEn9Ft-nwPQLyIqTW2At5fiItLkZmFcpG90Z4EsjY,2170
+socketry/_crypto.py,sha256=4xs1PEWHKtO3mWNAB3ZLvMWpNO2S55Ow66MMt04s8Wo,1796
+socketry/cli.py,sha256=AoQs33nxEaTYxQSgyEN8vznJSBrYRMFt1OrH6cvMuBw,9199
+socketry/client.py,sha256=gIEya-FfMoRtfsbm1eF8VDhDdPHhedloD51okVmB9II,17210
+socketry/properties.py,sha256=y2BRw4mT2l--uCtgt0IpkVoD1Deoc0kfVa25VUlPuSI,6158
+socketry/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+socketry-0.1.0.dist-info/WHEEL,sha256=iHtWm8nRfs0VRdCYVXocAWFW8ppjHL-uTJkAdZJKOBM,80
+socketry-0.1.0.dist-info/entry_points.txt,sha256=1ZOtKJ-ufHKUk3qc_LuB_57u0-yV2dE9eCB0j3DOF_E,47
+socketry-0.1.0.dist-info/METADATA,sha256=Lk0uCs9hKAhqyAEF4HImT8bTE8CW1ZNTo4mb5dnzaFI,6080
+socketry-0.1.0.dist-info/RECORD,,

socketry-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: uv 0.9.30
+Root-Is-Purelib: true
+Tag: py3-none-any

socketry-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+socketry = socketry.cli:app
+