@openhands/extensions 0.4.2 → 0.6.0

package/skills/slack-channel-monitor/scripts/main.py

@@ -9,7 +9,8 @@ trigger phrase is detected it:
   3. Posts a reply in the Slack thread with a link to the conversation.
 
 On subsequent runs:
-  - New replies in a tracked thread are forwarded to the running conversation.
+  - New replies in a tracked thread are forwarded only when they contain the
+    trigger phrase.
   - When the conversation reaches a terminal/idle state the agent's final
     response (or an error notice) is posted back to the Slack thread.
 
@@ -39,11 +40,10 @@ import urllib.request
 from datetime import datetime, timezone
 from urllib.parse import urlencode
 
-# ── Debug logging to a persistent file ────────────────────────────────────────
+# ── Debug logging to a per-run file ───────────────────────────────────────────
 _DEBUG_LOG_PATH = os.path.join(
-    os.path.dirname(os.path.dirname(os.path.abspath(
-        os.environ.get("WORKSPACE_BASE", "/tmp")))),
-    "automation-state", "slack_poller_debug.log",
+    os.environ.get("WORKSPACE_BASE", "/tmp"),
+    "slack_poller_debug.log",
 )
 os.makedirs(os.path.dirname(_DEBUG_LOG_PATH), exist_ok=True)
 _debug_log_fh = open(_DEBUG_LOG_PATH, "a")
@@ -85,6 +85,18 @@ CONTEXT_MESSAGE_LIMIT = 15
 # How far back (seconds) to look for context when creating a new conversation.
 CONTEXT_LOOKBACK_SECONDS = 3600  # 1 hour of recent messages for context
 
+# Keep completed conversations available for triggered follow-up replies for a
+# short inactivity window. Polling conversations.replies is intentionally throttled:
+# bot-token Slack apps may have a very small per-method quota, so each thread
+# carries its own exponential backoff and each automation run polls at most one
+# due thread. Start hot immediately after each bot reply, then back off
+# on quiet threads.
+THREAD_FOLLOWUP_WATCH_SECONDS = 300
+THREAD_REPLY_INITIAL_BACKOFF_SECONDS = 5
+THREAD_REPLY_MAX_BACKOFF_SECONDS = 300
+THREAD_REPLY_BACKOFF_MULTIPLIER = 2
+MAX_THREAD_REPLY_POLLS_PER_RUN = 1
+
 
 # ── Stdlib helpers ─────────────────────────────────────────────────────────────
 
@@ -108,6 +120,55 @@ def get_secret(name: str) -> str:
         return r.read().decode().strip()
 
 
+def _is_loopback_openhands_url(url: str) -> bool:
+    return url.startswith((
+        "http://localhost",
+        "https://localhost",
+        "http://127.0.0.1",
+        "https://127.0.0.1",
+    ))
+
+
+def _ngrok_public_openhands_url() -> str | None:
+    try:
+        with urllib.request.urlopen(
+            "http://127.0.0.1:4040/api/tunnels", timeout=2
+        ) as response:
+            tunnels = json.loads(response.read()).get("tunnels", [])
+    except Exception as exc:
+        print(f"Could not discover ngrok public URL: {exc}")
+        return None
+
+    for tunnel in tunnels:
+        public_url = str(tunnel.get("public_url", "")).rstrip("/")
+        addr = str(tunnel.get("config", {}).get("addr", ""))
+        if (
+            public_url.startswith("https://")
+            and ("localhost:8000" in addr or "127.0.0.1:8000" in addr)
+        ):
+            return public_url
+
+    for tunnel in tunnels:
+        public_url = str(tunnel.get("public_url", "")).rstrip("/")
+        if public_url.startswith("https://"):
+            return public_url
+
+    return None
+
+
+def resolve_openhands_url() -> str:
+    try:
+        configured = get_secret("OPENHANDS_URL").rstrip()
+    except Exception:
+        configured = ""
+
+    configured = (configured or DEFAULT_OPENHANDS_URL).rstrip("/")
+    if not _is_loopback_openhands_url(configured):
+        return configured
+
+    return _ngrok_public_openhands_url() or configured
+
+
 def fire_callback(
     status: str = "COMPLETED",
     error: str | None = None,
@@ -136,14 +197,47 @@ def fire_callback(
         print(f"Callback error (non-fatal): {exc}")
 
 
-# ── State management ───────────────────────────────────────────────────────────
+# ── State persistence (KV store with local-file fallback) ─────────────────────
 
-def _state_file_path() -> str:
-    """Derive a persistent storage path from WORKSPACE_BASE.
+_KV_TOKEN = os.environ.get("AUTOMATION_KV_TOKEN", "")
+_KV_BASE = os.environ.get("AUTOMATION_API_URL", "").rstrip("/")
+_STATE_KEY = "state"
 
-    WORKSPACE_BASE = {root}/automation-runs/{run_id}
-    State lives two levels up at {root}/automation-state/.
-    """
+
+def _kv_available() -> bool:
+    return bool(_KV_TOKEN and _KV_BASE)
+
+
+def _kv_get(key: str) -> dict | None:
+    req = urllib.request.Request(
+        f"{_KV_BASE}/v1/kv/{key}",
+        headers={"Authorization": f"Bearer {_KV_TOKEN}"},
+    )
+    try:
+        with urllib.request.urlopen(req) as r:
+            return json.loads(r.read())["value"]
+    except urllib.error.HTTPError as exc:
+        if exc.code == 404:
+            return None
+        raise
+
+
+def _kv_set(key: str, value: dict) -> None:
+    req = urllib.request.Request(
+        f"{_KV_BASE}/v1/kv/{key}",
+        data=json.dumps(value).encode(),
+        headers={
+            "Authorization": f"Bearer {_KV_TOKEN}",
+            "Content-Type": "application/json",
+        },
+        method="PUT",
+    )
+    with urllib.request.urlopen(req) as r:
+        r.read()
+
+
+def _state_file_path() -> str:
+    """Derive a persistent storage path from WORKSPACE_BASE (file fallback only)."""
     workspace_base = os.environ.get("WORKSPACE_BASE", "")
     event_payload = json.loads(os.environ.get("AUTOMATION_EVENT_PAYLOAD", "{}"))
     automation_id = event_payload.get("automation_id", "default")
@@ -158,22 +252,42 @@ def _state_file_path() -> str:
     return os.path.join(state_dir, f"slack_poller_{automation_id}.json")
 
 
-def load_state(path: str) -> dict:
-    if os.path.exists(path):
-        return json.load(open(path))
+def _default_state() -> dict:
     return {
         "version": 1,
         "bot_user_id": None,
-        "last_poll": {},           # channel_id → float timestamp string
-        "conversations": {},       # conv_key → ConversationRecord (see schema docs)
-        "bot_message_ts": [],      # ts strings of messages posted by this bot
-        "processed_ts": [],        # ts strings of messages already handled (dedup)
+        "last_poll": {},
+        "conversations": {},
+        "bot_message_ts": [],
+        "processed_ts": [],
     }
 
 
-def save_state(path: str, state: dict) -> None:
+def load_state() -> dict:
+    if _kv_available():
+        data = _kv_get(_STATE_KEY)
+        if data is not None:
+            print("State loaded from KV store")
+            return data
+        return _default_state()
+    path = _state_file_path()
+    if os.path.exists(path):
+        try:
+            return json.load(open(path))
+        except Exception as exc:
+            print(f"Warning: state file {path} unreadable ({exc}); starting fresh")
+    return _default_state()
+
+
+def save_state(state: dict) -> None:
+    if _kv_available():
+        _kv_set(_STATE_KEY, state)
+        print("State saved to KV store")
+        return
+    path = _state_file_path()
     with open(path, "w") as f:
         json.dump(state, f, indent=2)
+    print(f"State saved to {path}")
 
 
 # ── Slack API helpers ──────────────────────────────────────────────────────────
@@ -195,8 +309,14 @@ def _slack_call(
     }
     data = json.dumps(body).encode() if body is not None else None
     req = urllib.request.Request(url, data=data, headers=headers, method=method)
-    with urllib.request.urlopen(req) as r:
-        result = json.loads(r.read())
+    try:
+        with urllib.request.urlopen(req) as r:
+            result = json.loads(r.read())
+    except urllib.error.HTTPError as exc:
+        if exc.code == 429:
+            retry_after = exc.headers.get("Retry-After", "60")
+            raise RuntimeError(f"Slack {endpoint}: rate_limited retry_after={retry_after}") from exc
+        raise
     if not result.get("ok"):
         raise RuntimeError(f"Slack {endpoint}: {result.get('error', 'unknown_error')}")
     return result
@@ -243,7 +363,12 @@ def add_reaction(token: str, channel: str, ts: str, emoji: str = "eyes") -> None
 
 def post_message(token: str, channel: str, text: str, thread_ts: str | None = None) -> str:
     """Post a Slack message and return its timestamp."""
-    body: dict = {"channel": channel, "text": text}
+    body: dict = {
+        "channel": channel,
+        "markdown_text": text,
+        "unfurl_links": False,
+        "unfurl_media": False,
+    }
     if thread_ts:
         body["thread_ts"] = thread_ts
     return slack_post(token, "chat.postMessage", body).get("ts", "")
@@ -273,6 +398,36 @@ def thread_replies(token: str, channel: str, thread_ts: str, oldest: str) -> lis
     return [m for m in messages if m.get("ts") != thread_ts]
 
 
+def _trigger_index(text: str) -> int:
+    """Return the start index of an exact trigger phrase match, or -1."""
+    lowered = text.lower()
+    trigger = TRIGGER_PHRASE.lower()
+    start = 0
+    while True:
+        idx = lowered.find(trigger, start)
+        if idx < 0:
+            return -1
+        before = lowered[idx - 1] if idx > 0 else ""
+        after_idx = idx + len(trigger)
+        after = lowered[after_idx] if after_idx < len(lowered) else ""
+        before_ok = not before or not (before.isalnum() or before in "_-")
+        after_ok = not after or not (after.isalnum() or after in "_-")
+        if before_ok and after_ok:
+            return idx
+        start = idx + 1
+
+
+def _has_trigger(text: str) -> bool:
+    return _trigger_index(text) >= 0
+
+
+def _request_after_trigger(text: str) -> str:
+    idx = _trigger_index(text)
+    if idx < 0:
+        return text
+    return text[idx + len(TRIGGER_PHRASE):].strip(" :–—")
+
+
 def full_thread_history(
     token: str, channel: str, thread_ts: str,
     bot_user_id: str, bot_message_ts: list[str],
@@ -567,14 +722,114 @@ def _gather_channel_context(
     return context_lines
 
 
+def _close_thread_watch(rec: dict, conv_key: str, now: float) -> None:
+    rec["status"] = "closed"
+    rec["closed_reason"] = "followup_watch_expired"
+    rec["closed_at"] = now
+    print(f"  Follow-up watch expired for {conv_key}")
+
+
+def _next_reply_poll_at(rec: dict, now: float, delay: int) -> float:
+    next_poll_at = now + delay
+    watch_until = float(rec.get("watch_until") or 0)
+    if rec.get("status") == "watching" and watch_until:
+        next_poll_at = min(next_poll_at, watch_until)
+    return next_poll_at
+
+
+def _poll_due_thread_replies(
+    slack_token: str,
+    active_convs: dict[str, dict],
+    bot_user_id: str,
+    bot_message_ts: list[str],
+) -> list[tuple[str, dict]]:
+    now = time.time()
+    due: list[tuple[float, str, dict]] = []
+    for conv_key, rec in active_convs.items():
+        if rec.get("status") not in {"active", "watching"}:
+            continue
+        next_poll = float(rec.get("next_reply_poll_at") or 0)
+        watch_until = float(rec.get("watch_until") or 0)
+        if rec.get("status") == "watching" and watch_until and now >= watch_until:
+            next_poll = min(next_poll or watch_until, watch_until)
+        if next_poll <= now:
+            due.append((next_poll, conv_key, rec))
+
+    reply_messages: list[tuple[str, dict]] = []
+    for _next_poll, conv_key, rec in sorted(due)[:MAX_THREAD_REPLY_POLLS_PER_RUN]:
+        cid = rec["channel_id"]
+        thread_ts = rec["thread_ts"]
+        oldest = rec.get("last_seen_reply_ts") or thread_ts
+        watch_until = float(rec.get("watch_until") or 0)
+        watch_expired = rec.get("status") == "watching" and watch_until and now >= watch_until
+        try:
+            replies = thread_replies(slack_token, cid, thread_ts, oldest)
+        except Exception as exc:
+            message = str(exc)
+            retry_after = THREAD_REPLY_MAX_BACKOFF_SECONDS
+            marker = "retry_after="
+            if marker in message:
+                raw = message.split(marker, 1)[1].split()[0]
+                try:
+                    retry_after = max(THREAD_REPLY_INITIAL_BACKOFF_SECONDS, int(raw))
+                except ValueError:
+                    pass
+            if watch_expired:
+                _close_thread_watch(rec, conv_key, now)
+            else:
+                rec["next_reply_poll_at"] = _next_reply_poll_at(rec, now, retry_after)
+                rec["reply_poll_backoff_seconds"] = min(
+                    THREAD_REPLY_MAX_BACKOFF_SECONDS,
+                    max(retry_after, int(rec.get("reply_poll_backoff_seconds") or THREAD_REPLY_INITIAL_BACKOFF_SECONDS)),
+                )
+            print(f"  Warning: could not fetch replies for thread {thread_ts}: {exc}")
+            continue
+
+        if replies:
+            rec["last_seen_reply_ts"] = max(r.get("ts", oldest) for r in replies)
+
+        human_replies = [r for r in replies if _is_human_message(r, bot_user_id, bot_message_ts)]
+        triggered_replies = [
+            r for r in human_replies
+            if _has_trigger(r.get("text", "") or "")
+        ]
+        if triggered_replies:
+            rec["reply_poll_backoff_seconds"] = THREAD_REPLY_INITIAL_BACKOFF_SECONDS
+            rec["next_reply_poll_at"] = now + THREAD_REPLY_INITIAL_BACKOFF_SECONDS
+            rec["watch_until"] = now + THREAD_FOLLOWUP_WATCH_SECONDS
+            for r in triggered_replies:
+                reply_messages.append((cid, r))
+            print(f"  {conv_key}: {len(triggered_replies)} triggered follow-up reply/replies")
+        elif watch_expired:
+            if human_replies:
+                print(f"  {conv_key}: ignored {len(human_replies)} follow-up reply/replies without trigger")
+            _close_thread_watch(rec, conv_key, now)
+        else:
+            if human_replies:
+                print(f"  {conv_key}: ignored {len(human_replies)} follow-up reply/replies without trigger")
+            current = int(rec.get("reply_poll_backoff_seconds") or THREAD_REPLY_INITIAL_BACKOFF_SECONDS)
+            next_backoff = min(
+                THREAD_REPLY_MAX_BACKOFF_SECONDS,
+                max(THREAD_REPLY_INITIAL_BACKOFF_SECONDS, current * THREAD_REPLY_BACKOFF_MULTIPLIER),
+            )
+            rec["reply_poll_backoff_seconds"] = next_backoff
+            rec["next_reply_poll_at"] = _next_reply_poll_at(rec, now, next_backoff)
+            next_delay = max(0, int(rec["next_reply_poll_at"] - now))
+            print(f"  {conv_key}: no follow-ups; next reply poll in {next_delay}s")
+
+    return reply_messages
+
+
 def _poll_new_messages(
     slack_token: str,
     use_search: bool,
     oldest_by_channel: dict[str, str],
     global_oldest: str,
     active_convs: dict[str, dict],
+    bot_user_id: str,
+    bot_message_ts: list[str],
 ) -> list[tuple[str, dict]]:
-    """Collect and sort new top-level messages and thread replies from Slack."""
+    """Collect and sort new top-level messages and due thread replies from Slack."""
     new_messages: list[tuple[str, dict]] = []
 
     if use_search:
@@ -602,19 +857,9 @@ def _poll_new_messages(
             except Exception as exc:
                 print(f"  Warning: could not fetch history for {cid}: {exc}")
 
-    reply_messages: list[tuple[str, dict]] = []
-    for _conv_key, rec in active_convs.items():
-        if rec.get("status") == "closed":
-            continue
-        cid = rec["channel_id"]
-        thread_ts = rec["thread_ts"]
-        oldest = oldest_by_channel.get(cid, global_oldest)
-        try:
-            replies = thread_replies(slack_token, cid, thread_ts, oldest)
-            for r in replies:
-                reply_messages.append((cid, r))
-        except Exception as exc:
-            print(f"  Warning: could not fetch replies for thread {thread_ts}: {exc}")
+    reply_messages = _poll_due_thread_replies(
+        slack_token, active_convs, bot_user_id, bot_message_ts
+    )
 
     return sorted(
         new_messages + reply_messages,
@@ -669,10 +914,7 @@ def _process_trigger_message(
             print(f"  Warning: could not fetch thread history: {exc}")
 
     # Extract the user's request: the text that follows the trigger phrase.
-    request_part = text
-    idx = text.lower().find(TRIGGER_PHRASE.lower())
-    if idx >= 0:
-        request_part = text[idx + len(TRIGGER_PHRASE):].strip(" :–—")
+    request_part = _request_after_trigger(text)
 
     initial_prompt = (
         f"You are an AI assistant responding to a Slack message.\n\n"
@@ -697,12 +939,17 @@ def _process_trigger_message(
         conv_id = create_conversation(agent_url, api_key, initial_prompt)
         conv_url = f"{openhands_url}/conversations/{conv_id}"
 
+        now = time.time()
         active_convs[conv_key] = {
             "conversation_id": conv_id,
             "channel_id": channel_id,
             "thread_ts": thread_root,
             "status": "active",
-            "last_activity": time.time(),
+            "last_activity": now,
+            "last_seen_reply_ts": msg_ts,
+            "reply_poll_backoff_seconds": THREAD_REPLY_INITIAL_BACKOFF_SECONDS,
+            "next_reply_poll_at": now + THREAD_REPLY_INITIAL_BACKOFF_SECONDS,
+            "watch_until": now + THREAD_FOLLOWUP_WATCH_SECONDS,
         }
 
         link_text = f"🤖 On it! View progress here: {conv_url}"
@@ -760,26 +1007,30 @@ def _check_conversation_completion(
         if ts_back:
             bot_message_ts.append(ts_back)
 
-        rec["status"] = "closed"
-        print(f"  Posted summary for {conv_key}")
+        now = time.time()
+        rec["status"] = "watching"
+        rec["last_activity"] = now
+        rec["watch_until"] = now + THREAD_FOLLOWUP_WATCH_SECONDS
+        rec["reply_poll_backoff_seconds"] = THREAD_REPLY_INITIAL_BACKOFF_SECONDS
+        rec["next_reply_poll_at"] = now + THREAD_REPLY_INITIAL_BACKOFF_SECONDS
+        print(
+            f"  Posted summary for {conv_key}; watching for follow-ups "
+            f"until {rec['watch_until']:.0f}"
+        )
 
 
 # ── Main ───────────────────────────────────────────────────────────────────────
 
 def main() -> str | None:
     """Run one polling cycle. Returns the last conversation ID created, if any."""
-    state_path = _state_file_path()
-    state = load_state(state_path)
+    state = load_state()
 
     agent_url = os.environ.get("AGENT_SERVER_URL", "").rstrip("/")
     api_key = _get_env_key()
 
     slack_token, token_is_user = _resolve_slack_token()
 
-    try:
-        openhands_url = get_secret("OPENHANDS_URL").rstrip("/") or DEFAULT_OPENHANDS_URL
-    except Exception:
-        openhands_url = DEFAULT_OPENHANDS_URL
+    openhands_url = resolve_openhands_url()
 
     # Raises RuntimeError immediately if the token is invalid - no point polling.
     bot_user_id_new, scopes = _slack_auth_test(slack_token)
@@ -808,7 +1059,8 @@ def main() -> str | None:
     active_convs: dict[str, dict] = state.get("conversations", {})
 
     all_incoming = _poll_new_messages(
-        slack_token, use_search, oldest_by_channel, global_oldest, active_convs
+        slack_token, use_search, oldest_by_channel, global_oldest,
+        active_convs, bot_user_id, bot_message_ts,
     )
 
     print(f"  all_incoming: {len(all_incoming)} message(s), "
@@ -848,14 +1100,16 @@ def main() -> str | None:
         thread_root: str = thread_ts if thread_ts and thread_ts != msg_ts else msg_ts
         conv_key = f"{channel_id}:{thread_root}"
 
-        has_trigger = TRIGGER_PHRASE.lower() in text.lower()
+        has_trigger = _has_trigger(text)
         is_thread_reply = (
             thread_ts is not None
             and thread_ts != msg_ts
         )
+        tracked_rec = active_convs.get(conv_key)
         is_reply_in_tracked = (
             is_thread_reply
-            and conv_key in active_convs
+            and tracked_rec is not None
+            and tracked_rec.get("status") in {"active", "watching"}
         )
 
         print(f"  EVAL: ts={msg_ts} trigger={has_trigger} reply={is_thread_reply} "
@@ -863,20 +1117,39 @@ def main() -> str | None:
               f"text={text[:60]!r}")
 
         # ── Case A: reply in a thread that has a tracked conversation ──────────
-        # Route to the existing conversation regardless of its status (active or
-        # closed).  If the conversation was closed, re-activate it so the agent
-        # processes the new message and the completion check fires again later.
+        # Route to the existing conversation while it is active or in its
+        # follow-up watch window, but only when the reply includes the trigger
+        # phrase. Once the watch expires, a new trigger in the thread creates a
+        # fresh conversation instead.
         if is_reply_in_tracked:
             rec = active_convs[conv_key]
-            print(f"  → Case A: Forwarding reply {msg_ts} → conversation {rec['conversation_id']}")
+            rec["last_seen_reply_ts"] = max(rec.get("last_seen_reply_ts", msg_ts), msg_ts)
+            if not has_trigger:
+                processed_ts.add(msg_ts)
+                print(f"  → Case A ignored (tracked reply without trigger): {msg_ts}")
+                continue
+
+            request_part = _request_after_trigger(text)
+            print(f"  → Case A: Forwarding triggered reply {msg_ts} → conversation {rec['conversation_id']}")
             try:
-                send_to_conversation(agent_url, api_key, rec["conversation_id"],
-                                     f"User replied in Slack thread: {text}")
+                send_to_conversation(
+                    agent_url, api_key, rec["conversation_id"],
+                    (
+                        f"User <@{msg.get('user', '?')}> replied in Slack thread.\n"
+                        f"The reply was activated by the trigger phrase: `{TRIGGER_PHRASE}`\n"
+                        f"Full reply: {text}\n"
+                        f"User request: {request_part or '(no explicit request — use your best judgement)'}"
+                    ),
+                )
+                now = time.time()
                 rec["status"] = "active"
-                rec["last_activity"] = time.time()
+                rec["last_activity"] = now
+                rec["watch_until"] = now + THREAD_FOLLOWUP_WATCH_SECONDS
+                rec["reply_poll_backoff_seconds"] = THREAD_REPLY_INITIAL_BACKOFF_SECONDS
+                rec["next_reply_poll_at"] = now + THREAD_REPLY_INITIAL_BACKOFF_SECONDS
             except Exception as exc:
                 print(f"  Warning: failed to forward reply: {exc}")
-            if has_trigger and can_react:
+            if can_react:
                 add_reaction(slack_token, channel_id, msg_ts)
             processed_ts.add(msg_ts)
             continue
@@ -922,7 +1195,7 @@ def main() -> str | None:
     print(f"  last_poll set to {effective_last_poll}")
 
     for conv_key, rec in list(active_convs.items()):
-        if rec.get("status") != "closed":
+        if rec.get("status") == "active":
             _check_conversation_completion(
                 conv_key, rec, agent_url, api_key, slack_token, bot_message_ts,
             )
@@ -937,8 +1210,7 @@ def main() -> str | None:
     state["processed_ts"] = processed_list[-MAX_PROCESSED_TS:]
 
     state["conversations"] = active_convs
-    save_state(state_path, state)
-    print(f"State saved to {state_path}")
+    save_state(state)
     return last_conversation_id
 
 

package/tests/test_catalogs.py

@@ -40,10 +40,10 @@ def test_catalog_entries_have_required_fields():
         assert entry["id"]
         assert entry["name"]
         assert entry["description"]
-        assert entry["kind"] in {"mcp", "http"}
-        assert entry["iconBg"]
+        # iconBg/iconColor are optional UI styling hints (OAuth-only entries may
+        # ship without a bespoke icon background).
+        assert "iconBg" not in entry or entry["iconBg"]
         assert entry["connectionOptions"]
-        assert entry["defaultConnectionOptionId"]
         for option in entry["connectionOptions"]:
             assert option["id"]
             assert option["provider"] in {"mcp", "http"}
@@ -72,6 +72,24 @@ def test_catalog_entries_have_required_fields():
         assert isinstance(entry["estimatedSetupMinutes"], int)
 
 
+def test_remote_no_auth_mcp_entries_are_intentionally_public():
+    public_remote_mcp_ids = {"cloudflare-docs", "deepwiki", "huggingface"}
+
+    actual = set()
+    for entry in load_catalog_entries("integrations/catalog"):
+        for option in entry["connectionOptions"]:
+            transport = option.get("transport", {})
+            if (
+                option["provider"] == "mcp"
+                and option["auth"]["strategy"] == "none"
+                and transport.get("url", "").startswith("https://")
+            ):
+                actual.add(entry["id"])
+                assert transport["kind"] == "shttp"
+
+    assert actual == public_remote_mcp_ids
+
+
 def test_credential_fields_have_helper_text_and_link():
     """All password fields must have helperText plus a link (either a helperLink field or a
     markdown link embedded in helperText) so users know how to get credentials."""