@openhands/extensions 0.16.0 → 0.17.0

package/tests/test_catalogs.py

@@ -146,6 +146,49 @@ def test_credential_fields_have_helper_text_and_link():
                         )
 
 
+def test_posthog_catalog_prefers_oauth_with_safe_mcp_defaults():
+    posthog = next(
+        entry for entry in load_catalog_entries("integrations/catalog")
+        if entry["id"] == "posthog"
+    )
+
+    assert [option["id"] for option in posthog["connectionOptions"]] == [
+        "oauth",
+        "api-key",
+    ]
+
+    oauth = posthog["connectionOptions"][0]
+    assert oauth["provider"] == "mcp"
+    assert oauth["transport"] == {
+        "kind": "shttp",
+        "url": "https://mcp.posthog.com/mcp?readonly=true",
+        "urlEditable": True,
+    }
+    oauth_config = oauth["auth"]["oauth"]
+    assert oauth_config["authorizationUrl"] == (
+        "https://oauth.posthog.com/oauth/authorize/"
+    )
+    assert oauth_config["tokenUrl"] == "https://oauth.posthog.com/oauth/token/"
+    assert oauth_config["registrationUrl"] == (
+        "https://oauth.posthog.com/oauth/register/"
+    )
+    assert oauth_config["pkce"] is True
+    assert oauth_config["clientAuthentication"] == "none"
+    assert oauth_config["additionalAuthorizationParams"] == {
+        "resource": "https://mcp.posthog.com/mcp"
+    }
+    assert oauth_config["additionalTokenParams"] == {
+        "resource": "https://mcp.posthog.com/mcp"
+    }
+    assert "query:read" in oauth_config["scopes"]
+    assert all(not scope.endswith(":write") for scope in oauth_config["scopes"])
+
+    api_key = posthog["connectionOptions"][1]
+    assert api_key["auth"]["strategy"] == "bearer"
+    assert api_key["auth"]["credentialSecretName"] == "POSTHOG_PERSONAL_API_KEY"
+    assert api_key["auth"]["saveCredentialAsSecretByDefault"] is True
+
+
 def test_node_package_exports_catalogs():
     script = """
       import { INTEGRATION_CATALOG, AUTOMATION_CATALOG } from './index.js';

package/tests/test_skills_catalog.py

@@ -373,19 +373,6 @@ SKILL_CATEGORY_IDS = {
 # Adding entries would mean creating .plugin/plugin.json and vendor symlinks (see test_skill_plugin_loading.py), which publishes them as Codex/Claude Code plugins.
 SKILLS_WITHOUT_MARKETPLACE_ENTRY = {"qa-changes", "release-notes"}
 
-EXPECTED_CATEGORY_COUNTS = {
-    "environment": 10,
-    "automations": 9,
-    "code-hosting": 8,
-    "agent-authoring": 8,
-    "code-quality": 6,
-    "integrations": 6,
-    "writing": 4,
-    "design": 2,
-    "other": 1,
-}
-
-
 def _marketplace_skill_categories() -> dict[str, str]:
     """Map skill directory name -> category, across every marketplace manifest."""
     result: dict[str, str] = {}
@@ -417,12 +404,6 @@ class TestMarketplaceSkillCategories:
         uncovered = dirs - set(_marketplace_skill_categories())
         assert uncovered == SKILLS_WITHOUT_MARKETPLACE_ENTRY
 
-    def test_category_distribution_is_balanced(self):
-        from collections import Counter
-
-        counts = dict(Counter(_marketplace_skill_categories().values()))
-        assert counts == EXPECTED_CATEGORY_COUNTS
-
     def test_plugin_entries_keep_their_own_taxonomy(self):
         """Plugin entries are for Claude Code browsing and must not be rewritten."""
         categories = set()
@@ -437,25 +418,35 @@ class TestMarketplaceSkillCategories:
         )
 
 
-class TestCategoryJoin:
-    def _build(self, tmp_path, skills: dict[str, str], manifests: dict[str, dict], check: bool = True):
-        skills_dir = tmp_path / "skills"
-        skills_dir.mkdir()
-        for name, content in skills.items():
-            (skills_dir / name).mkdir()
-            (skills_dir / name / "SKILL.md").write_text(content)
+def build_from_fixtures(
+    tmp_path: Path,
+    skills: dict[str, str],
+    manifests: dict[str, dict],
+    check: bool = True,
+) -> subprocess.CompletedProcess:
+    """Run buildCatalog over temp SKILL.md dirs joined against temp manifests."""
+    skills_dir = tmp_path / "skills"
+    skills_dir.mkdir()
+    for name, content in skills.items():
+        (skills_dir / name).mkdir()
+        (skills_dir / name / "SKILL.md").write_text(content)
+
+    markets_dir = tmp_path / "marketplaces"
+    markets_dir.mkdir()
+    for filename, manifest in manifests.items():
+        (markets_dir / filename).write_text(json.dumps(manifest))
+
+    script = textwrap.dedent(f"""\
+        import {{ buildCatalog }} from './scripts/build-skills-catalog.mjs';
+        const entries = buildCatalog({json.dumps(str(skills_dir))}, {json.dumps(str(markets_dir))});
+        process.stdout.write(JSON.stringify(entries));
+    """)
+    return run_node(script, check=check)
 
-        markets_dir = tmp_path / "marketplaces"
-        markets_dir.mkdir()
-        for filename, manifest in manifests.items():
-            (markets_dir / filename).write_text(json.dumps(manifest))
 
-        script = textwrap.dedent(f"""\
-            import {{ buildCatalog }} from './scripts/build-skills-catalog.mjs';
-            const entries = buildCatalog({json.dumps(str(skills_dir))}, {json.dumps(str(markets_dir))});
-            process.stdout.write(JSON.stringify(entries));
-        """)
-        return run_node(script, check=check)
+class TestCategoryJoin:
+    def _build(self, tmp_path, skills: dict[str, str], manifests: dict[str, dict], check: bool = True):
+        return build_from_fixtures(tmp_path, skills, manifests, check=check)
 
     def test_category_is_joined_from_the_manifest(self, tmp_path):
         result = self._build(
@@ -544,3 +535,158 @@ class TestGeneratedCategories:
             }}
         """)
         run_node(script)
+
+
+# ---------------------------------------------------------------------------
+# defaultEnabled: the marketplace flag that seeds a new workspace's skill set
+# ---------------------------------------------------------------------------
+
+SKILL_MD = "---\nname: docker\ndescription: d\n---\nBody"
+
+
+def _entry(**overrides) -> dict:
+    return {"name": "docker", "source": "./skills/docker", "category": "environment", **overrides}
+
+
+class TestDefaultEnabledJoin:
+    def test_flag_is_joined_from_the_manifest(self, tmp_path):
+        result = build_from_fixtures(
+            tmp_path,
+            {"docker": SKILL_MD},
+            {"m.json": {"plugins": [_entry(defaultEnabled=True)]}},
+        )
+        assert json.loads(result.stdout)[0]["defaultEnabled"] is True
+
+    def test_absent_flag_is_omitted_rather_than_false(self, tmp_path):
+        """So consumers can test for absence."""
+        result = build_from_fixtures(
+            tmp_path,
+            {"docker": SKILL_MD},
+            {"m.json": {"plugins": [_entry()]}},
+        )
+        assert "defaultEnabled" not in json.loads(result.stdout)[0]
+
+    def test_explicit_false_is_also_omitted(self, tmp_path):
+        result = build_from_fixtures(
+            tmp_path,
+            {"docker": SKILL_MD},
+            {"m.json": {"plugins": [_entry(defaultEnabled=False)]}},
+        )
+        assert "defaultEnabled" not in json.loads(result.stdout)[0]
+
+    def test_skill_without_a_manifest_entry_is_not_default_enabled(self, tmp_path):
+        result = build_from_fixtures(
+            tmp_path,
+            {"lonely": "---\nname: lonely\ndescription: d\n---\nBody"},
+            {"m.json": {"plugins": []}},
+        )
+        assert "defaultEnabled" not in json.loads(result.stdout)[0]
+
+    def test_non_boolean_throws_naming_the_skill(self, tmp_path):
+        """A truthy string like "true" must not silently enable a skill for every new user."""
+        result = build_from_fixtures(
+            tmp_path,
+            {"docker": SKILL_MD},
+            {"m.json": {"plugins": [_entry(defaultEnabled="true")]}},
+            check=False,
+        )
+        assert result.returncode != 0
+        assert "docker" in result.stderr
+        assert "defaultEnabled" in result.stderr
+        assert "boolean" in result.stderr
+
+    def test_conflicting_values_across_manifests_throws(self, tmp_path):
+        result = build_from_fixtures(
+            tmp_path,
+            {"docker": SKILL_MD},
+            {
+                "a.json": {"plugins": [_entry(defaultEnabled=True)]},
+                "b.json": {"plugins": [_entry()]},
+            },
+            check=False,
+        )
+        assert result.returncode != 0
+        assert "docker" in result.stderr
+        assert "Conflicting defaultEnabled" in result.stderr
+
+    def test_plugin_entries_cannot_set_the_flag(self, tmp_path):
+        """Only `./skills/*` sources feed the catalog."""
+        result = build_from_fixtures(
+            tmp_path,
+            {"docker": SKILL_MD},
+            {"m.json": {"plugins": [
+                {"name": "docker", "source": "./plugins/docker", "category": "utilities", "defaultEnabled": True},
+                _entry(),
+            ]}},
+        )
+        assert "defaultEnabled" not in json.loads(result.stdout)[0]
+
+
+class TestManifestDefaultEnabled:
+    """The hand-authored side: what the real marketplaces/*.json are allowed to say."""
+
+    def _skill_entries(self):
+        for path in sorted(MARKETPLACES_DIR.glob("*.json")):
+            for entry in json.loads(path.read_text()).get("plugins", []):
+                if entry.get("source", "").startswith("./skills/"):
+                    yield path.name, entry
+
+    def test_values_are_boolean(self):
+        bad = {
+            f"{filename}:{entry['name']}": entry["defaultEnabled"]
+            for filename, entry in self._skill_entries()
+            if "defaultEnabled" in entry and not isinstance(entry["defaultEnabled"], bool)
+        }
+        assert bad == {}, f"Non-boolean defaultEnabled: {bad}"
+
+    def test_off_by_default_is_expressed_by_omission(self):
+        redundant = [
+            f"{filename}:{entry['name']}"
+            for filename, entry in self._skill_entries()
+            if entry.get("defaultEnabled") is False
+        ]
+        assert redundant == [], f"Drop the field instead: {redundant}"
+
+    def test_default_set_stays_a_curated_minority(self):
+        """The bug this flag fixes is "everything is on"."""
+        entries = list(self._skill_entries())
+        enabled = [entry["name"] for _, entry in entries if entry.get("defaultEnabled")]
+        assert enabled, "No skill is default-enabled; a new workspace would start empty"
+        assert len(enabled) < len(entries) / 2, (
+            f"{len(enabled)}/{len(entries)} skills are default-enabled, which is back to all-on"
+        )
+
+
+class TestGeneratedDefaultEnabled:
+    def test_names_export_matches_the_flagged_entries(self):
+        script = textwrap.dedent("""\
+            import { SKILLS_CATALOG, DEFAULT_ENABLED_SKILL_NAMES } from './skills/index.js';
+            const fromEntries = SKILLS_CATALOG.filter(e => e.defaultEnabled).map(e => e.name);
+            const exported = [...DEFAULT_ENABLED_SKILL_NAMES];
+            if (JSON.stringify(fromEntries) !== JSON.stringify(exported)) {
+              console.error('Mismatch: ' + JSON.stringify(fromEntries) + ' vs ' + JSON.stringify(exported));
+              process.exit(1);
+            }
+            if (exported.length === 0) process.exit(1);
+        """)
+        run_node(script)
+
+    def test_flag_is_only_ever_true_in_the_generated_catalog(self):
+        script = textwrap.dedent("""\
+            import { SKILLS_CATALOG } from './skills/index.js';
+            for (const entry of SKILLS_CATALOG) {
+              if ('defaultEnabled' in entry && entry.defaultEnabled !== true) {
+                console.error('Non-true defaultEnabled for ' + entry.name);
+                process.exit(1);
+              }
+            }
+        """)
+        run_node(script)
+
+    def test_names_are_re_exported_from_the_package_root(self):
+        script = textwrap.dedent("""\
+            import { DEFAULT_ENABLED_SKILL_NAMES } from './index.js';
+            if (!Array.isArray(DEFAULT_ENABLED_SKILL_NAMES)) process.exit(1);
+            if (DEFAULT_ENABLED_SKILL_NAMES.length === 0) process.exit(1);
+        """)
+        run_node(script)

package/tests/test_slack_channel_monitor.py

@@ -31,7 +31,7 @@ def test_post_message_sends_markdown_text(monkeypatch):
         return {"ts": "123.456"}
 
     monkeypatch.setitem(helpers, "slack_post", fake_slack_post)
-    markdown_summary = "✅ Done!\n\n- **Bold:** [link](https://example.com)"
+    markdown_summary = "- **Bold:** [link](https://example.com)"
 
     ts = helpers["post_message"](
         "xoxb-test",