sanka-cli 0.2.2__tar.gz → 0.2.3__tar.gz

{sanka_cli-0.2.2 → sanka_cli-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: sanka-cli
-Version: 0.2.2
+Version: 0.2.3
 Summary: Sanka command-line interface and migration runtime
 Project-URL: Repository, https://github.com/sankaHQ/sanka
 Project-URL: Issues, https://github.com/sankaHQ/sanka/issues

{sanka_cli-0.2.2 → sanka_cli-0.2.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sanka-cli"
-version = "0.2.2"
+version = "0.2.3"
 description = "Sanka command-line interface and migration runtime"
 readme = "README.md"
 requires-python = ">=3.12"

{sanka_cli-0.2.2 → sanka_cli-0.2.3}/src/sanka/cli/__init__.py

@@ -669,9 +669,51 @@ def _extension_result(
     data = {"operation": operation, "records": records}
     if args.json:
         _print_json(_json_result("extension", data, migration_state="not_started"))
-    else:
-        for record in records:
-            print(json.dumps(record, ensure_ascii=False, sort_keys=True))
+        return 0
+
+    terminal = _terminal(args)
+    if operation == "list":
+        terminal.heading("Extensions")
+        terminal.table(
+            ("Extension", "Kind", "Version", "Status", "Marketplace"),
+            [
+                (
+                    str(record.get("id", "")),
+                    str(record.get("kind", "")),
+                    str(record.get("version", "")),
+                    ", ".join(map(str, record.get("status", []))),
+                    str(record.get("marketplace", "")),
+                )
+                for record in records
+            ],
+        )
+    elif operation == "marketplace_list":
+        terminal.heading("Marketplaces")
+        terminal.table(
+            ("Marketplace", "Source", "Commit", "Trusted"),
+            [
+                (
+                    str(record.get("name", "")),
+                    str(record.get("source", "")),
+                    str(record.get("resolved_commit") or "-")[:12],
+                    "yes" if record.get("trusted") else "no",
+                )
+                for record in records
+            ],
+        )
+    elif operation == "add":
+        record = records[0]
+        terminal.success(f"Installed {record['id']} {record['version']}")
+    elif operation == "remove":
+        terminal.success(f"Removed {records[0]['id']}")
+    elif operation == "marketplace_add":
+        terminal.success(f"Added marketplace {records[0]['name']}")
+    elif operation == "marketplace_upgrade":
+        terminal.success(
+            "Updated marketplace " + ", ".join(str(record["name"]) for record in records)
+        )
+    elif operation == "marketplace_remove":
+        terminal.success(f"Removed marketplace {records[0]['name']}")
     return 0
 
 

{sanka_cli-0.2.2 → sanka_cli-0.2.3}/src/sanka/cli/_output.py

@@ -57,6 +57,24 @@ class TerminalOutput:
         if not self.quiet:
             print(self.style(value, "cyan"), file=self.stdout)
 
+    def table(self, headers: tuple[str, ...], rows: list[tuple[str, ...]]) -> None:
+        if self.quiet:
+            return
+        widths = [
+            max(len(header), *(len(row[index]) for row in rows))
+            for index, header in enumerate(headers)
+        ]
+        print(
+            "  ".join(header.ljust(width) for header, width in zip(headers, widths, strict=True)),
+            file=self.stdout,
+        )
+        print("  ".join("-" * width for width in widths), file=self.stdout)
+        for row in rows:
+            print(
+                "  ".join(value.ljust(width) for value, width in zip(row, widths, strict=True)),
+                file=self.stdout,
+            )
+
     def success(self, value: str) -> None:
         print(self.style(f"✓ OK  {value}", "green"), file=self.stdout)
 

{sanka_cli-0.2.2 → sanka_cli-0.2.3}/src/sanka/runtime/extensions/store.py

@@ -529,6 +529,13 @@ def _create_venv(
     )
 
 
+def _venv_launcher_names() -> tuple[str, ...]:
+    names = ("python", "python3", f"python{sys.version_info.major}.{sys.version_info.minor}")
+    if sys.version_info[:2] == (3, 14) and sys.getfilesystemencoding() == "utf-8":
+        names += ("𝜋thon",)
+    return names
+
+
 def _normalize_venv_launchers(environment_descriptor: int) -> None:
     if os.name == "nt":
         return
@@ -543,10 +550,9 @@ def _normalize_venv_launchers(environment_descriptor: int) -> None:
                 )
             os.unlink("lib64", dir_fd=environment_descriptor)
     interpreter = Path(sys.executable).resolve()
-    names = ("python", "python3", f"python{sys.version_info.major}.{sys.version_info.minor}")
     with _directory_at(environment_descriptor, "bin", Path("bin")) as bin_descriptor:
         assert bin_descriptor is not None
-        for name in names:
+        for name in _venv_launcher_names():
             with suppress(FileNotFoundError):
                 status = os.stat(name, dir_fd=bin_descriptor, follow_symlinks=False)
                 if not (stat.S_ISLNK(status.st_mode) or stat.S_ISREG(status.st_mode)):
@@ -2830,24 +2836,29 @@ class ExtensionStore:
                 missing_ok=True,
             ) as existing:
                 if existing is not None:
-                    digest = content_hash(
-                        _tree_records(
-                            existing,
-                            error_code="SANKA_EXTENSION_PATH",
-                            subject="Extension environment",
-                            allowed_symlinks=self._environment_symlinks(),
-                        )
-                    )
-                    if digest == expected_digest:
-                        try:
-                            self._verify_environment_artifacts(
-                                root, executable, wheels, providers=providers
+                    try:
+                        digest = content_hash(
+                            _tree_records(
+                                existing,
+                                error_code="SANKA_EXTENSION_PATH",
+                                subject="Extension environment",
+                                allowed_symlinks=self._environment_symlinks(),
                             )
-                        except ExtensionError as error:
-                            if error.code != "SANKA_EXTENSION_HASH_MISMATCH":
-                                raise
-                        else:
-                            return root
+                        )
+                    except ExtensionError as error:
+                        if error.code != "SANKA_EXTENSION_PATH" or expected_digest is not None:
+                            raise
+                    else:
+                        if digest == expected_digest:
+                            try:
+                                self._verify_environment_artifacts(
+                                    root, executable, wheels, providers=providers
+                                )
+                            except ExtensionError as error:
+                                if error.code != "SANKA_EXTENSION_HASH_MISMATCH":
+                                    raise
+                            else:
+                                return root
                     replace_existing = True
             if replace_existing:
                 shutil.rmtree(environment_name, dir_fd=environments)
@@ -3212,11 +3223,7 @@ class ExtensionStore:
     def _environment_symlinks() -> dict[str, Path]:
         interpreter = Path(sys.executable).resolve()
         return dict.fromkeys(
-            (
-                "bin/python",
-                "bin/python3",
-                f"bin/python{sys.version_info.major}.{sys.version_info.minor}",
-            ),
+            (f"bin/{name}" for name in _venv_launcher_names()),
             interpreter,
         )
 

{sanka_cli-0.2.2 → sanka_cli-0.2.3}/src/sanka_cli/__init__.py

@@ -1,4 +1,4 @@
 # SPDX-License-Identifier: Apache-2.0
 __all__ = ["__version__"]
 
-__version__ = "0.2.2"
+__version__ = "0.2.3"

{sanka_cli-0.2.2 → sanka_cli-0.2.3}/tests/test_cli.py

@@ -163,6 +163,73 @@ def test_extension_management_uses_stable_json_envelopes(
     ]
 
 
+def test_extension_lists_use_human_readable_tables(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+    capsys: pytest.CaptureFixture[str],
+) -> None:
+    class Record:
+        def __init__(self, data: dict[str, object]) -> None:
+            self.data = data
+
+        def to_dict(self) -> dict[str, object]:
+            return self.data
+
+    class Store:
+        def __init__(self, project_root: Path) -> None:
+            assert project_root == tmp_path
+
+        def list_extensions(self) -> tuple[Record, ...]:
+            return (
+                Record(
+                    {
+                        "id": "sanka/drf-to-fastapi",
+                        "kind": "migration",
+                        "version": "0.1.0a3",
+                        "status": ["installed", "enabled"],
+                        "marketplace": "official",
+                        "wheels": [{"sha256": "secret-noise"}],
+                    }
+                ),
+            )
+
+        def marketplaces(self) -> tuple[Record, ...]:
+            return (
+                Record(
+                    {
+                        "name": "official",
+                        "source": "https://github.com/sankaHQ/extensions.git",
+                        "resolved_commit": "a44ab1794924d45e8eeaeec456ce5c28c1c17d56",
+                        "trusted": True,
+                        "snapshot_root": "/private/cache/noise",
+                    }
+                ),
+            )
+
+    monkeypatch.chdir(tmp_path)
+    monkeypatch.setattr(cli, "ExtensionStore", Store)
+
+    assert main(["extension", "list", "--no-color"]) == 0
+    extensions = capsys.readouterr().out
+    assert "Extension" in extensions
+    assert "sanka/drf-to-fastapi" in extensions
+    assert "installed, enabled" in extensions
+    assert "wheels" not in extensions
+    assert "secret-noise" not in extensions
+    assert not extensions.lstrip().startswith("{")
+
+    assert main(["extension", "marketplace", "list", "--no-color"]) == 0
+    marketplaces = capsys.readouterr().out
+    assert "Marketplace" in marketplaces
+    assert "official" in marketplaces
+    assert "github.com/sankaHQ/extensions" in marketplaces
+    assert "a44ab179492" in marketplaces
+    assert "yes" in marketplaces
+    assert "snapshot_root" not in marketplaces
+    assert "private/cache/noise" not in marketplaces
+    assert not marketplaces.lstrip().startswith("{")
+
+
 def test_extension_errors_preserve_stable_code_and_details(
     tmp_path: Path,
     monkeypatch: pytest.MonkeyPatch,
@@ -550,7 +617,7 @@ def test_research_client_uses_public_branded_base_and_unwraps_data() -> None:
         "after": ["2027-01"],
         "locale": ["ja"],
     }
-    assert request.get_header("User-agent") == "sanka-cli/0.2.2"
+    assert request.get_header("User-agent") == "sanka-cli/0.2.3"
     assert timeout == 10.0
 
 

{sanka_cli-0.2.2 → sanka_cli-0.2.3}/tests/test_extension_store.py

@@ -1748,6 +1748,82 @@ def test_venv_normalization_rejects_a_nonstandard_lib64_alias(tmp_path: Path) ->
         os.close(descriptor)
 
 
+@pytest.mark.skipif(os.name != "posix", reason="POSIX venv launcher sealing only")
+def test_venv_normalization_accepts_python_314_unicode_launcher(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    environment = tmp_path / "environment"
+    (environment / "bin").mkdir(parents=True)
+    (environment / "bin" / "𝜋thon").symlink_to("python3.14")
+
+    class VersionInfo(tuple[object, ...]):
+        major = 3
+        minor = 14
+
+    version_info = VersionInfo((3, 14, 0, "final", 0))
+    monkeypatch.setattr(sys, "version_info", version_info)
+    monkeypatch.setattr(sys, "getfilesystemencoding", lambda: "utf-8")
+
+    descriptor = os.open(environment, os.O_RDONLY)
+    try:
+        extension_store._normalize_venv_launchers(descriptor)
+        extension_store._tree_records(
+            descriptor,
+            error_code="SANKA_EXTENSION_PATH",
+            subject="Extension environment",
+            allowed_symlinks=ExtensionStore._environment_symlinks(),
+        )
+    finally:
+        os.close(descriptor)
+
+    launcher = environment / "bin" / "𝜋thon"
+    assert launcher.is_symlink()
+    assert Path(os.readlink(launcher)) == Path(sys.executable).resolve()
+
+
+@pytest.mark.skipif(os.name != "posix", reason="POSIX venv launcher sealing only")
+def test_add_rebuilds_an_orphaned_environment_with_an_unverified_symlink(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    source, wheel = _marketplace(tmp_path / "source")
+    store = ExtensionStore(tmp_path / "project", user_root=tmp_path / "home")
+    store.add_marketplace(source, name="fixtures", trust=True)
+    manifest = load_marketplace(store.marketplaces()[0].snapshot_root)[0]
+    _responses(monkeypatch, {manifest.wheels[0].name: wheel})
+    environment = store.user_root / "environments" / store._manifest_artifact_digest(manifest)
+    (environment / "bin").mkdir(parents=True)
+    stale_launcher = environment / "bin" / "stale-python"
+    stale_launcher.symlink_to("python")
+
+    lock = store.add_extension("example/demo")
+
+    assert lock.artifact_digest == environment.name
+    assert not stale_launcher.exists() and not stale_launcher.is_symlink()
+    assert store.resolve_locked("example/demo") == lock
+
+
+@pytest.mark.skipif(os.name != "posix", reason="POSIX venv launcher sealing only")
+def test_add_rejects_an_unverified_symlink_in_a_recorded_environment(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    source, wheel = _marketplace(tmp_path / "source")
+    store = ExtensionStore(tmp_path / "project", user_root=tmp_path / "home")
+    store.add_marketplace(source, name="fixtures", trust=True)
+    manifest = load_marketplace(store.marketplaces()[0].snapshot_root)[0]
+    _responses(monkeypatch, {manifest.wheels[0].name: wheel})
+    lock = store.add_extension("example/demo")
+    stale_launcher = (
+        store.user_root / "environments" / lock.artifact_digest / "bin" / "stale-python"
+    )
+    stale_launcher.symlink_to("python")
+
+    with pytest.raises(ExtensionError) as raised:
+        store.add_extension("example/demo")
+
+    assert raised.value.code == "SANKA_EXTENSION_PATH"
+    assert stale_launcher.is_symlink()
+
+
 @pytest.mark.skipif(os.name != "posix", reason="POSIX venv launcher sealing only")
 def test_real_posix_materializer_installs_without_a_venv_test_hook(
     tmp_path: Path, monkeypatch: pytest.MonkeyPatch

{sanka_cli-0.2.2 → sanka_cli-0.2.3}/tests/test_mcp.py

@@ -21,7 +21,7 @@ def test_root_version_uses_unified_public_version(runner: CliRunner) -> None:
     result = runner.invoke(cli, ["--version"])
 
     assert result.exit_code == 0
-    assert result.output == "sanka, version 0.2.2\n"
+    assert result.output == "sanka, version 0.2.3\n"
 
 
 def test_mcp_client_uses_the_cli_version_in_its_user_agent() -> None:
@@ -29,7 +29,7 @@ def test_mcp_client_uses_the_cli_version_in_its_user_agent() -> None:
 
     client = SankaMigrateApiClient()
 
-    assert client._client.headers["User-Agent"] == "sanka-cli/0.2.2"
+    assert client._client.headers["User-Agent"] == "sanka-cli/0.2.3"
 
 
 def test_mcp_without_extra_has_install_hint(

{sanka_cli-0.2.2 → sanka_cli-0.2.3}/tests/test_sanka_facade.py

@@ -35,7 +35,7 @@ def test_public_facade_version_matches_unified_distribution() -> None:
         == sanka_cli.__version__
         == sanka_cli.mcp.__version__
         == distribution_version("sanka-cli")
-        == "0.2.2"
+        == "0.2.3"
     )