tetherly 0.1.0__py3-none-any.whl

tetherly/__init__.py

@@ -0,0 +1 @@
+"""tetherly package."""

tetherly/authz.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+import discord
+
+
+@dataclass(frozen=True)
+class AccessController:
+    allowed_guild_ids: set[int]
+    allowed_role_ids: set[int]
+    allowed_user_ids: set[int]
+
+    def is_allowed_user(self, guild_id: int | None, user: object) -> bool:
+        if self.allowed_guild_ids and guild_id not in self.allowed_guild_ids:
+            return False
+        user_id = getattr(user, "id", None)
+        if user_id in self.allowed_user_ids:
+            return True
+        if not self.allowed_role_ids:
+            return user_id in self.allowed_user_ids
+        if isinstance(user, discord.Member):
+            role_ids = {role.id for role in user.roles}
+            return bool(role_ids & self.allowed_role_ids)
+        return False
+
+    def is_allowed(self, interaction: discord.Interaction) -> bool:
+        return self.is_allowed_user(interaction.guild_id, interaction.user)
+
+    async def assert_allowed(self, interaction: discord.Interaction) -> bool:
+        if self.is_allowed(interaction):
+            return True
+        await interaction.response.send_message(
+            "You are not allowed to use this command.",
+            ephemeral=True,
+        )
+        return False

tetherly/config.py

@@ -0,0 +1,83 @@
+from __future__ import annotations
+
+import logging
+import os
+from dataclasses import dataclass
+from pathlib import Path
+
+
+USER_CONFIG_DIR = Path.home() / ".tetherly"
+USER_ENV_PATH = USER_CONFIG_DIR / ".env"
+USER_STATE_PATH = USER_CONFIG_DIR / "state.json"
+
+
+def _load_env_file(path: Path) -> None:
+    if not path.exists():
+        return
+    for raw_line in path.read_text().splitlines():
+        line = raw_line.strip()
+        if not line or line.startswith("#"):
+            continue
+        if line.startswith("export "):
+            line = line[len("export ") :]
+        if "=" not in line:
+            continue
+        key, value = line.split("=", 1)
+        key = key.strip()
+        value = value.strip().strip("'").strip('"')
+        os.environ.setdefault(key, value)
+
+
+def load_dotenv(path: str = ".env") -> None:
+    _load_env_file(Path(path))
+    _load_env_file(USER_ENV_PATH)
+
+
+def _parse_id_set(raw: str | None) -> set[int]:
+    if not raw:
+        return set()
+    values: set[int] = set()
+    for chunk in raw.split(","):
+        chunk = chunk.strip()
+        if not chunk:
+            continue
+        values.add(int(chunk))
+    return values
+
+
+@dataclass(frozen=True)
+class Config:
+    discord_bot_token: str
+    state_path: Path
+    allowed_guild_ids: set[int]
+    allowed_role_ids: set[int]
+    allowed_user_ids: set[int]
+    test_guild_id: int | None = None
+    default_tail_lines: int = 40
+    max_tail_lines: int = 200
+    log_level: str = "INFO"
+    command_prefix: str = "/"
+
+    @classmethod
+    def from_env(cls) -> "Config":
+        token = os.environ["DISCORD_BOT_TOKEN"].strip()
+        state_path = Path(os.environ.get("TETHERLY_STATE_PATH", str(USER_STATE_PATH)))
+        return cls(
+            discord_bot_token=token,
+            state_path=state_path,
+            allowed_guild_ids=_parse_id_set(os.environ.get("TETHERLY_ALLOWED_GUILD_IDS")),
+            allowed_role_ids=_parse_id_set(os.environ.get("TETHERLY_ALLOWED_ROLE_IDS")),
+            allowed_user_ids=_parse_id_set(os.environ.get("TETHERLY_ALLOWED_USER_IDS")),
+            test_guild_id=int(os.environ["TETHERLY_TEST_GUILD_ID"])
+            if os.environ.get("TETHERLY_TEST_GUILD_ID")
+            else None,
+            default_tail_lines=int(os.environ.get("TETHERLY_DEFAULT_TAIL_LINES", "40")),
+            max_tail_lines=int(os.environ.get("TETHERLY_MAX_TAIL_LINES", "200")),
+            log_level=os.environ.get("TETHERLY_LOG_LEVEL", "INFO").upper(),
+        )
+
+    def configure_logging(self) -> None:
+        logging.basicConfig(
+            level=getattr(logging, self.log_level, logging.INFO),
+            format="%(asctime)s %(levelname)s %(name)s %(message)s",
+        )

tetherly/discord_bot.py

@@ -0,0 +1,283 @@
+from __future__ import annotations
+
+import logging
+
+import discord
+from discord import app_commands
+
+from tetherly.authz import AccessController
+from tetherly.config import Config
+from tetherly.session_registry import SessionRegistry, SessionRegistryError
+from tetherly.tmux_service import TmuxError, TmuxService, normalize_session_name
+
+LOGGER = logging.getLogger(__name__)
+AUTO_SEND_MAX_LENGTH = 4000
+
+
+def _render_code_block(text: str) -> str:
+    stripped = text.strip()
+    if not stripped:
+        return "```text\n<empty>\n```"
+    return f"```text\n{stripped[:1800]}\n```"
+
+
+def _extract_auto_send_text(message: discord.Message) -> str | None:
+    if message.author.bot or message.webhook_id is not None:
+        return None
+    if message.guild is None or isinstance(message.channel, discord.Thread):
+        return None
+    if message.type is not discord.MessageType.default:
+        return None
+    if message.reference is not None or message.attachments:
+        return None
+    content = message.content.strip()
+    if not content or content.startswith("/") or len(content) > AUTO_SEND_MAX_LENGTH:
+        return None
+    return content
+
+
+class TetherlyBot(discord.Client):
+    def __init__(
+        self,
+        *,
+        config: Config,
+        registry: SessionRegistry,
+        tmux_service: TmuxService,
+        access_controller: AccessController,
+    ) -> None:
+        intents = discord.Intents.default()
+        intents.message_content = True
+        super().__init__(intents=intents)
+        self.config = config
+        self.registry = registry
+        self.tmux_service = tmux_service
+        self.access_controller = access_controller
+        self.tree = app_commands.CommandTree(self)
+
+    async def setup_hook(self) -> None:
+        self._register_commands()
+        if self.config.test_guild_id is not None:
+            guild = discord.Object(id=self.config.test_guild_id)
+            self.tree.copy_global_to(guild=guild)
+            await self.tree.sync(guild=guild)
+            LOGGER.info("synced commands to guild %s", self.config.test_guild_id)
+            return
+        await self.tree.sync()
+
+    async def on_ready(self) -> None:
+        LOGGER.info("bot ready as %s", self.user)
+
+    async def on_message(self, message: discord.Message) -> None:
+        if message.guild is None:
+            return
+        binding = self.registry.get(message.channel.id)
+        if binding is None or not binding.auto_send:
+            return
+        if not self.access_controller.is_allowed_user(message.guild.id, message.author):
+            return
+        content = _extract_auto_send_text(message)
+        if content is None:
+            return
+        try:
+            self.tmux_service.send_text(binding.session_name, content, press_enter=True)
+        except TmuxError as exc:
+            LOGGER.warning(
+                "auto-send failed for channel %s session %s: %s",
+                binding.channel_id,
+                binding.session_name,
+                exc,
+            )
+            return
+        self.registry.touch(binding.channel_id)
+
+    def _register_commands(self) -> None:
+        @self.tree.command(name="bind", description="Bind this Discord channel to a tmux session.")
+        @app_commands.describe(session="tmux session name")
+        async def bind(interaction: discord.Interaction, session: str) -> None:
+            if not await self.access_controller.assert_allowed(interaction):
+                return
+            if interaction.guild_id is None or interaction.channel_id is None:
+                await interaction.response.send_message(
+                    "This command can only be used inside a guild channel.",
+                    ephemeral=True,
+                )
+                return
+            try:
+                session_name = normalize_session_name(session)
+            except ValueError as exc:
+                await interaction.response.send_message(str(exc), ephemeral=True)
+                return
+            created = self.tmux_service.ensure_session(session_name)
+            self.tmux_service.set_session_environment(
+                session_name,
+                "TETHERLY_SESSION",
+                session_name,
+            )
+            self.tmux_service.set_session_environment(
+                session_name,
+                "TETHERLY_NOTIFY_ON_FINISH",
+                "1",
+            )
+            try:
+                binding = self.registry.bind(
+                    guild_id=interaction.guild_id,
+                    channel_id=interaction.channel_id,
+                    session_name=session_name,
+                    bound_by=interaction.user.id,
+                )
+            except SessionRegistryError as exc:
+                await interaction.response.send_message(str(exc), ephemeral=True)
+                return
+            verb = "Created and bound" if created else "Bound"
+            await interaction.response.send_message(
+                f"{verb} channel <#{binding.channel_id}> to tmux session `{binding.session_name}`.",
+                ephemeral=True,
+            )
+
+        @self.tree.command(
+            name="config",
+            description="Configure channel behavior for the bound tmux session.",
+        )
+        @app_commands.describe(auto_send="forward plain text messages without using /send")
+        async def config(interaction: discord.Interaction, auto_send: bool) -> None:
+            if not await self.access_controller.assert_allowed(interaction):
+                return
+            binding = self.registry.get(interaction.channel_id)
+            if binding is None:
+                await interaction.response.send_message(
+                    "This channel is not bound. Run `/bind session:<name>` first.",
+                    ephemeral=True,
+                )
+                return
+            updated = self.registry.set_auto_send(interaction.channel_id, auto_send)
+            status = "enabled" if auto_send else "disabled"
+            await interaction.response.send_message(
+                f"Auto-send {status} for `{updated.session_name}`.",
+                ephemeral=True,
+            )
+
+        @self.tree.command(name="send", description="Send text into the bound tmux session and press Enter.")
+        @app_commands.describe(text="text to send")
+        async def send(interaction: discord.Interaction, text: str) -> None:
+            if not await self.access_controller.assert_allowed(interaction):
+                return
+            binding = self.registry.get(interaction.channel_id)
+            if binding is None:
+                await interaction.response.send_message(
+                    "This channel is not bound. Run `/bind session:<name>` first.",
+                    ephemeral=True,
+                )
+                return
+            try:
+                self.tmux_service.send_text(binding.session_name, text, press_enter=True)
+            except TmuxError as exc:
+                await interaction.response.send_message(
+                    f"Failed to send to `{binding.session_name}`: {exc}",
+                    ephemeral=True,
+                )
+                return
+            self.registry.touch(interaction.channel_id)
+            await interaction.response.send_message(
+                f"Sent to `{binding.session_name}`.",
+                ephemeral=True,
+            )
+
+        @self.tree.command(name="key", description="Send a special key into the bound tmux session.")
+        @app_commands.describe(key="special key to send")
+        @app_commands.choices(
+            key=[
+                app_commands.Choice(name="Enter", value="enter"),
+                app_commands.Choice(name="Escape", value="esc"),
+                app_commands.Choice(name="Ctrl-C", value="ctrl-c"),
+                app_commands.Choice(name="Ctrl-D", value="ctrl-d"),
+                app_commands.Choice(name="Tab", value="tab"),
+                app_commands.Choice(name="Up", value="up"),
+                app_commands.Choice(name="Down", value="down"),
+                app_commands.Choice(name="Left", value="left"),
+                app_commands.Choice(name="Right", value="right"),
+            ]
+        )
+        async def key(interaction: discord.Interaction, key: app_commands.Choice[str]) -> None:
+            if not await self.access_controller.assert_allowed(interaction):
+                return
+            binding = self.registry.get(interaction.channel_id)
+            if binding is None:
+                await interaction.response.send_message(
+                    "This channel is not bound. Run `/bind session:<name>` first.",
+                    ephemeral=True,
+                )
+                return
+            try:
+                self.tmux_service.send_key(binding.session_name, key.value)
+            except TmuxError as exc:
+                await interaction.response.send_message(
+                    f"Failed to send `{key.name}` to `{binding.session_name}`: {exc}",
+                    ephemeral=True,
+                )
+                return
+            self.registry.touch(interaction.channel_id)
+            await interaction.response.send_message(
+                f"Sent `{key.name}` to `{binding.session_name}`.",
+                ephemeral=True,
+            )
+
+        @self.tree.command(name="tail", description="Show recent output from the bound tmux session.")
+        @app_commands.describe(lines="number of lines to fetch")
+        async def tail(interaction: discord.Interaction, lines: int | None = None) -> None:
+            if not await self.access_controller.assert_allowed(interaction):
+                return
+            binding = self.registry.get(interaction.channel_id)
+            if binding is None:
+                await interaction.response.send_message(
+                    "This channel is not bound. Run `/bind session:<name>` first.",
+                    ephemeral=True,
+                )
+                return
+            requested = lines or self.config.default_tail_lines
+            capped = min(max(1, requested), self.config.max_tail_lines)
+            try:
+                output = self.tmux_service.capture_tail(binding.session_name, capped)
+            except TmuxError as exc:
+                await interaction.response.send_message(
+                    f"Failed to capture `{binding.session_name}`: {exc}",
+                    ephemeral=True,
+                )
+                return
+            self.registry.touch(interaction.channel_id)
+            await interaction.response.send_message(
+                f"Recent output from `{binding.session_name}` ({capped} lines max)\n{_render_code_block(output)}",
+                ephemeral=True,
+            )
+
+        @self.tree.command(name="status", description="Show binding and tmux session status for this channel.")
+        async def status(interaction: discord.Interaction) -> None:
+            if not await self.access_controller.assert_allowed(interaction):
+                return
+            binding = self.registry.get(interaction.channel_id)
+            if binding is None:
+                await interaction.response.send_message(
+                    "This channel is not bound.",
+                    ephemeral=True,
+                )
+                return
+            tmux_status = self.tmux_service.get_status(binding.session_name)
+            if tmux_status.exists:
+                headline = f"🟢 Active — tmux session `{binding.session_name}` is alive"
+            else:
+                headline = (
+                    f"🔴 tmux session `{binding.session_name}` is GONE — "
+                    "run `/bind session:<name>` to reconnect"
+                )
+            await interaction.response.send_message(
+                "\n".join(
+                    [
+                        headline,
+                        f"Channel: <#{binding.channel_id}>",
+                        f"Auto-send: `{binding.auto_send}`",
+                        f"Bound by: <@{binding.bound_by}>",
+                        f"Bound at: `{binding.bound_at}`",
+                        f"Last used at: `{binding.last_used_at}`",
+                    ]
+                ),
+                ephemeral=True,
+            )

tetherly/discord_sender.py

@@ -0,0 +1,93 @@
+from __future__ import annotations
+
+import asyncio
+from dataclasses import dataclass
+
+from tetherly.config import Config
+from tetherly.session_registry import SessionRegistry
+
+DISCORD_MESSAGE_LIMIT = 2000
+
+
+class DiscordSendError(RuntimeError):
+    pass
+
+
+@dataclass(frozen=True)
+class SendResult:
+    channel_id: int
+    session_name: str
+    chunks_sent: int
+
+
+def split_message(text: str, limit: int = DISCORD_MESSAGE_LIMIT) -> list[str]:
+    normalized = text.strip()
+    if not normalized:
+        raise DiscordSendError("message is empty")
+    chunks: list[str] = []
+    remaining = normalized
+    while remaining:
+        if len(remaining) <= limit:
+            chunks.append(remaining)
+            break
+        split_at = remaining.rfind("\n", 0, limit)
+        if split_at <= 0:
+            split_at = limit
+        chunks.append(remaining[:split_at].rstrip())
+        remaining = remaining[split_at:].lstrip("\n")
+    return chunks
+
+
+async def _post_message(token: str, channel_id: int, content: str) -> None:
+    import aiohttp
+
+    url = f"https://discord.com/api/v10/channels/{channel_id}/messages"
+    headers = {
+        "Authorization": f"Bot {token}",
+        "Content-Type": "application/json",
+    }
+    async with aiohttp.ClientSession(headers=headers) as session:
+        async with session.post(url, json={"content": content}) as response:
+            if response.status >= 400:
+                body = await response.text()
+                raise DiscordSendError(
+                    f"discord send failed with status {response.status}: {body}"
+                )
+
+
+async def send_to_session_async(
+    *,
+    config: Config,
+    registry: SessionRegistry,
+    session_name: str,
+    message: str,
+) -> SendResult:
+    binding = registry.get_by_session_name(session_name)
+    if binding is None:
+        raise DiscordSendError(f"no bound Discord channel for session {session_name!r}")
+    chunks = split_message(message)
+    for chunk in chunks:
+        await _post_message(config.discord_bot_token, binding.channel_id, chunk)
+    registry.touch(binding.channel_id)
+    return SendResult(
+        channel_id=binding.channel_id,
+        session_name=session_name,
+        chunks_sent=len(chunks),
+    )
+
+
+def send_to_session(
+    *,
+    config: Config,
+    registry: SessionRegistry,
+    session_name: str,
+    message: str,
+) -> SendResult:
+    return asyncio.run(
+        send_to_session_async(
+            config=config,
+            registry=registry,
+            session_name=session_name,
+            message=message,
+        )
+    )