comodor 0.19.2__tar.gz → 0.20.1__tar.gz

{comodor-0.19.2 → comodor-0.20.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: comodor
-Version: 0.19.2
+Version: 0.20.1
 Summary: Comodor — a self-improving terminal coding agent with a Rich TUI
 Project-URL: Homepage, https://comodor.ai
 Project-URL: Repository, https://github.com/ifekri/Comodor
@@ -75,7 +75,7 @@ falling or not. A number, not a claim.
 | **Never surprises you** | Reading is silent. Writing shows a diff. Commands ask. Every change is checkpointed and `/undo` puts it back. [→](docs/safety.md) |
 | **Drives a real browser** | One that runs JavaScript, keeps cookies and can log in — not a page fetcher. [→](docs/browser.md) |
 | **Uses your screen** | Mouse and keyboard in any application, with a halo showing where it is about to click before it clicks. [→](docs/computer.md) |
-| **Runs on your phone** | Telegram or WhatsApp, the whole interface as buttons, running in the background whether or not a terminal is open. Read-only until you say otherwise. [→](docs/telegram.md) · [→](docs/whatsapp.md) |
+| **Runs on your phone** | Telegram, Slack or WhatsApp — the whole interface as buttons, running in the background whether or not a terminal is open. Read-only until you say otherwise. [→](docs/telegram.md) · [→](docs/slack.md) · [→](docs/whatsapp.md) |
 | **Runs a model locally** | Pick one, watch it download, use it with the network unplugged. No key, no account. [→](docs/local-models.md) |
 | **Lives in your editor** | Speaks ACP, so VS Code, JetBrains and Zed drive it from their own panels. [→](docs/acp.md) |
 | **Follows your procedures** | Write a skill once; it loads when the work matches. 147 ready to install. [→](docs/skills.md) |
@@ -174,6 +174,7 @@ Esc        stop it                F3         cycle mode
 | [What it can do](docs/tools.md) | The 13 tools, and when it uses each |
 | [Safety and permissions](docs/safety.md) | What it asks, and what it never does |
 | [From your phone](docs/telegram.md) | The Telegram bot, and who it answers |
+| [From Slack](docs/slack.md) | Socket Mode — five minutes, and no public address |
 | [From WhatsApp](docs/whatsapp.md) | The Cloud API — longer to set up; Telegram does the same thing |
 | [Models on your machine](docs/local-models.md) | Downloading one, running it offline |
 | [Configuration](docs/configuration.md) | Every setting, and what wins |

{comodor-0.19.2 → comodor-0.20.1}/README.md

@@ -48,7 +48,7 @@ falling or not. A number, not a claim.
 | **Never surprises you** | Reading is silent. Writing shows a diff. Commands ask. Every change is checkpointed and `/undo` puts it back. [→](docs/safety.md) |
 | **Drives a real browser** | One that runs JavaScript, keeps cookies and can log in — not a page fetcher. [→](docs/browser.md) |
 | **Uses your screen** | Mouse and keyboard in any application, with a halo showing where it is about to click before it clicks. [→](docs/computer.md) |
-| **Runs on your phone** | Telegram or WhatsApp, the whole interface as buttons, running in the background whether or not a terminal is open. Read-only until you say otherwise. [→](docs/telegram.md) · [→](docs/whatsapp.md) |
+| **Runs on your phone** | Telegram, Slack or WhatsApp — the whole interface as buttons, running in the background whether or not a terminal is open. Read-only until you say otherwise. [→](docs/telegram.md) · [→](docs/slack.md) · [→](docs/whatsapp.md) |
 | **Runs a model locally** | Pick one, watch it download, use it with the network unplugged. No key, no account. [→](docs/local-models.md) |
 | **Lives in your editor** | Speaks ACP, so VS Code, JetBrains and Zed drive it from their own panels. [→](docs/acp.md) |
 | **Follows your procedures** | Write a skill once; it loads when the work matches. 147 ready to install. [→](docs/skills.md) |
@@ -147,6 +147,7 @@ Esc        stop it                F3         cycle mode
 | [What it can do](docs/tools.md) | The 13 tools, and when it uses each |
 | [Safety and permissions](docs/safety.md) | What it asks, and what it never does |
 | [From your phone](docs/telegram.md) | The Telegram bot, and who it answers |
+| [From Slack](docs/slack.md) | Socket Mode — five minutes, and no public address |
 | [From WhatsApp](docs/whatsapp.md) | The Cloud API — longer to set up; Telegram does the same thing |
 | [Models on your machine](docs/local-models.md) | Downloading one, running it offline |
 | [Configuration](docs/configuration.md) | Every setting, and what wins |

{comodor-0.19.2 → comodor-0.20.1}/docs/README.md

@@ -42,6 +42,7 @@ ends with the agent doing something useful.
 | | |
 |---|---|
 | [From your phone](telegram.md) | The Telegram bot: pairing, the buttons, and who it answers |
+| [From Slack](slack.md) | Socket Mode — five minutes, no public address, and it answers in threads |
 | [From WhatsApp](whatsapp.md) | The Cloud API — about twenty minutes and technical. Telegram does the same in one |
 | [Models on your machine](local-models.md) | Downloading one, running it offline, adding to the list |
 | [Questions](questions.md) | The form it puts up when a request reads two ways |

{comodor-0.19.2 → comodor-0.20.1}/src/comodor/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.19.2'
-__version_tuple__ = version_tuple = (0, 19, 2)
+__version__ = version = '0.20.1'
+__version_tuple__ = version_tuple = (0, 20, 1)
 
 __commit_id__ = commit_id = None

{comodor-0.19.2 → comodor-0.20.1}/src/comodor/browser/cdp.py

@@ -24,17 +24,16 @@ Two things about the protocol that are easy to get wrong:
 
 from __future__ import annotations
 
-import base64
 import json
-import os
-import socket
-import struct
 import threading
 import time
 import urllib.error
 import urllib.request
 from typing import Any, Callable
 
+from ..net.ws import WebSocket as _WebSocket
+from ..net.ws import WebSocketError
+
 DEFAULT_TIMEOUT = 30.0
 #: Long enough for a slow page on a slow machine, short enough that a hung
 #: renderer does not hold the turn until the agent's own deadline.
@@ -50,135 +49,34 @@ class BrowserError(RuntimeError):
 # --------------------------------------------------------------------------- #
 
 
-class WebSocket:
-    """RFC 6455, client side, and only the parts CDP uses.
+class WebSocket(_WebSocket):
+    """The general client, with the browser's vocabulary on its failures.
 
-    No extensions, no compression, no continuation frames on send: CDP sends
-    JSON text and so do we. Fragmented *incoming* frames are reassembled,
-    because a large accessibility tree arrives in pieces.
+    The frame handling moved to `net.ws` when Slack's Socket Mode became a
+    second caller for it. This keeps the errors saying "the browser", because
+    everything above catches `BrowserError` and a person reading a traceback
+    about a websocket is a person who has to work out which websocket.
     """
 
     def __init__(self, url: str, timeout: float = DEFAULT_TIMEOUT) -> None:
-        _, _, rest = url.partition("://")
-        hostport, _, path = rest.partition("/")
-        host, _, port = hostport.partition(":")
         try:
-            self._socket = socket.create_connection((host, int(port or 80)),
-                                                    timeout=timeout)
-        except OSError as error:
-            raise BrowserError(f"could not connect to the browser: {error}") from error
-        self._socket.settimeout(timeout)
-
-        key = base64.b64encode(os.urandom(16)).decode()
-        self._socket.sendall(
-            f"GET /{path} HTTP/1.1\r\n"
-            f"Host: {hostport}\r\n"
-            f"Upgrade: websocket\r\n"
-            f"Connection: Upgrade\r\n"
-            f"Sec-WebSocket-Key: {key}\r\n"
-            f"Sec-WebSocket-Version: 13\r\n\r\n".encode())
-
-        header = b""
-        while b"\r\n\r\n" not in header:
-            chunk = self._socket.recv(1)
-            if not chunk:
-                raise BrowserError("the browser closed the connection during the handshake")
-            header += chunk
-            if len(header) > 8192:
-                raise BrowserError("the browser sent a handshake we cannot read")
-        if b" 101" not in header.split(b"\r\n")[0]:
-            raise BrowserError(f"the browser refused the upgrade: "
-                               f"{header.split(chr(13).encode())[0][:80]!r}")
-        self._buffer = b""
-        self._send_lock = threading.Lock()
-
-    # -- frames ------------------------------------------------------------ #
+            super().__init__(url, timeout=timeout)
+        except WebSocketError as error:
+            raise BrowserError(
+                f"could not connect to the browser: {error}") from error
 
     def send(self, text: str) -> None:
-        payload = text.encode()
-        frame = bytearray([0x81])                 # FIN + text
-        length = len(payload)
-        if length < 126:
-            frame.append(0x80 | length)
-        elif length < 65536:
-            frame.append(0x80 | 126)
-            frame += struct.pack(">H", length)
-        else:
-            frame.append(0x80 | 127)
-            frame += struct.pack(">Q", length)
-        # A client must mask; a server must not. Chrome enforces both.
-        mask = os.urandom(4)
-        frame += mask
-        frame += bytes(byte ^ mask[index % 4] for index, byte in enumerate(payload))
-        with self._send_lock:
-            try:
-                self._socket.sendall(bytes(frame))
-            except OSError as error:
-                raise BrowserError(f"the browser went away: {error}") from error
+        try:
+            super().send(text)
+        except WebSocketError as error:
+            raise BrowserError(f"the browser went away: {error}") from error
 
     def receive(self) -> str:
-        """One complete message, reassembled if it arrived in fragments."""
-        parts: list[bytes] = []
-        while True:
-            first, second = self._exactly(2)
-            final = bool(first & 0x80)
-            opcode = first & 0x0F
-            length = second & 0x7F
-            if length == 126:
-                length = struct.unpack(">H", self._exactly(2))[0]
-            elif length == 127:
-                length = struct.unpack(">Q", self._exactly(8))[0]
-            mask = self._exactly(4) if second & 0x80 else b""
-            payload = self._exactly(length)
-            if mask:
-                payload = bytes(byte ^ mask[index % 4]
-                                for index, byte in enumerate(payload))
-
-            if opcode == 0x8:                     # close
-                raise BrowserError("the browser closed the connection")
-            if opcode == 0x9:                     # ping -> pong
-                self._pong(payload)
-                continue
-            if opcode == 0xA:                     # pong
-                continue
-
-            parts.append(payload)
-            if final:
-                return b"".join(parts).decode("utf-8", "replace")
-
-    def _pong(self, payload: bytes) -> None:
-        frame = bytearray([0x8A, 0x80 | len(payload)])
-        mask = os.urandom(4)
-        frame += mask
-        frame += bytes(byte ^ mask[index % 4] for index, byte in enumerate(payload))
-        with self._send_lock:
-            try:
-                self._socket.sendall(bytes(frame))
-            except OSError:
-                pass
-
-    def _exactly(self, count: int) -> bytes:
-        while len(self._buffer) < count:
-            try:
-                chunk = self._socket.recv(65536)
-            except socket.timeout as error:
-                raise BrowserError("the browser stopped answering") from error
-            except OSError as error:
-                raise BrowserError(f"the browser went away: {error}") from error
-            if not chunk:
-                raise BrowserError("the browser closed the connection")
-            self._buffer += chunk
-        taken, self._buffer = self._buffer[:count], self._buffer[count:]
-        return taken
-
-    def settimeout(self, timeout: float) -> None:
-        self._socket.settimeout(timeout)
-
-    def close(self) -> None:
         try:
-            self._socket.close()
-        except OSError:
-            pass
+            return super().receive()
+        except WebSocketError as error:
+            raise BrowserError(
+                f"the browser closed the connection: {error}") from error
 
 
 # --------------------------------------------------------------------------- #

{comodor-0.19.2 → comodor-0.20.1}/src/comodor/channels/__init__.py

@@ -65,9 +65,25 @@ def _whatsapp_ready(settings: Any) -> tuple[bool, str]:
     return True, ""
 
 
+def _slack_ready(settings: Any) -> tuple[bool, str]:
+    if not settings.bot_token:
+        return False, ("Not connected. `comodor slack connect` sets up the "
+                       "workspace and the two tokens.")
+    if not settings.app_token:
+        return False, ("No app-level token, so Socket Mode cannot open — "
+                       "`comodor slack connect --app-token xapp-…`")
+    if not settings.allowed:
+        return False, ("Nobody is paired, so it would answer nobody. "
+                       "`comodor slack pair` first.")
+    return True, ""
+
+
 TELEGRAM = Channel(name="telegram", label="Telegram", section="telegram",
                    ready=_telegram_ready)
 WHATSAPP = Channel(name="whatsapp", label="WhatsApp", section="whatsapp",
                    ready=_whatsapp_ready)
 
-CHANNELS = (TELEGRAM, WHATSAPP)
+SLACK = Channel(name="slack", label="Slack", section="slack",
+                ready=_slack_ready)
+
+CHANNELS = (TELEGRAM, WHATSAPP, SLACK)

comodor-0.20.1/src/comodor/channels/markdown.py

@@ -0,0 +1,322 @@
+"""The model writes Markdown. None of these three chat apps reads Markdown.
+
+Every one of them was being handed the model's answer as-is, so a reply that
+said
+
+    Use **`Path.resolve()`** — see [the docs](https://docs.python.org/3/).
+
+arrived on somebody's phone as exactly that, asterisks and brackets and all.
+A person reading that does not think "the renderer is wrong"; they think the
+tool is sloppy, and a code fence full of backticks is worse — it is the part of
+an answer that most needs to be set apart, and it was the part that looked most
+broken.
+
+So the answer is converted, once, into whatever the destination actually
+speaks. Three targets and no two of them agree:
+
+    Telegram    HTML: <b>, <i>, <code>, <pre>, <a href>, <blockquote>
+    Slack       mrkdwn: *bold*, _italic_, `code`, <url|text>
+    WhatsApp    *bold*, _italic_, ```mono```, and no link markup at all
+
+**Order is the whole of the correctness here.** Code comes out first and is
+replaced by a sentinel, so that an asterisk inside a shell command is never
+mistaken for emphasis and a `<` inside a code block is escaped as text rather
+than parsed as a tag. Everything else is done on what is left, and the code is
+put back last.
+
+Two traps this is deliberately careful about, because both produce output that
+looks *almost* right:
+
+*Underscores in identifiers.* `some_var_name` is not italics. An underscore
+only opens emphasis at a word boundary, which is why `_italic_` works and
+`snake_case_name` survives.
+
+*Unmatched markers.* A lone `**` from a truncated stream is left as text rather
+than swallowing the rest of the message into bold.
+"""
+
+from __future__ import annotations
+
+import html
+import re
+from dataclasses import dataclass
+
+#: The one character that may not appear in model output, used to seal a
+#: rendered piece so no later pass can read it as markup.
+NUL = chr(0)
+
+#: Sentinels for the parts that must not be touched by anything else. Control
+#: characters, because no model output contains them and no regex below can
+#: match one by accident.
+CODE_MARK = "\x00c{}\x00"
+BLOCK_MARK = "\x00b{}\x00"
+
+FENCE = re.compile(r"```([A-Za-z0-9_+-]*)[ \t]*\r?\n(.*?)```", re.S)
+#: A fence with nothing after it — a stream that stopped mid-block.
+OPEN_FENCE = re.compile(r"```([A-Za-z0-9_+-]*)[ \t]*\r?\n(.*)\Z", re.S)
+INLINE_CODE = re.compile(r"`([^`\n]+)`")
+
+LINK = re.compile(r"\[([^\]\n]+)\]\(\s*<?([^)\s>]+)>?\s*\)")
+BOLD = re.compile(r"\*\*(?!\s)(.+?)(?<!\s)\*\*", re.S)
+BOLD_ALT = re.compile(r"(?<![\w*])__(?!\s)(.+?)(?<!\s)__(?![\w*])", re.S)
+ITALIC = re.compile(r"(?<![\w*])\*(?!\s)([^*\n]+?)(?<!\s)\*(?![\w*])")
+ITALIC_ALT = re.compile(r"(?<![\w_])_(?!\s)([^_\n]+?)(?<!\s)_(?![\w_])")
+STRIKE = re.compile(r"~~(?!\s)(.+?)(?<!\s)~~", re.S)
+
+HEADING = re.compile(r"^\s{0,3}(#{1,6})\s+(.*?)\s*#*\s*$")
+BULLET = re.compile(r"^(\s*)[-*+]\s+(.*)$")
+NUMBERED = re.compile(r"^(\s*)(\d{1,3})[.)]\s+(.*)$")
+QUOTE = re.compile(r"^\s{0,3}>\s?(.*)$")
+RULE = re.compile(r"^\s{0,3}([-*_])\s*(?:\1\s*){2,}$")
+
+#: What a horizontal rule becomes. A row of box drawing rather than three
+#: hyphens, which every one of these apps renders as three hyphens.
+RULE_LINE = "─" * 24
+
+
+@dataclass(frozen=True)
+class Flavour:
+    """One destination's idea of markup."""
+
+    name: str
+    bold: tuple[str, str]
+    italic: tuple[str, str]
+    strike: tuple[str, str]
+    code: tuple[str, str]
+    #: Given (language, body) return the whole block.
+    block: object
+    #: Given (text, href) return the link.
+    link: object
+    #: Given the line's text return a quoted line.
+    quote: object
+    #: How to make text safe in this flavour.
+    escape: object
+    bullet: str = "• "
+    #: Whether emphasis may wrap a code span. WhatsApp's only
+    #: monospace is a triple backtick, and `*```x```*` renders
+    #: as neither bold nor code.
+    nest_code: bool = True
+
+
+def _html_escape(text: str) -> str:
+    return html.escape(text or "", quote=False)
+
+
+def _slack_escape(text: str) -> str:
+    """Only the three Slack reads as markup in ordinary text.
+
+    Not the asterisks and underscores: those are what this module is putting
+    in, deliberately.
+    """
+    return (text.replace("&", "&amp;").replace("<", "&lt;")
+                .replace(">", "&gt;"))
+
+
+def _plain(text: str) -> str:
+    return text or ""
+
+
+TELEGRAM = Flavour(
+    name="telegram",
+    bold=("<b>", "</b>"),
+    italic=("<i>", "</i>"),
+    strike=("<s>", "</s>"),
+    code=("<code>", "</code>"),
+    block=lambda language, body: (
+        f'<pre><code class="language-{language}">{body}</code></pre>'
+        if language else f"<pre>{body}</pre>"),
+    link=lambda text, href: f'<a href="{href}">{text}</a>',
+    quote=lambda text: f"<blockquote>{text}</blockquote>",
+    escape=_html_escape,
+)
+
+SLACK = Flavour(
+    name="slack",
+    bold=("*", "*"),
+    italic=("_", "_"),
+    strike=("~", "~"),
+    code=("`", "`"),
+    block=lambda language, body: f"```\n{body}\n```",
+    link=lambda text, href: f"<{href}|{text}>",
+    # A raw `>`: `&gt;` renders as the character and makes no
+    # blockquote, which is the whole point of the line.
+    quote=lambda text: f"> {text}",
+    escape=_slack_escape,
+)
+
+WHATSAPP = Flavour(
+    name="whatsapp",
+    bold=("*", "*"),
+    italic=("_", "_"),
+    strike=("~", "~"),
+    # WhatsApp has no single-backtick span. Three is what it understands, and
+    # it renders inline as monospace, which is what was wanted.
+    code=("```", "```"),
+    block=lambda language, body: f"```\n{body}\n```",
+    # No link markup at all: WhatsApp finds URLs on its own. So the label is
+    # kept and the address follows it, rather than one of them being lost.
+    link=lambda text, href: (href if text.strip() == href.strip()
+                             else f"{text} ({href})"),
+    quote=lambda text: f"> {text}",
+    escape=_plain,
+    nest_code=False,
+)
+
+FLAVOURS = {f.name: f for f in (TELEGRAM, SLACK, WHATSAPP)}
+
+
+def render(text: str, flavour: Flavour) -> str:
+    """The model's Markdown, in the markup this destination understands."""
+    if not text:
+        return ""
+
+    blocks: list[str] = []
+    text = _lift_blocks(text, blocks, flavour)
+
+    lines = [_line(line, flavour) for line in text.replace("\r\n", "\n").split("\n")]
+    out = "\n".join(lines)
+
+    # The code goes back last, so nothing above could have touched it.
+    for index, body in enumerate(blocks):
+        out = out.replace(BLOCK_MARK.format(index), body)
+    return out
+
+
+def _lift_blocks(text: str, blocks: list[str], flavour: Flavour) -> str:
+    """Pull fenced code out and leave a sentinel where each was."""
+
+    def take(match: re.Match) -> str:
+        language = (match.group(1) or "").strip()
+        body = match.group(2)
+        if body.endswith("\n"):
+            body = body[:-1]
+        blocks.append(flavour.block(language, flavour.escape(body)))
+        return BLOCK_MARK.format(len(blocks) - 1)
+
+    text = FENCE.sub(take, text)
+    # A stream cut off mid-block still has to render as code rather than as a
+    # row of backticks followed by the rest of the answer in italics.
+    return OPEN_FENCE.sub(take, text)
+
+
+def _line(line: str, flavour: Flavour) -> str:
+    """One line, as whatever kind of line it is."""
+    if BLOCK_MARK.format(0)[0] in line and line.strip().startswith("\x00"):
+        return line                                   # a lifted code block
+    if not line.strip():
+        return ""
+
+    if RULE.match(line):
+        return RULE_LINE
+
+    heading = HEADING.match(line)
+    if heading:
+        # None of the three has headings. Bold is what a heading is for.
+        return _apply(flavour.bold, _inline(heading.group(2), flavour))
+
+    quoted = QUOTE.match(line)
+    if quoted:
+        return flavour.quote(_inline(quoted.group(1), flavour))
+
+    bullet = BULLET.match(line)
+    if bullet:
+        indent = " " * len(bullet.group(1))
+        return f"{indent}{flavour.bullet}{_inline(bullet.group(2), flavour)}"
+
+    numbered = NUMBERED.match(line)
+    if numbered:
+        indent = " " * len(numbered.group(1))
+        return (f"{indent}{numbered.group(2)}. "
+                f"{_inline(numbered.group(3), flavour)}")
+
+    return _inline(line, flavour)
+
+
+def _apply(pair: tuple[str, str], text: str) -> str:
+    return f"{pair[0]}{text}{pair[1]}"
+
+
+def _inline(text: str, flavour: Flavour) -> str:
+    """Everything that happens inside one line.
+
+    Every replacement is sealed behind a sentinel as it is made, and they are
+    all put back at the end. Without that, the later passes read the earlier
+    ones: on Slack and WhatsApp bold emits `*`, so running italic afterwards
+    matched every bold word and turned it italic instead.
+    """
+    spans: list[str] = []
+
+    def seal(rendered: str) -> str:
+        spans.append(rendered)
+        return CODE_MARK.format(len(spans) - 1)
+
+    text = INLINE_CODE.sub(
+        lambda m: seal(_apply(flavour.code, flavour.escape(m.group(1)))), text)
+    text = flavour.escape(text)
+
+    # Links before emphasis: a URL can hold underscores and a title can hold
+    # asterisks, and neither of those is markup.
+    text = LINK.sub(
+        lambda m: seal(flavour.link(_open(m.group(1), spans), m.group(2))),
+        text)
+
+    text = BOLD.sub(lambda m: seal(_emphasis(flavour, "bold", m.group(1),
+                                             spans)), text)
+    text = BOLD_ALT.sub(lambda m: seal(_emphasis(flavour, "bold", m.group(1),
+                                                 spans)), text)
+    text = STRIKE.sub(lambda m: seal(_apply(flavour.strike, m.group(1))), text)
+    text = ITALIC.sub(lambda m: seal(_emphasis(flavour, "italic", m.group(1),
+                                               spans)), text)
+    text = ITALIC_ALT.sub(lambda m: seal(_emphasis(flavour, "italic",
+                                                   m.group(1), spans)), text)
+
+    return _unseal(text, spans)
+
+
+def _emphasis(flavour: Flavour, kind: str, inner: str,
+              spans: list[str]) -> str:
+    """Emphasis around some text, or around a code span.
+
+    A flavour that cannot nest the two gets the code alone: on WhatsApp the
+    only monospace is a triple backtick, and `*```x```*` renders as neither
+    bold nor code.
+    """
+    if not flavour.nest_code and _is_only_code(inner, spans, flavour):
+        return inner
+    pair = flavour.bold if kind == "bold" else flavour.italic
+    return _apply(pair, inner)
+
+
+def _is_only_code(inner: str, spans: list[str], flavour: Flavour) -> bool:
+    match = re.fullmatch(NUL + r"c(\d+)" + NUL, inner)
+    if not match:
+        return False
+    span = spans[int(match.group(1))]
+    return span.startswith(flavour.code[0])
+
+
+def _open(text: str, spans: list[str]) -> str:
+    """A link's own label, with any sentinels inside it restored."""
+    return _unseal(text, spans)
+
+
+def _unseal(text: str, spans: list[str]) -> str:
+    """Put every sealed piece back, including ones nested inside others."""
+    for _ in range(6):
+        if NUL not in text:
+            break
+        for index in range(len(spans) - 1, -1, -1):
+            text = text.replace(CODE_MARK.format(index), spans[index])
+    return text
+
+
+def to_telegram(text: str) -> str:
+    return render(text, TELEGRAM)
+
+
+def to_slack(text: str) -> str:
+    return render(text, SLACK)
+
+
+def to_whatsapp(text: str) -> str:
+    return render(text, WHATSAPP)

{comodor-0.19.2 → comodor-0.20.1}/src/comodor/cli.py

@@ -104,6 +104,7 @@ def build_parser() -> argparse.ArgumentParser:
     from .local.commands import register as register_local
     from .mcp.commands import register as register_mcp
     from .skills.commands import register as register_skills
+    from .slack.commands import register as register_slack
     from .telegram.commands import register as register_telegram
     from .web.commands import register as register_web
     from .whatsapp.commands import register as register_whatsapp
@@ -112,6 +113,7 @@ def build_parser() -> argparse.ArgumentParser:
     register_local(sub)
     register_telegram(sub)
     register_whatsapp(sub)
+    register_slack(sub)
     register_skills(sub)
     register_web(sub)
     register_acp(sub)
@@ -828,6 +830,10 @@ def main(argv: list[str] | None = None) -> int:
         from .whatsapp.commands import run as run_whatsapp
 
         return run_whatsapp(config, args)
+    if args.command == "slack":
+        from .slack.commands import run as run_slack
+
+        return run_slack(config, args)
     if args.command == "skills":
         from .skills.commands import run as run_skills