customrp-cli 0.1.1__py3-none-any.whl

customrp_cli/messages.py

@@ -0,0 +1,66 @@
+"""User-facing text, kept in one place so it's easy to review (and to translate, should that ever happen).
+
+Messages from customrp-core (validation, presets, connection errors) are passed through as they are.
+"""
+
+# --- Config file -----------------------------------------------------------------
+
+CONFIG_MISSING = "No config file at {path}. Create one with: customrp-cli init"
+CONFIG_UNREADABLE = "Can't read {path}: {reason}"
+CONFIG_NOT_UTF8 = "{path} isn't a UTF-8 text file"
+CONFIG_BAD_TOML = "{path} isn't valid TOML: {reason}"
+CONFIG_EXISTS = "{path} already exists. Use --force to overwrite it."
+CONFIG_WRITTEN = "Wrote {path}"
+CONFIG_INVALID = "The config file has errors:"
+
+UNKNOWN_OPTION = "unknown option"
+DID_YOU_MEAN = " (did you mean '{suggestion}'?)"
+EXPECTED_TYPE = "expected {expected}, got {actual}"
+EXPECTED_CHOICE = "{value!r} isn't one of: {choices}"
+AT_LEAST = "must be at least {minimum}"
+TOO_MANY_BUTTONS = "Discord shows at most 2 buttons; {count} are set"
+NEEDS_TIME = "needs a time as well as a date, like {example}"
+BAD_DATETIME = "{value!r} isn't a date and time, like {example}"
+PIPE_HINT = '"auto" or a number from 0 to 9'
+
+TYPE_NAMES = {
+    str: "a string", bool: "true or false", int: "a whole number", float: "a number", dict: "a table",
+    list: "an array",
+}
+
+# --- Commands --------------------------------------------------------------------
+
+CHECK_OK = "No problems found in {path}"
+CHECK_SUMMARY = "{errors} error(s), {warnings} warning(s) in {path}"
+ERROR_PREFIX = "error"
+WARNING_PREFIX = "warning"
+
+ALREADY_RUNNING = "customrp-cli is already running (PID {pid}). Stop it with: customrp-cli stop"
+NOT_RUNNING = "customrp-cli isn't running"
+RUNNING = "customrp-cli is running (PID {pid})"
+STATUS_STATE = "  State: {state}{detail}"
+STATUS_USER = "  Discord user: {user}"
+STATUS_CONFIG = "  Config: {path}"
+STATUS_SINCE = "  Running since: {since}"
+STOP_SENT = "Asked customrp-cli (PID {pid}) to stop"
+STOPPED = "Stopped"
+STOP_TIMEOUT = "customrp-cli (PID {pid}) didn't stop within {timeout} seconds"
+
+PRESET_IMPORTED = "Imported {preset} into {path}"
+PRESET_EXPORTED = "Exported the presence from {path} to {preset}"
+PRESET_KEPT_SETTINGS = "Kept the [connection], [run] and [logging] settings from the existing file"
+FILE_EXISTS = "{path} already exists. Use --force to overwrite it."
+CANT_WRITE = "Can't write {path}: {reason}"
+
+ASSETS_NONE = "Application {app_id} has no art assets"
+ASSETS_HEADER = "Art assets of application {app_id}:"
+ASSETS_PAGE = "Manage them at {url}"
+
+# --- Running ---------------------------------------------------------------------
+
+RUN_STARTING = "Starting customrp-cli {version} with {path}"
+RUN_STOPPED = "Stopped"
+RUN_GAVE_UP = "Gave up connecting to Discord. Is the Discord desktop app running?"
+RUN_RELOADED = "Reloaded {path}"
+RUN_RELOAD_FAILED = "Not reloading {path}, it has errors:"
+RUN_RESTART_NEEDED = "Changes to [connection] and [logging] take effect after a restart"

customrp_cli/paths.py

@@ -0,0 +1,44 @@
+"""Where the config file and runtime files live on each platform."""
+
+from __future__ import annotations
+
+import os
+import sys
+from pathlib import Path
+
+APP_DIR_NAME = "customrp-cli"
+CONFIG_FILE_NAME = "config.toml"
+
+#: Overrides the config file location (the -c option still wins)
+CONFIG_ENV = "CUSTOMRP_CLI_CONFIG"
+#: Overrides the directory for the lock, PID and status files
+STATE_ENV = "CUSTOMRP_CLI_STATE_DIR"
+
+
+def _env_dir(name: str, fallback: Path) -> Path:
+    value = os.environ.get(name)
+    return Path(value) if value else fallback
+
+
+def config_dir() -> Path:
+    if sys.platform == "win32":
+        return _env_dir("APPDATA", Path.home() / "AppData" / "Roaming") / APP_DIR_NAME
+    if sys.platform == "darwin":
+        return Path.home() / "Library" / "Application Support" / APP_DIR_NAME
+    return _env_dir("XDG_CONFIG_HOME", Path.home() / ".config") / APP_DIR_NAME
+
+
+def state_dir() -> Path:
+    override = os.environ.get(STATE_ENV)
+    if override:
+        return Path(override)
+    if sys.platform == "win32":
+        return _env_dir("LOCALAPPDATA", Path.home() / "AppData" / "Local") / APP_DIR_NAME
+    if sys.platform == "darwin":
+        return Path.home() / "Library" / "Application Support" / APP_DIR_NAME
+    return _env_dir("XDG_STATE_HOME", Path.home() / ".local" / "state") / APP_DIR_NAME
+
+
+def default_config_path() -> Path:
+    override = os.environ.get(CONFIG_ENV)
+    return Path(override) if override else config_dir() / CONFIG_FILE_NAME

customrp_cli/runner.py

@@ -0,0 +1,175 @@
+"""The ``run`` command: show the presence until asked to stop."""
+
+from __future__ import annotations
+
+import logging
+import os
+import signal
+import threading
+from datetime import datetime
+from pathlib import Path
+
+from customrp_core import PresenceSession, SessionState, display_name
+
+from . import __version__, messages as msg
+from .config import Config, ConfigError, load_config
+from .instance import Instance
+
+log = logging.getLogger("customrp_cli")
+
+EXIT_OK = 0
+EXIT_FAILED = 1
+
+# How often to check for stop requests and config changes, in seconds
+TICK = 0.5
+
+
+class ConfigWatcher:
+    """Notices when the config file changes, once it has stopped changing (editors save in steps)."""
+
+    def __init__(self, path: Path):
+        self.path = path
+        self._loaded = self._signature()
+        self._pending = None
+
+    def _signature(self):
+        try:
+            stat = self.path.stat()
+            return stat.st_mtime_ns, stat.st_size
+        except OSError:
+            return None
+
+    def changed(self) -> bool:
+        current = self._signature()
+        if current == self._loaded or current is None:
+            self._pending = None
+            return False
+        if current != self._pending:
+            self._pending = current  # Wait one more tick to see that it has settled
+            return False
+        self._loaded = current
+        self._pending = None
+        return True
+
+    def mark_loaded(self):
+        self._loaded = self._signature()
+        self._pending = None
+
+
+def _log_problems(problems):
+    for problem in problems:
+        if problem.is_error:
+            log.error("%s", problem)
+        else:
+            log.warning("%s", problem)
+
+
+class Runner:
+    def __init__(self, config: Config, instance: Instance, *, watch: bool):
+        self.config = config
+        self.instance = instance
+        self.watch = watch and config.watch_config and config.path is not None
+        self.stop_event = threading.Event()
+        self.reload_event = threading.Event()
+        self.started = datetime.now().astimezone()
+        self.session = PresenceSession(
+            config.presence, pipe=config.pipe, retry_interval=config.retry_interval,
+            max_retries=config.max_retries, proxy_discord_cdn=config.proxy_discord_cdn,
+            on_state_change=self._state_changed)
+
+    def _state_changed(self, state: SessionState, message: str | None):
+        # The library logs connection problems itself; this only records the state for "status"
+        user = self.session.user
+        self.instance.write_status({
+            "pid": os.getpid(),
+            "state": state.value,
+            "message": message,
+            "user": display_name(user) if user else None,
+            "config": str(self.config.path) if self.config.path else None,
+            "started": self.started.isoformat(timespec="seconds"),
+            "updated": datetime.now().astimezone().isoformat(timespec="seconds"),
+        })
+
+    def _install_signal_handlers(self):
+        previous = {}
+
+        def stop(signum, frame):
+            self.stop_event.set()
+
+        def reload(signum, frame):
+            self.reload_event.set()
+
+        # SIGINT stays as KeyboardInterrupt. SIGTERM is what service managers send;
+        # SIGBREAK is Ctrl+Break on Windows; SIGHUP traditionally means "reload".
+        for name, handler in (("SIGTERM", stop), ("SIGBREAK", stop), ("SIGHUP", reload)):
+            signum = getattr(signal, name, None)
+            if signum is not None:
+                try:
+                    previous[signum] = signal.signal(signum, handler)
+                except (ValueError, OSError):  # Not on the main thread, or not supported
+                    pass
+        return previous
+
+    def _reload(self, watcher: ConfigWatcher | None):
+        path = self.config.path
+        if watcher:
+            watcher.mark_loaded()
+        try:
+            new = load_config(path)
+        except ConfigError as e:
+            log.error(msg.RUN_RELOAD_FAILED.format(path=path))
+            for problem in e.problems:
+                log.error("  %s", problem)
+            return
+
+        problems = new.problems()
+        if any(p.is_error for p in problems):
+            log.error(msg.RUN_RELOAD_FAILED.format(path=path))
+            _log_problems(problems)
+            return
+
+        _log_problems(problems)
+        if not self.config.same_runtime_settings(new):
+            log.warning(msg.RUN_RESTART_NEEDED)
+        self.session.proxy_discord_cdn = new.proxy_discord_cdn
+        self.watch = self.watch and new.watch_config
+        self.config = new
+        log.info(msg.RUN_RELOADED.format(path=path))
+        self.session.update(new.presence)
+
+    def run(self) -> int:
+        previous_handlers = self._install_signal_handlers()
+        watcher = ConfigWatcher(self.config.path) if self.watch else None
+        self.session.start()
+        try:
+            while not self.session.wait(TICK):
+                if self.stop_event.is_set() or self.instance.stop_requested():
+                    break
+                if self.reload_event.is_set() or (self.watch and watcher and watcher.changed()):
+                    self.reload_event.clear()
+                    self._reload(watcher)
+        except KeyboardInterrupt:
+            pass
+        finally:
+            self.session.stop()
+            self.session.wait(5)
+            for signum, handler in previous_handlers.items():
+                signal.signal(signum, handler)
+
+        if self.session.gave_up:
+            log.error(msg.RUN_GAVE_UP)
+            return EXIT_FAILED
+        log.info(msg.RUN_STOPPED)
+        return EXIT_OK
+
+
+def run(config: Config, instance: Instance, *, watch: bool = True) -> int:
+    """Runs until stopped. The caller has already set up logging and checked the config for errors."""
+    if not instance.acquire():
+        log.error(msg.ALREADY_RUNNING.format(pid=instance.running_pid() or "unknown"))
+        return EXIT_FAILED
+    try:
+        log.info(msg.RUN_STARTING.format(version=__version__, path=config.path))
+        return Runner(config, instance, watch=watch).run()
+    finally:
+        instance.release()

customrp_cli-0.1.1.dist-info/METADATA

@@ -0,0 +1,287 @@
+Metadata-Version: 2.4
+Name: customrp-cli
+Version: 0.1.1
+Summary: Custom Discord Rich Presence from the command line, configured with a TOML file. An independent alternative to CustomRP for Linux, macOS and Windows.
+Author: KeiraOMG0
+License: MIT
+Project-URL: Homepage, https://github.com/KeiraOMG0/customrp-cli
+Project-URL: Documentation, https://github.com/KeiraOMG0/customrp-cli/tree/main/docs
+Project-URL: Issues, https://github.com/KeiraOMG0/customrp-cli/issues
+Keywords: discord,rich presence,rpc,customrp,cli
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Communications :: Chat
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: customrp-core<0.2,>=0.1.2
+Requires-Dist: tomli>=1.1; python_version < "3.11"
+Provides-Extra: test
+Requires-Dist: pytest>=7; extra == "test"
+Dynamic: license-file
+
+# customrp-cli
+
+Show a custom Discord Rich Presence ("Playing ...", with your own text, images, buttons and timer) from
+the command line, configured with a TOML file. It runs natively on **Linux**, **macOS** and **Windows**.
+
+customrp-cli is a command-line alternative to [CustomRP](https://www.customrp.xyz), the Windows app by
+maximmax42. It does what CustomRP does, minus the window. It's built on
+[customrp-core](https://github.com/KeiraOMG0/customrp-core), a library that does the heavy lifting.
+
+> **Independent project.** customrp-cli isn't made or maintained by CustomRP's developer, and isn't an
+> official replacement. Please report problems [here](https://github.com/KeiraOMG0/customrp-cli/issues),
+> not on the CustomRP repository.
+
+```console
+$ customrp-cli init
+Wrote /home/you/.config/customrp-cli/config.toml
+$ nano ~/.config/customrp-cli/config.toml
+$ customrp-cli run
+2026-01-01 12:00:00 INFO    Starting customrp-cli 0.1.0 with /home/you/.config/customrp-cli/config.toml
+2026-01-01 12:00:00 INFO    Connecting to Discord with application ID 896771305108553788
+2026-01-01 12:00:00 INFO    Connected to /run/user/1000/discord-ipc-0
+2026-01-01 12:00:00 INFO    Connected to Discord as you
+2026-01-01 12:00:00 INFO    Presence updated
+```
+
+## Why
+
+CustomRP is a Windows Forms application, so it only runs on Windows. Linux users have had to rely on Wine
+or RPC bridges. The GUI is convenient, but the useful part, telling Discord what to show, doesn't need a
+window. customrp-cli does that part natively, from a config file. That also makes it work on headless
+setups, under a service manager, and in dotfiles.
+
+## Features
+
+- Everything CustomRP can show: activity type (Playing, Listening, Watching, Competing), name, details
+  and state lines with optional links, party size, large and small images (asset names or URLs) with
+  tooltips and links, two buttons, and which field appears in the member list
+- All five CustomRP timestamp modes: since last connection, since startup, since last update, local
+  time, and custom start/end (including countdowns)
+- Live reload: save the config file and the presence updates within a second, without reconnecting
+- Checks your config the way Discord will (length limits in bytes, one-character fields, broken URLs,
+  image URLs that are too long) and names the exact option at fault
+- Waits for Discord: if Discord isn't running yet, it retries every 10 seconds, and reconnects if
+  Discord restarts
+- Imports and exports CustomRP's `.crp` presets, so you can move presets between this and the Windows app
+- Lists the art assets uploaded to your Discord application
+- One instance per user, with `status` and `stop` commands that work on every platform
+- Runs as a systemd user service, a launchd agent, or a Windows scheduled task; ready-made files are in
+  [`contrib/`](https://github.com/KeiraOMG0/customrp-cli/tree/main/contrib)
+- No GUI, no Wine, and nothing beyond Python (plus `tomli` on Python 3.9 and 3.10)
+
+## How it differs from CustomRP
+
+| CustomRP (Windows app) | customrp-cli |
+|---|---|
+| Window with text boxes and dropdowns | A TOML config file ([reference](https://github.com/KeiraOMG0/customrp-cli/blob/main/docs/configuration.md)) |
+| Click "Update presence" | Save the file; it reloads automatically |
+| Minimizes to the tray | Runs in a terminal or as a background service |
+| "Run on startup" checkbox | systemd, launchd or Task Scheduler ([guide](https://github.com/KeiraOMG0/customrp-cli/blob/main/docs/running-in-the-background.md)) |
+| Gives up after 30 attempts to reach Discord | Retries forever by default (`max_retries`) |
+| Translated into many languages | English only for now |
+| Built-in update checker | Update with `pipx upgrade customrp-cli` |
+
+More in [docs/migrating-from-customrp.md](https://github.com/KeiraOMG0/customrp-cli/blob/main/docs/migrating-from-customrp.md).
+
+## Supported systems
+
+| System | Status |
+|---|---|
+| Linux | Tests run in CI on Ubuntu, and were run on Ubuntu 24.04 (WSL), against a fake Discord over a real Unix socket, including running as a separate process. **Not yet tested against the real Discord client on Linux.** |
+| Windows 10/11 | Tests run in CI and on Windows 11 against a fake Discord over a named pipe, including background mode with `pythonw`. The underlying library has completed a handshake with the real Discord client. |
+| macOS | Tests run in CI on macOS against a fake Discord over a real Unix socket, including running as a separate process. **Not yet tested against the real Discord client on macOS**, and the launchd setup is untested. |
+
+You need:
+
+- Python 3.9 or newer
+- The Discord **desktop** app (or a client that provides Discord's IPC socket, like Vesktop) running on
+  the same computer, as the same user. The browser version can't show Rich Presence from other programs.
+
+## Installation
+
+The easiest way is [pipx](https://pipx.pypa.io), which puts customrp-cli in its own environment and
+on your `PATH`:
+
+```sh
+pipx install customrp-cli
+```
+
+Don't have pipx? It needs Python 3.11 or newer. The short version:
+
+| System | Command |
+|---|---|
+| macOS | `brew install pipx` |
+| Ubuntu, Debian | `sudo apt install pipx` |
+| Fedora | `sudo dnf install pipx` |
+| Arch | `sudo pacman -S python-pipx` |
+| Windows | `py -m pip install --user pipx` |
+
+Then run `pipx ensurepath` (on Windows: `py -m pipx ensurepath`) and open a new terminal. Step-by-step
+instructions for every system are in [docs/installation.md](https://github.com/KeiraOMG0/customrp-cli/blob/main/docs/installation.md#installing-pipx).
+
+Or with a virtual environment and `requirements.txt`:
+
+```sh
+git clone https://github.com/KeiraOMG0/customrp-cli.git
+cd customrp-cli
+python3 -m venv .venv
+source .venv/bin/activate          # Windows: .venv\Scripts\activate
+pip install -r requirements.txt    # Installs customrp-core from GitHub
+pip install .
+```
+
+Plain `pip install customrp-cli` inside a virtual environment works too.
+
+Details, including Windows notes and uninstalling, are in [docs/installation.md](https://github.com/KeiraOMG0/customrp-cli/blob/main/docs/installation.md).
+
+## Quick start
+
+```sh
+customrp-cli init       # Writes a config file with every option, then prints its path
+# Edit the file: set details, state, images, buttons...
+customrp-cli check      # Points out mistakes
+customrp-cli preview    # Shows exactly what will be sent to Discord
+customrp-cli run        # Shows the presence until you press Ctrl+C
+```
+
+To use your own application name and images, create an application in the
+[Discord Developer Portal](https://discord.com/developers/applications) and put its ID in
+`application_id`. CustomRP's [setup guide](https://docs.customrp.xyz/setting-up) walks through it.
+
+## Configuration
+
+A minimal config:
+
+```toml
+[presence]
+application_id = "123456789012345678"
+details = "Exploring the Linux desktop"
+state = "Day 3"
+timestamps = "since_startup"
+
+[presence.large_image]
+key = "penguin"               # An asset name from your application, or an image URL
+text = "Tux says hi"
+
+[[presence.buttons]]
+label = "My website"
+url = "https://example.com"
+```
+
+Every option is optional. [`examples/config.toml`](https://github.com/KeiraOMG0/customrp-cli/blob/main/examples/config.toml) is a complete, commented
+example, and [docs/configuration.md](https://github.com/KeiraOMG0/customrp-cli/blob/main/docs/configuration.md) explains each option.
+
+The config file is at:
+
+| System | Default path |
+|---|---|
+| Linux | `~/.config/customrp-cli/config.toml` (or `$XDG_CONFIG_HOME/customrp-cli/`) |
+| macOS | `~/Library/Application Support/customrp-cli/config.toml` |
+| Windows | `%APPDATA%\customrp-cli\config.toml` |
+
+Use another file with `-c path/to/file.toml`, or set `CUSTOMRP_CLI_CONFIG`.
+
+## Commands
+
+| Command | Does |
+|---|---|
+| `customrp-cli init [--force]` | Create a config file listing every option |
+| `customrp-cli check` | Check the config for mistakes (alias: `validate`) |
+| `customrp-cli preview` | Print the activity that would be sent, as JSON |
+| `customrp-cli run [--no-watch]` | Show the presence until stopped |
+| `customrp-cli status` | Show whether it's running, its connection state and Discord user |
+| `customrp-cli stop` | Stop the running instance |
+| `customrp-cli import FILE.crp [--force]` | Replace the presence in the config with a CustomRP preset |
+| `customrp-cli export FILE.crp [--force]` | Save the configured presence as a CustomRP preset |
+| `customrp-cli assets [--application-id ID]` | List the images uploaded to your Discord application |
+| `customrp-cli paths` | Show where the config and runtime files are |
+
+Options for every command: `-c/--config FILE`, `-v/--verbose` (debug output), `-q/--quiet` (errors
+only), `-h/--help`, plus `-V/--version`. Exit codes and more examples are in
+[docs/commands.md](https://github.com/KeiraOMG0/customrp-cli/blob/main/docs/commands.md).
+
+customrp-cli never asks questions or waits for input, so it's safe to use from scripts, cron and service
+managers.
+
+## Running in the background
+
+```sh
+# Linux (systemd), after installing with pipx:
+mkdir -p ~/.config/systemd/user
+curl -o ~/.config/systemd/user/customrp-cli.service \
+  https://raw.githubusercontent.com/KeiraOMG0/customrp-cli/main/contrib/systemd/customrp-cli.service
+systemctl --user daemon-reload
+systemctl --user enable --now customrp-cli
+journalctl --user -u customrp-cli -f     # Watch the log
+```
+
+macOS (launchd) and Windows (Task Scheduler) are covered in
+[docs/running-in-the-background.md](https://github.com/KeiraOMG0/customrp-cli/blob/main/docs/running-in-the-background.md).
+
+## Logging and troubleshooting
+
+`run` logs to the terminal (stderr). Add `-v` to see every message exchanged with Discord, or set
+`[logging] file` to also log to a file (rotated at 1 MB).
+
+| Problem | Try |
+|---|---|
+| `Couldn't find a running Discord client` | Start the Discord desktop app. With Flatpak or Snap, see [troubleshooting](https://github.com/KeiraOMG0/customrp-cli/blob/main/docs/troubleshooting.md#discord-isnt-found). |
+| `Discord returned an error (4000): Invalid Client ID` | `application_id` is wrong |
+| Runs fine but nothing shows on your profile | In Discord: User Settings → Activity Privacy → turn on sharing your activity |
+| `already running` | `customrp-cli status`, then `customrp-cli stop` |
+
+More in [docs/troubleshooting.md](https://github.com/KeiraOMG0/customrp-cli/blob/main/docs/troubleshooting.md).
+
+## Known limitations
+
+- English only.
+- Only the presence settings are shared with CustomRP, through `.crp` presets; CustomRP's own settings
+  file isn't read.
+- One instance per user. Showing two presences at once isn't supported.
+- Discord's socket locations for Flatpak, Snap and Vesktop come from other Rich Presence projects and
+  haven't been verified here.
+- Changes to `[connection]` and `[logging]` need a restart; `[presence]` changes apply live.
+
+## Documentation
+
+[docs/](https://github.com/KeiraOMG0/customrp-cli/blob/main/docs/index.md): [installation](https://github.com/KeiraOMG0/customrp-cli/blob/main/docs/installation.md) · [configuration](https://github.com/KeiraOMG0/customrp-cli/blob/main/docs/configuration.md) ·
+[commands](https://github.com/KeiraOMG0/customrp-cli/blob/main/docs/commands.md) · [background](https://github.com/KeiraOMG0/customrp-cli/blob/main/docs/running-in-the-background.md) ·
+[troubleshooting](https://github.com/KeiraOMG0/customrp-cli/blob/main/docs/troubleshooting.md) · [migrating from CustomRP](https://github.com/KeiraOMG0/customrp-cli/blob/main/docs/migrating-from-customrp.md) ·
+[design](https://github.com/KeiraOMG0/customrp-cli/blob/main/docs/design.md) · [development](https://github.com/KeiraOMG0/customrp-cli/blob/main/docs/development.md)
+
+## Running the tests
+
+```sh
+pip install -e ".[test]"
+pytest
+```
+
+The tests don't need Discord; they use a fake Discord server from customrp-core. See
+[docs/development.md](https://github.com/KeiraOMG0/customrp-cli/blob/main/docs/development.md).
+
+## Contributing
+
+Issues and pull requests are welcome. Please:
+
+- open an issue first for anything big
+- add tests for behaviour changes (`pytest` must pass)
+- keep it small: no new dependencies or abstractions without a concrete need
+- put changes to how presences work in [customrp-core](https://github.com/KeiraOMG0/customrp-core),
+  and changes to the command line, config and running in this repository
+
+## Credits
+
+- [CustomRP](https://github.com/maximmax42/Discord-CustomRP) by maximmax42 (MIT). The features, rules and
+  preset format come from it, and its developer was open to an independent alternative.
+- CustomRP's default Discord application and its image proxy (`customrp.xyz/proxy`, used for Discord-hosted
+  images) belong to CustomRP's developer.
+
+## License
+
+MIT. See [LICENSE](https://github.com/KeiraOMG0/customrp-cli/blob/main/LICENSE).

customrp_cli-0.1.1.dist-info/RECORD

@@ -0,0 +1,15 @@
+customrp_cli/__init__.py,sha256=9LemoxjFCBTWcEmSw74DNVqMREFmYSLK8a7_RdVYmuk,124
+customrp_cli/__main__.py,sha256=t2N7Y3qgy6N_RgKOdQ1xrlSVO1EnFDrHsG2XTq0_hP4,146
+customrp_cli/cli.py,sha256=tuGiRrjcYuI7TIA2IBQPmjW7TBqTqp2b3M84hegyJVM,11294
+customrp_cli/config.py,sha256=vs6miMehx9p2ZeI7h9j8K8ucJ2NoMev3w29Bn6ZJgzk,19175
+customrp_cli/instance.py,sha256=BzOQPg_yXalX9t-c9W6AmPGVlhb3HUknfpb2m5wmzHM,4382
+customrp_cli/logs.py,sha256=bKgWfumedxWWABIwGH0w2c_XBPH7CUBUFyAJpRM8HsI,1656
+customrp_cli/messages.py,sha256=dGxRVy-_9jpU9j1VV39q1-cPTA7un2GWwfDATiQBvVg,2954
+customrp_cli/paths.py,sha256=0OIeVqzNL5s_vsxmU_I1GCS0PqDmd9-3DXo0OzUsRsY,1472
+customrp_cli/runner.py,sha256=51Pmig8dCd_qwotQuddJSIg8fbzVQttnUVki4QOU6dc,6137
+customrp_cli-0.1.1.dist-info/licenses/LICENSE,sha256=g9gZVj6t0ROL4NWd7zN6OVYbdopsJm6pDruVEkTKJyU,1159
+customrp_cli-0.1.1.dist-info/METADATA,sha256=Iv2oAsxpAHTqG6lvzszXGUHLwTySti-bQo1ENzgRS1E,13923
+customrp_cli-0.1.1.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+customrp_cli-0.1.1.dist-info/entry_points.txt,sha256=jZ263Ar7gNJJTPY8Zn6Vm9eMT0Cw5JQuEnO7gxXAoGY,55
+customrp_cli-0.1.1.dist-info/top_level.txt,sha256=qCyamvoYKt4H-sM1gH9sdVyamg3K60HsHZLZfLRyYXA,13
+customrp_cli-0.1.1.dist-info/RECORD,,

customrp_cli-0.1.1.dist-info/WHEEL

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

customrp_cli-0.1.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+customrp-cli = customrp_cli.cli:main

customrp_cli-0.1.1.dist-info/licenses/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2026 KeiraOMG0
+Copyright (c) 2020-2026 maximmax42 (CustomRP, whose features and preset format this follows)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

customrp_cli-0.1.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+customrp_cli