@openhands/extensions 0.4.2 → 0.6.0

package/tests/test_integration_catalog_in_sync.py

@@ -0,0 +1,204 @@
+"""Assert integration catalog files drive the generated JS/Python assets."""
+
+from __future__ import annotations
+
+import json
+import subprocess
+from pathlib import Path
+
+import openhands_extensions
+
+ROOT = Path(__file__).resolve().parents[1]
+CATALOG_DIR = ROOT / "integrations" / "catalog"
+CATALOG_INDEX = ROOT / "integrations" / "catalog-index.js"
+AGGREGATE_ASSETS = [
+    ROOT / "integrations" / "integration-catalog.json",
+    ROOT / "python" / "openhands_extensions" / "integration-catalog.json",
+]
+
+
+def _catalog_files() -> dict[str, dict]:
+    return {p.stem: json.loads(p.read_text()) for p in CATALOG_DIR.glob("*.json")}
+
+
+def _catalog_entries() -> list[dict]:
+    entries = list(_catalog_files().values())
+    return sorted(entries, key=lambda entry: (-(entry.get("popularityRank") if entry.get("popularityRank") is not None else -1), entry["id"]))
+
+
+def _supports_mcp(entry: dict) -> bool:
+    return any(option.get("provider") == "mcp" for option in entry["connectionOptions"])
+
+
+def _supports_oauth(entry: dict) -> bool:
+    return any(option.get("auth", {}).get("strategy") == "oauth2" for option in entry["connectionOptions"])
+
+
+
+def test_catalog_directory_is_hand_authored_source_of_truth() -> None:
+    for integration_id, entry in _catalog_files().items():
+        assert entry["id"] == integration_id
+        assert "supportsMcp" not in entry
+        assert "supportsOauth" not in entry
+        assert "oauthProvider" not in entry
+        assert "registrationDefaults" not in entry
+        assert "managedConnectorSlug" not in entry
+        assert "authStrategy" not in entry
+        assert "defaultConnectionOptionId" not in entry
+        assert "kind" not in entry
+        assert "catalogStatus" not in entry
+        assert "availability" not in entry
+        assert "runtimeAvailability" not in entry
+
+
+def test_no_aggregate_catalog_json_exists() -> None:
+    for asset in AGGREGATE_ASSETS:
+        assert not asset.exists()
+
+
+def test_generated_js_index_references_catalog_directory() -> None:
+    body = CATALOG_INDEX.read_text()
+    for file in sorted(path.name for path in CATALOG_DIR.glob("*.json")):
+        assert f"./catalog/{file}" in body
+    assert "integration-catalog.json" not in body
+
+
+def test_python_snapshot_is_built_from_catalog_directory() -> None:
+    assert openhands_extensions.INTEGRATION_CATALOG_SNAPSHOT == {
+        "integrations": _catalog_entries()
+    }
+
+
+def test_python_list_integration_catalog_returns_raw_entries() -> None:
+    entries = openhands_extensions.list_integration_catalog()
+    assert entries == _catalog_entries()
+    for entry in entries:
+        assert "supportsMcp" not in entry
+        assert "supportsOauth" not in entry
+        assert "registrationDefaults" not in entry
+        assert "managedConnectorSlug" not in entry
+        assert "authStrategy" not in entry
+        assert "defaultConnectionOptionId" not in entry
+        assert "catalogStatus" not in entry
+        assert "availability" not in entry
+        assert "runtimeAvailability" not in entry
+
+
+def test_logo_metadata_is_serializable_and_language_agnostic() -> None:
+    entries = openhands_extensions.list_integration_catalog()
+    with_logo = [entry for entry in entries if entry.get("logoUrl")]
+    assert with_logo
+    assert any(entry["id"].startswith("cloudflare-") for entry in with_logo)
+    for entry in with_logo:
+        assert isinstance(entry["logoUrl"], str)
+        assert entry["logoUrl"].startswith("https://")
+        assert "react" not in entry["logoUrl"].lower()
+
+
+def test_get_integration_catalog_entry_round_trip() -> None:
+    github = openhands_extensions.get_integration_catalog_entry("github")
+    assert github is not None
+    assert github == next(
+        entry for entry in openhands_extensions.list_integration_catalog() if entry["id"] == "github"
+    )
+    assert openhands_extensions.get_integration_catalog_entry("nope") is None
+
+
+def _js_call(expr: str) -> str:
+    result = subprocess.run(
+        ["node", "--input-type=module", "-e", expr],
+        capture_output=True,
+        text=True,
+        check=True,
+        cwd=ROOT,
+    )
+    return result.stdout
+
+
+def test_js_reads_the_same_catalog_as_python() -> None:
+    integrations = _js_call(
+        "import { listIntegrationCatalog } from './integrations/index.js';\n"
+        "process.stdout.write(JSON.stringify(listIntegrationCatalog()));"
+    )
+    assert json.loads(integrations) == openhands_extensions.list_integration_catalog()
+
+    github = _js_call(
+        "import { getIntegrationCatalogEntry } from './integrations/index.js';\n"
+        "process.stdout.write(JSON.stringify(getIntegrationCatalogEntry('github')));"
+    )
+    assert json.loads(github) == openhands_extensions.get_integration_catalog_entry("github")
+
+
+def _js_filter(mcp, oauth) -> list[str]:
+    expr = (
+        "import { listIntegrationCatalog } from './integrations/index.js';\n"
+        f"const f = listIntegrationCatalog({{ mcp: {mcp}, oauth: {oauth} }});\n"
+        "process.stdout.write(JSON.stringify(f.map((e) => e.id)));"
+    )
+    return json.loads(_js_call(expr))
+
+
+def test_filter_mcp_only() -> None:
+    py_ids = {e["id"] for e in openhands_extensions.list_integration_catalog(mcp=True)}
+    js_ids = set(_js_filter("true", "undefined"))
+    all_mcp = {e["id"] for e in openhands_extensions.list_integration_catalog() if _supports_mcp(e)}
+    assert py_ids == js_ids == all_mcp
+    assert "filesystem" in py_ids
+
+
+def test_filter_oauth_only() -> None:
+    py_ids = {e["id"] for e in openhands_extensions.list_integration_catalog(oauth=True)}
+    js_ids = set(_js_filter("undefined", "true"))
+    all_oauth = {e["id"] for e in openhands_extensions.list_integration_catalog() if _supports_oauth(e)}
+    assert py_ids == js_ids == all_oauth
+    assert "github" in py_ids
+
+
+def test_filter_oauth_not_mcp() -> None:
+    py_ids = {
+        e["id"] for e in openhands_extensions.list_integration_catalog(oauth=True, mcp=False)
+    }
+    js_ids = set(_js_filter("false", "true"))
+    expected = {
+        e["id"]
+        for e in openhands_extensions.list_integration_catalog()
+        if _supports_oauth(e) and not _supports_mcp(e)
+    }
+    assert py_ids == js_ids == expected
+
+
+def test_filter_none_returns_all() -> None:
+    assert len(openhands_extensions.list_integration_catalog()) == len(
+        openhands_extensions.list_integration_catalog(mcp=None, oauth=None)
+    )
+
+
+def test_accessors_return_independent_copies() -> None:
+    catalog_a = openhands_extensions.list_integration_catalog()
+    catalog_b = openhands_extensions.list_integration_catalog()
+    assert catalog_a == catalog_b
+    assert catalog_a is not catalog_b
+    catalog_a[0]["__mutated"] = True
+    assert "__mutated" not in openhands_extensions.list_integration_catalog()[0]
+
+    github = openhands_extensions.get_integration_catalog_entry("github")
+    assert github is not None
+    github["__mutated"] = True
+    assert "__mutated" not in openhands_extensions.get_integration_catalog_entry("github")
+
+    snapshot = openhands_extensions.INTEGRATION_CATALOG_SNAPSHOT
+    snapshot["integrations"][0]["__mutated"] = True
+    assert "__mutated" not in openhands_extensions.list_integration_catalog()[0]
+
+
+def test_hubspot_oauth_config_lives_on_connection_option() -> None:
+    hubspot = openhands_extensions.get_integration_catalog_entry("hubspot")
+    assert hubspot is not None
+    assert "registrationDefaults" not in hubspot
+    option = hubspot["connectionOptions"][0]
+    assert option["provider"] == "mcp"
+    assert option["transport"]["url"] == "https://mcp.hubspot.com"
+    oauth = option["auth"]["oauth"]
+    assert oauth["authorizationUrl"] == "https://mcp.hubspot.com/oauth/authorize/user"
+    assert oauth["tokenUrl"] == "https://mcp.hubspot.com/oauth/v3/token"
+    assert oauth["pkce"] is True

package/tests/test_slack_channel_monitor.py

@@ -0,0 +1,142 @@
+import os
+from pathlib import Path
+
+
+SCRIPT_PATH = (
+    Path(__file__).parent.parent
+    / "skills"
+    / "slack-channel-monitor"
+    / "scripts"
+    / "main.py"
+)
+
+
+def load_slack_monitor_helpers():
+    os.environ["WORKSPACE_BASE"] = "/tmp/openhands/workspaces/slack-monitor-test/run"
+    source = SCRIPT_PATH.read_text(encoding="utf-8")
+    helper_source = source.split("\nPOLL_ITERATIONS = 10", 1)[0]
+    namespace: dict = {}
+    exec(compile(helper_source, str(SCRIPT_PATH), "exec"), namespace)
+    return namespace
+
+
+def test_post_message_sends_markdown_text(monkeypatch):
+    helpers = load_slack_monitor_helpers()
+    posted: dict = {}
+
+    def fake_slack_post(token: str, endpoint: str, body: dict) -> dict:
+        posted["token"] = token
+        posted["endpoint"] = endpoint
+        posted["body"] = body
+        return {"ts": "123.456"}
+
+    monkeypatch.setitem(helpers, "slack_post", fake_slack_post)
+    markdown_summary = "✅ Done!\n\n- **Bold:** [link](https://example.com)"
+
+    ts = helpers["post_message"](
+        "xoxb-test",
+        "C123",
+        markdown_summary,
+        thread_ts="111.222",
+    )
+
+    assert ts == "123.456"
+    assert posted["endpoint"] == "chat.postMessage"
+    assert posted["body"] == {
+        "channel": "C123",
+        "markdown_text": markdown_summary,
+        "unfurl_links": False,
+        "unfurl_media": False,
+        "thread_ts": "111.222",
+    }
+    assert "text" not in posted["body"]
+    assert "blocks" not in posted["body"]
+    assert "mrkdwn" not in posted["body"]
+
+
+def test_followup_quiet_poll_is_capped_at_watch_expiry(monkeypatch):
+    helpers = load_slack_monitor_helpers()
+    monkeypatch.setattr(helpers["time"], "time", lambda: 950.0)
+    calls: list[tuple[str, str, str]] = []
+
+    def fake_thread_replies(
+        token: str,
+        channel: str,
+        thread_ts: str,
+        oldest: str,
+    ) -> list[dict]:
+        calls.append((channel, thread_ts, oldest))
+        return []
+
+    monkeypatch.setitem(helpers, "thread_replies", fake_thread_replies)
+    rec = {
+        "channel_id": "C123",
+        "thread_ts": "900.000000",
+        "status": "watching",
+        "last_seen_reply_ts": "900.000000",
+        "reply_poll_backoff_seconds": 80,
+        "next_reply_poll_at": 950.0,
+        "watch_until": 1000.0,
+    }
+
+    replies = helpers["_poll_due_thread_replies"](
+        "xoxb-test",
+        {"C123:900.000000": rec},
+        "UBOT",
+        [],
+    )
+
+    assert replies == []
+    assert calls == [("C123", "900.000000", "900.000000")]
+    assert rec["status"] == "watching"
+    assert rec["next_reply_poll_at"] == 1000.0
+
+
+def test_expired_followup_watch_polls_once_before_closing(monkeypatch):
+    helpers = load_slack_monitor_helpers()
+    monkeypatch.setattr(helpers["time"], "time", lambda: 1001.0)
+    trigger = helpers["TRIGGER_PHRASE"]
+    reply = {
+        "ts": "999.500000",
+        "user": "U1",
+        "text": f"{trigger} please continue",
+    }
+    calls: list[tuple[str, str, str]] = []
+
+    def fake_thread_replies(
+        token: str,
+        channel: str,
+        thread_ts: str,
+        oldest: str,
+    ) -> list[dict]:
+        calls.append((channel, thread_ts, oldest))
+        return [reply]
+
+    monkeypatch.setitem(helpers, "thread_replies", fake_thread_replies)
+    rec = {
+        "channel_id": "C123",
+        "thread_ts": "900.000000",
+        "status": "watching",
+        "last_seen_reply_ts": "900.000000",
+        "reply_poll_backoff_seconds": 160,
+        "next_reply_poll_at": 1100.0,
+        "watch_until": 1000.0,
+    }
+
+    replies = helpers["_poll_due_thread_replies"](
+        "xoxb-test",
+        {"C123:900.000000": rec},
+        "UBOT",
+        [],
+    )
+
+    assert calls == [("C123", "900.000000", "900.000000")]
+    assert replies == [("C123", reply)]
+    assert rec["last_seen_reply_ts"] == "999.500000"
+    assert (
+        rec["reply_poll_backoff_seconds"]
+        == helpers["THREAD_REPLY_INITIAL_BACKOFF_SECONDS"]
+    )
+    assert rec["next_reply_poll_at"] == 1006.0
+    assert rec["watch_until"] == 1301.0
+

package/tests/test_version_alignment.py

@@ -0,0 +1,64 @@
+"""Assert the JS (``package.json``) and Python (``pyproject.toml`` +
+``_version.py``) package versions never drift apart.
+
+``release-please`` is configured to bump both ``package.json`` and
+``pyproject.toml`` together (see ``release-please-config.json`` ->
+``extra-files``). This test is the guard that catches a manual edit that
+bumps only one.
+"""
+
+from __future__ import annotations
+
+import re
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[1]
+
+
+def _package_json_version() -> str:
+    text = (ROOT / "package.json").read_text()
+    match = re.search(r'"version"\s*:\s*"([^"]+)"', text)
+    assert match, "package.json has no version field"
+    return match.group(1)
+
+
+def _pyproject_version() -> str:
+    text = (ROOT / "pyproject.toml").read_text()
+    match = re.search(r'^version\s*=\s*"([^"]+)"', text, re.MULTILINE)
+    assert match, "pyproject.toml has no version field"
+    return match.group(1)
+
+
+def _version_module_version() -> str:
+    import openhands_extensions._version as v
+
+    text = (ROOT / "python" / "openhands_extensions" / "_version.py").read_text()
+    match = re.search(r'_FALLBACK_VERSION\s*=\s*"([^"]+)"', text)
+    assert match, "_version.py has no _FALLBACK_VERSION"
+    fallback = match.group(1)
+    # Runtime __version__ is metadata-derived when installed, fallback otherwise;
+    # both must agree with the declared versions.
+    assert v.__version__ in (fallback, _package_json_version()), (
+        f"runtime __version__ {v.__version__!r} disagrees with fallback/package.json"
+    )
+    return fallback
+
+
+def test_package_json_and_pyproject_versions_match() -> None:
+    assert _package_json_version() == _pyproject_version(), (
+        "package.json and pyproject.toml versions differ. release-please "
+        "should bump both together; check release-please-config.json."
+    )
+
+
+def test_version_module_matches_package_json() -> None:
+    assert _version_module_version() == _package_json_version(), (
+        "python/openhands_extensions/_version.py is out of sync with "
+        "package.json."
+    )
+
+
+def test_installed_package_version_matches_source() -> None:
+    import openhands_extensions
+
+    assert openhands_extensions.__version__ == _package_json_version()

package/integrations/logos.d.ts

@@ -1,5 +0,0 @@
-import type { ReactNode } from "react";
-
-export const INTEGRATION_FALLBACK_LOGO: ReactNode;
-export const INTEGRATION_LOGOS: Record<string, ReactNode>;
-export const INTEGRATION_LOGO_IDS: Set<string>;

package/integrations/logos.js

@@ -1,94 +0,0 @@
-import { createElement } from "react";
-import {
-  BookOpen,
-  Bot,
-  Brain,
-  Clock,
-  Database,
-  Flame,
-  Folder,
-  GitBranch,
-  Globe,
-  ListTree,
-  MousePointerClick,
-  Search,
-  Sparkles,
-  Telescope,
-  TestTube,
-} from "lucide-react";
-import {
-  SiAirtable,
-  SiAtlassian,
-  SiBrave,
-  SiClickhouse,
-  SiCloudflare,
-  SiElevenlabs,
-  SiFigma,
-  SiGithub,
-  SiHuggingface,
-  SiKagi,
-  SiLinear,
-  SiMongodb,
-  SiNotion,
-  SiObsidian,
-  SiPaypal,
-  SiRedis,
-  SiResend,
-  SiSentry,
-  SiSlack,
-  SiStripe,
-  SiSupabase,
-} from "react-icons/si";
-
-const LOGO = "h-5 w-5";
-
-const simpleIcon = (Icon) => createElement(Icon, { className: LOGO });
-const lucideIcon = (Icon) =>
-  createElement(Icon, { className: LOGO, strokeWidth: 2.25 });
-
-export const INTEGRATION_FALLBACK_LOGO = lucideIcon(Bot);
-
-export const INTEGRATION_LOGOS = {
-  github: simpleIcon(SiGithub),
-  slack: simpleIcon(SiSlack),
-  tavily: createElement(Search, { className: LOGO, strokeWidth: 2.5 }),
-  linear: simpleIcon(SiLinear),
-  notion: simpleIcon(SiNotion),
-  atlassian: simpleIcon(SiAtlassian),
-  sentry: simpleIcon(SiSentry),
-  stripe: simpleIcon(SiStripe),
-  paypal: simpleIcon(SiPaypal),
-  "cloudflare-docs": simpleIcon(SiCloudflare),
-  "cloudflare-bindings": simpleIcon(SiCloudflare),
-  "cloudflare-observability": simpleIcon(SiCloudflare),
-  huggingface: simpleIcon(SiHuggingface),
-  deepwiki: simpleIcon(BookOpen),
-  git: lucideIcon(GitBranch),
-  "brave-search": simpleIcon(SiBrave),
-  exa: lucideIcon(Telescope),
-  firecrawl: lucideIcon(Flame),
-  apify: lucideIcon(Bot),
-  fetch: lucideIcon(Globe),
-  "browser-mcp": lucideIcon(MousePointerClick),
-  playwright: lucideIcon(TestTube),
-  supabase: simpleIcon(SiSupabase),
-  neon: lucideIcon(Database),
-  mongodb: simpleIcon(SiMongodb),
-  redis: simpleIcon(SiRedis),
-  filesystem: lucideIcon(Folder),
-  memory: lucideIcon(Brain),
-  "sequential-thinking": lucideIcon(ListTree),
-  time: lucideIcon(Clock),
-  everything: lucideIcon(Sparkles),
-  figma: simpleIcon(SiFigma),
-  airtable: simpleIcon(SiAirtable),
-  obsidian: simpleIcon(SiObsidian),
-  elevenlabs: simpleIcon(SiElevenlabs),
-  resend: simpleIcon(SiResend),
-  "cloudflare-builds": simpleIcon(SiCloudflare),
-  "cloudflare-browser-rendering": simpleIcon(SiCloudflare),
-  kagi: simpleIcon(SiKagi),
-  clickhouse: simpleIcon(SiClickhouse),
-};
-
-export const INTEGRATION_LOGO_IDS = new Set(Object.keys(INTEGRATION_LOGOS));