@openhands/extensions 0.25.0 → 0.26.0

package/tests/test_skill_plugin_loading.py

@@ -1,8 +1,10 @@
 """Test that skills listed in marketplaces can be loaded as Codex/Claude plugins.
 
 Every marketplace entry that references a ``skills/`` directory needs a
-``.plugin/plugin.json`` manifest and vendor symlinks (``.codex-plugin``,
+``.plugin/plugin.json`` manifest and vendor manifests (``.codex-plugin``,
 ``.claude-plugin``) so that Codex and Claude Code can discover and load them.
+A vendor manifest is either a symlink to ``.plugin/`` or a real directory
+mirroring ``plugin.json`` (Codex install drops symlinked dirs; see issue #257).
 
 Regression test for: https://github.com/OpenHands/extensions/issues/201
 """
@@ -61,18 +63,17 @@ class TestAllMarketplaceSkillsHaveManifests:
             f"{', '.join(missing)}"
         )
 
-    def test_all_marketplace_skills_have_vendor_symlinks(self):
-        """Every marketplace skill with a manifest must have vendor symlinks."""
+    def test_all_marketplace_skills_have_vendor_manifests(self):
+        """Every marketplace skill with a manifest must have vendor manifests."""
         problems = []
         for name, path in _marketplace_skill_entries():
             if not (path / ".plugin" / "plugin.json").exists():
                 continue
             for vendor in VENDOR_SYMLINKS:
-                link = path / vendor
-                if not link.is_symlink():
+                if not _vendor_manifest_ok(path, vendor):
                     problems.append(f"{name}/{vendor}")
         assert not problems, (
-            f"Missing vendor symlinks: {', '.join(problems)}"
+            f"Missing vendor manifests: {', '.join(problems)}"
         )
 
     def test_all_manifests_have_required_fields(self):
@@ -127,8 +128,20 @@ class TestIteratePluginLoading:
         assert "verify" in command_names
 
 
+def _vendor_manifest_ok(directory: Path, vendor: str) -> bool:
+    """A vendor manifest is a symlink to .plugin/ or a real dir mirror."""
+    link = directory / vendor
+    if link.is_symlink():
+        return link.resolve() == (directory / ".plugin").resolve()
+    if link.is_dir():
+        src = directory / ".plugin" / "plugin.json"
+        dst = link / "plugin.json"
+        return src.is_file() and dst.is_file() and src.read_bytes() == dst.read_bytes()
+    return False
+
+
 class TestVendorSymlinksForManifests:
-    """Every directory with .plugin/ must have vendor symlinks."""
+    """Every directory with .plugin/ must have vendor manifests."""
 
     @pytest.fixture(
         params=list(_all_dirs_with_plugin_manifest()),
@@ -137,13 +150,10 @@ class TestVendorSymlinksForManifests:
     def dir_with_manifest(self, request):
         return request.param
 
-    def test_has_vendor_symlinks(self, dir_with_manifest):
-        """Directories with .plugin/ must have .claude-plugin and .codex-plugin symlinks."""
+    def test_has_vendor_manifests(self, dir_with_manifest):
+        """Directories with .plugin/ must have .claude-plugin and .codex-plugin manifests."""
         for vendor in VENDOR_SYMLINKS:
-            link = dir_with_manifest / vendor
-            assert link.is_symlink(), (
-                f"{link.relative_to(REPO_ROOT)} must be a symlink to .plugin"
-            )
-            assert link.resolve() == (dir_with_manifest / ".plugin").resolve(), (
-                f"{link.relative_to(REPO_ROOT)} must point to .plugin"
+            assert _vendor_manifest_ok(dir_with_manifest, vendor), (
+                f"{dir_with_manifest / vendor} must be a symlink to .plugin "
+                "or a real directory mirroring plugin.json"
             )

package/tests/test_sync_extensions.py

@@ -1,5 +1,6 @@
 """Tests for scripts/sync_extensions.py core functions."""
 
+import shutil
 import sys
 from pathlib import Path
 
@@ -18,6 +19,7 @@ from sync_extensions import (
     parse_frontmatter,
     slash_triggers,
     sync_commands,
+    sync_symlinks,
 )
 
 
@@ -288,6 +290,106 @@ class TestSyncCommands:
         assert any("manually-edited" in p for p in problems)
 
 
+# ── vendor manifests ─────────────────────────────────────────────────
+
+def _make_plugin_skill(root: Path, name: str = "demo") -> Path:
+    """Create a fake skill dir with a canonical .plugin/plugin.json."""
+    skill = root / "skills" / name
+    (skill / ".plugin").mkdir(parents=True)
+    (skill / ".plugin" / "plugin.json").write_text('{"name": "demo"}\n')
+    return skill
+
+
+def _make_real_vendor_mirror(skill: Path, vendor: str = ".codex-plugin") -> Path:
+    path = skill / vendor
+    path.mkdir(exist_ok=True)
+    (path / "plugin.json").write_text('{"name": "demo"}\n')
+    return path
+
+
+def _point_sync_at(tmp_path, monkeypatch):
+    monkeypatch.setattr("sync_extensions.SKILL_DIRS", [tmp_path / "skills"])
+    monkeypatch.setattr("sync_extensions.REPO_ROOT", tmp_path)
+
+
+class TestVendorManifests:
+    def test_iterate_vendor_dirs_are_real_and_mirror_canonical(self):
+        """Codex drops symlinked dirs on install, so iterate ships real ones."""
+        iterate = REPO_ROOT / "skills" / "iterate"
+        canon = (iterate / ".plugin" / "plugin.json").read_bytes()
+        for vendor in (".codex-plugin", ".claude-plugin"):
+            path = iterate / vendor
+            assert not path.is_symlink(), f"{vendor} must not be a symlink"
+            assert path.is_dir(), f"{vendor} must be a real directory"
+            assert (path / "plugin.json").read_bytes() == canon
+
+    def test_symlink_to_canonical_passes(self, tmp_path, monkeypatch):
+        skill = _make_plugin_skill(tmp_path)
+        try:
+            for vendor in (".codex-plugin", ".claude-plugin"):
+                (skill / vendor).symlink_to(".plugin", target_is_directory=True)
+        except OSError:
+            pytest.skip("symlinks need privileges on this platform")
+        _point_sync_at(tmp_path, monkeypatch)
+
+        assert sync_symlinks(check=True) == []
+
+    def test_real_dir_mirror_passes_and_stale_copy_is_flagged(self, tmp_path, monkeypatch):
+        skill = _make_plugin_skill(tmp_path)
+        vendor = _make_real_vendor_mirror(skill)
+        _make_real_vendor_mirror(skill, ".claude-plugin")
+        _point_sync_at(tmp_path, monkeypatch)
+
+        assert sync_symlinks(check=True) == []
+
+        (vendor / "plugin.json").write_text('{"name": "stale"}\n')
+        problems = sync_symlinks(check=True)
+        assert any("stale manifest copy" in p for p in problems)
+
+    def test_fix_mode_refreshes_stale_copy(self, tmp_path, monkeypatch):
+        skill = _make_plugin_skill(tmp_path)
+        vendor = _make_real_vendor_mirror(skill)
+        _make_real_vendor_mirror(skill, ".claude-plugin")
+        (vendor / "plugin.json").write_text('{"name": "stale"}\n')
+        _point_sync_at(tmp_path, monkeypatch)
+
+        problems = sync_symlinks(check=False)
+        assert any("stale manifest copy" in p for p in problems)
+        assert (vendor / "plugin.json").read_text() == '{"name": "demo"}\n'
+        assert sync_symlinks(check=True) == []
+
+    def test_lossy_install_copy_keeps_codex_manifest(self, tmp_path):
+        """Mimic Codex `plugin add`, which drops symlinked directories.
+
+        The installed cache must still contain
+        `.codex-plugin/plugin.json` for the plugin to load.
+        """
+        src = REPO_ROOT / "skills" / "iterate"
+        dst = tmp_path / "iterate"
+        shutil.copytree(
+            src,
+            dst,
+            ignore=lambda d, names: [
+                n for n in names if (Path(d) / n).is_symlink()
+            ],
+        )
+        manifest = dst / ".codex-plugin" / "plugin.json"
+        assert manifest.is_file(), "Codex install lost .codex-plugin/plugin.json"
+        assert manifest.read_bytes() == (src / ".plugin" / "plugin.json").read_bytes()
+
+    def test_missing_vendor_still_gets_symlink(self, tmp_path, monkeypatch):
+        skill = _make_plugin_skill(tmp_path)
+        _point_sync_at(tmp_path, monkeypatch)
+        try:
+            sync_symlinks(check=False)
+        except OSError:
+            pytest.skip("symlinks need privileges on this platform")
+
+        assert (skill / ".codex-plugin").is_symlink()
+        assert (skill / ".claude-plugin").is_symlink()
+        assert sync_symlinks(check=True) == []
+
+
 # ── marketplace source paths ─────────────────────────────────────────
 
 class TestMarketplaceSourcePaths:

package/tests/test_vscode_app.py

@@ -0,0 +1,33 @@
+import json
+import subprocess
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[1]
+APP = ROOT / "apps" / "vscode"
+
+
+def test_vscode_app_manifest_has_contained_pinned_dual_arch_artifacts():
+    manifest = json.loads((APP / "canvas-extension.json").read_text())
+    backend = manifest["backend"]
+    assert set(backend["artifacts"]) == {"linux-amd64", "linux-arm64"}
+    for artifact in backend["artifacts"].values():
+        assert artifact["path"].startswith("backend/")
+        assert len(artifact["sha256"]) == 64
+    assert "HOME" not in backend["inherit_environment"]
+    assert manifest["entrypoint"] == "extension.js"
+
+
+def test_ready_entrypoint_is_self_contained_and_full_height():
+    source = (APP / "extension.js").read_text()
+    assert "export function activate" in source
+    assert "host.appBackendView.mount" in source
+    assert "query: { folder }" in source
+    assert "localStorage" in source
+    assert "height:100vh" in source
+    assert "<iframe" not in source
+    assert "import " not in source
+    subprocess.run(["node", "--check", str(APP / "extension.js")], check=True)
+
+
+def test_release_binaries_are_not_committed():
+    assert not list(APP.glob("backend/*"))

package/tests/vscode-app.test.mjs

@@ -0,0 +1,43 @@
+import assert from "node:assert/strict";
+import { activate } from "../apps/vscode/extension.js";
+
+class Element {
+  constructor(tag) { this.tagName = tag; this.children = []; this.listeners = {}; this.style = {}; }
+  append(...children) { this.children.push(...children); }
+  replaceChildren(...children) { this.children = children; }
+  setAttribute() {}
+  addEventListener(name, fn) { this.listeners[name] = fn; }
+  async click() { await this.listeners.click(); }
+}
+class Document { createElement(tag) { return new Element(tag); } createTextNode(text) { return { textContent: text }; } }
+const document = new Document();
+globalThis.document = document;
+globalThis.localStorage = { values: new Map(), getItem(k) { return this.values.get(k) ?? null; }, setItem(k, v) { this.values.set(k, v); }, removeItem(k) { this.values.delete(k); } };
+
+const requests = [];
+let status = { name: "vscode", state: "stopped", revision: "artifact-revision" };
+const host = {
+  backend: { id: "backend-a", orgId: "org-a" }, extension: { name: "vscode" },
+  agentServer: { request: async ({ method, path, body }) => {
+    requests.push({ method, path, body });
+    if (method === "GET") return status;
+    if (path.endsWith("/prepare")) return status;
+    if (path.endsWith("/start")) { status = { ...status, state: "ready" }; return status; }
+    return status;
+  } },
+  appBackendView: { mount: ({ container, query }) => { container.mountedQuery = query; return () => { container.disposed = true; }; } },
+  registerPage: (_id, mount) => { host.mount = mount; return () => {}; },
+};
+await activate(host);
+const container = new Element("main");
+const dispose = await host.mount({ container });
+assert.equal(container.children[0].children[0].children[0].textContent, "VS Code setup");
+await container.children[0].children[0].children[3].children[0].click();
+assert.deepEqual(requests.slice(0, 3).map(({ method, path, body }) => [method, path, body]), [
+  ["GET", "/api/canvas-extensions/installed/vscode/backend", undefined],
+  ["POST", "/api/canvas-extensions/installed/vscode/backend/prepare", { revision: "artifact-revision" }],
+  ["POST", "/api/canvas-extensions/installed/vscode/backend/start", { revision: "artifact-revision" }],
+]);
+assert.equal(container.children[0].children[0].mountedQuery, undefined);
+dispose();
+console.log("VS Code App lifecycle behavior passed");