@openhands/extensions 0.14.0 → 0.16.0

package/tests/test_interface_manifest.py

@@ -76,6 +76,26 @@ def test_featured_automations_resolve_to_catalog_entries():
                 constraints={"max": 50}
             ),
         ),
+        (
+            "a sub-page the interface does not serve",
+            lambda doc: doc["navigation"]["subPages"][0].update(
+                page="workflows"
+            ),
+        ),
+        (
+            "an icon outside the host's icon map",
+            lambda doc: doc["navigation"]["subPages"][0].update(icon="rocket"),
+        ),
+        (
+            "tile copy using a placeholder its metric does not expose",
+            lambda doc: doc["pages"]["list"]["overview"]["tiles"][2].update(
+                detail="{{active}} runs"
+            ),
+        ),
+        (
+            "a status filter without the all option",
+            lambda doc: doc["pages"]["list"]["filters"][0]["options"].pop(0),
+        ),
     ],
 )
 def test_schema_rejects(case, mutation):

package/tests/test_skills_catalog.py

@@ -27,6 +27,13 @@ def run_node(script: str, *, cwd: str | Path = ROOT, check: bool = True) -> subp
     )
 
 
+def empty_marketplaces(tmp_path: Path) -> Path:
+    """Isolates fixtures from the real manifests, so a fixture named after a real skill can't inherit its category."""
+    path = tmp_path / "marketplaces"
+    path.mkdir()
+    return path
+
+
 # ---------------------------------------------------------------------------
 # parseFrontmatter unit tests (via Node subprocess)
 # ---------------------------------------------------------------------------
@@ -134,9 +141,11 @@ class TestCodegenEndToEnd:
             skill_dir.mkdir()
             (skill_dir / "SKILL.md").write_text(content)
 
+        markets_dir = empty_marketplaces(tmp_path)
+
         script = textwrap.dedent(f"""\
             import {{ buildCatalog }} from './scripts/build-skills-catalog.mjs';
-            const entries = buildCatalog({json.dumps(str(skills_dir))});
+            const entries = buildCatalog({json.dumps(str(skills_dir))}, {json.dumps(str(markets_dir))});
             process.stdout.write(JSON.stringify(entries));
         """)
         result = run_node(script)
@@ -173,9 +182,11 @@ class TestCodegenEndToEnd:
         (skills_dir / "bad").mkdir()
         (skills_dir / "bad" / "SKILL.md").write_text("No frontmatter here")
 
+        markets_dir = empty_marketplaces(tmp_path)
+
         script = textwrap.dedent(f"""\
             import {{ buildCatalog }} from './scripts/build-skills-catalog.mjs';
-            buildCatalog({json.dumps(str(skills_dir))});
+            buildCatalog({json.dumps(str(skills_dir))}, {json.dumps(str(markets_dir))});
         """)
         result = run_node(script)
         assert "Warning" in result.stderr
@@ -198,11 +209,13 @@ class TestCodegenEndToEnd:
                 f"---\nname: {name}\ndescription: {name} desc\n---\nBody {name}"
             )
 
+        markets_dir = empty_marketplaces(tmp_path)
+
         output = tmp_path / "output.js"
         script = textwrap.dedent(f"""\
             import {{ writeFileSync }} from "node:fs";
             import {{ buildCatalog }} from './scripts/build-skills-catalog.mjs';
-            const entries = buildCatalog({json.dumps(str(skills_dir))});
+            const entries = buildCatalog({json.dumps(str(skills_dir))}, {json.dumps(str(markets_dir))});
             const src = "export const SKILLS_CATALOG = " + JSON.stringify(entries) + ";\\nexport default SKILLS_CATALOG;\\n";
             writeFileSync({json.dumps(str(output))}, src);
         """)
@@ -246,9 +259,11 @@ class TestCodegenEndToEnd:
         (skills_dir / "has-skill" / "SKILL.md").write_text("---\nname: ok\ndescription: d\n---\nBody")
         (skills_dir / "no-skill").mkdir()  # no SKILL.md
 
+        markets_dir = empty_marketplaces(tmp_path)
+
         script = textwrap.dedent(f"""\
             import {{ buildCatalog }} from './scripts/build-skills-catalog.mjs';
-            const entries = buildCatalog({json.dumps(str(skills_dir))});
+            const entries = buildCatalog({json.dumps(str(skills_dir))}, {json.dumps(str(markets_dir))});
             process.stdout.write(JSON.stringify(entries));
         """)
         result = run_node(script)
@@ -334,3 +349,198 @@ class TestGeneratedSkillsIndex:
         subprocess.run(["node", str(SCRIPT)], cwd=str(ROOT), check=True, capture_output=True)
         after = SKILLS_INDEX.read_text()
         assert before == after, "skills/index.js is out of date — run: node scripts/build-skills-catalog.mjs"
+
+
+# ---------------------------------------------------------------------------
+# Marketplace skill categories (consumed by the agent-canvas /skills rail)
+# ---------------------------------------------------------------------------
+
+MARKETPLACES_DIR = ROOT / "marketplaces"
+
+SKILL_CATEGORY_IDS = {
+    "automations",
+    "environment",
+    "code-hosting",
+    "agent-authoring",
+    "code-quality",
+    "integrations",
+    "writing",
+    "design",
+    "other",
+}
+
+# Skills with no marketplace entry, so they fall back to "other".
+# 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] = {}
+    for path in sorted(MARKETPLACES_DIR.glob("*.json")):
+        manifest = json.loads(path.read_text())
+        for entry in manifest.get("plugins", []):
+            source = entry.get("source", "")
+            if not source.startswith("./skills/"):
+                continue
+            result[source.split("/")[-1]] = entry.get("category")
+    return result
+
+
+class TestMarketplaceSkillCategories:
+    def test_every_skill_entry_uses_a_known_category(self):
+        bad = {
+            name: category
+            for name, category in _marketplace_skill_categories().items()
+            if category not in SKILL_CATEGORY_IDS
+        }
+        assert bad == {}, f"Unknown categories: {bad}"
+
+    def test_uncovered_skills_are_exactly_the_known_exceptions(self):
+        dirs = {
+            d.name
+            for d in (ROOT / "skills").iterdir()
+            if d.is_dir() and not d.name.startswith(".")
+        }
+        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()
+        for path in sorted(MARKETPLACES_DIR.glob("*.json")):
+            manifest = json.loads(path.read_text())
+            for entry in manifest.get("plugins", []):
+                if entry.get("source", "").startswith("./skills/"):
+                    continue
+                categories.add(entry.get("category"))
+        assert categories - SKILL_CATEGORY_IDS, (
+            "Plugin entries appear to have been rewritten to the skill taxonomy"
+        )
+
+
+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)
+
+        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)
+
+    def test_category_is_joined_from_the_manifest(self, tmp_path):
+        result = self._build(
+            tmp_path,
+            {"docker": "---\nname: docker\ndescription: d\n---\nBody"},
+            {"m.json": {"plugins": [{"name": "docker", "source": "./skills/docker", "category": "environment"}]}},
+        )
+        entries = json.loads(result.stdout)
+        assert entries[0]["category"] == "environment"
+
+    def test_plugin_entries_are_ignored_when_building_the_map(self, tmp_path):
+        result = self._build(
+            tmp_path,
+            {"docker": "---\nname: docker\ndescription: d\n---\nBody"},
+            {"m.json": {"plugins": [
+                {"name": "some-plugin", "source": "./plugins/some-plugin", "category": "utilities"},
+                {"name": "docker", "source": "./skills/docker", "category": "environment"},
+            ]}},
+        )
+        entries = json.loads(result.stdout)
+        assert entries[0]["category"] == "environment"
+
+    def test_unknown_category_throws_naming_the_skill(self, tmp_path):
+        result = self._build(
+            tmp_path,
+            {"docker": "---\nname: docker\ndescription: d\n---\nBody"},
+            {"m.json": {"plugins": [{"name": "docker", "source": "./skills/docker", "category": "code-hostig"}]}},
+            check=False,
+        )
+        assert result.returncode != 0
+        assert "docker" in result.stderr
+        assert "code-hostig" in result.stderr
+        assert "environment" in result.stderr  # the legal set is printed
+
+    def test_conflicting_categories_across_manifests_throws(self, tmp_path):
+        result = self._build(
+            tmp_path,
+            {"docker": "---\nname: docker\ndescription: d\n---\nBody"},
+            {
+                "a.json": {"plugins": [{"name": "docker", "source": "./skills/docker", "category": "environment"}]},
+                "b.json": {"plugins": [{"name": "docker", "source": "./skills/docker", "category": "design"}]},
+            },
+            check=False,
+        )
+        assert result.returncode != 0
+        assert "docker" in result.stderr
+        assert "Conflicting categories" in result.stderr
+        assert "environment" in result.stderr  # the first manifest's value
+        assert "design" in result.stderr  # the second manifest's conflicting value
+
+    def test_skill_without_an_entry_gets_other_and_warns(self, tmp_path):
+        result = self._build(
+            tmp_path,
+            {"lonely": "---\nname: lonely\ndescription: d\n---\nBody"},
+            {"m.json": {"plugins": []}},
+        )
+        entries = json.loads(result.stdout)
+        assert entries[0]["category"] == "other"
+        assert "lonely" in result.stderr
+
+
+class TestGeneratedCategories:
+    def test_every_entry_has_a_known_category(self):
+        script = textwrap.dedent("""\
+            import { SKILLS_CATALOG, SKILL_CATEGORY_IDS } from './skills/index.js';
+            const legal = new Set(SKILL_CATEGORY_IDS);
+            for (const entry of SKILLS_CATALOG) {
+              if (!legal.has(entry.category)) {
+                console.error('Bad category for ' + entry.name + ': ' + entry.category);
+                process.exit(1);
+              }
+            }
+        """)
+        run_node(script)
+
+    def test_uncovered_skills_land_in_other(self):
+        # flarglebargle is the one skill whose marketplace entry sets "other" on purpose: it is a trigger-testing skill, not a real category member.
+        script = textwrap.dedent(f"""\
+            import {{ SKILLS_CATALOG }} from './skills/index.js';
+            const expected = {json.dumps(sorted(SKILLS_WITHOUT_MARKETPLACE_ENTRY))};
+            const actual = SKILLS_CATALOG.filter(e => e.category === 'other').map(e => e.name).sort();
+            const extra = actual.filter(n => !expected.includes(n) && n !== 'flarglebargle');
+            if (extra.length) {{
+              console.error('Unexpected uncategorized skills: ' + extra.join(', '));
+              process.exit(1);
+            }}
+        """)
+        run_node(script)