tlaplus-cli 0.3.2__tar.gz → 0.3.4__tar.gz

{tlaplus_cli-0.3.2/src/tlaplus_cli.egg-info → tlaplus_cli-0.3.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tlaplus-cli
-Version: 0.3.2
+Version: 0.3.4
 Summary: TLA+ tools: download TLC, compile custom modules, run model checker
 Author-email: Denis Nikolskiy <codeomatics@gmail.com>
 License-Expression: MIT

{tlaplus_cli-0.3.2 → tlaplus_cli-0.3.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "tlaplus-cli"
-version = "0.3.2"
+version = "0.3.4"
 description = "TLA+ tools: download TLC, compile custom modules, run model checker"
 readme = "README.md"
 requires-python = ">=3.11"
@@ -45,7 +45,8 @@ where = ["src"]
 include = ["tlaplus_cli*"]
 
 [tool.setuptools.package-data]
-tlaplus_cli = ["resources/default_config.yaml", "py.typed"]
+tlaplus_cli = ["py.typed"]
+"tlaplus_cli.resources" = ["*.yaml"]
 
 [dependency-groups]
 dev = [

{tlaplus_cli-0.3.2 → tlaplus_cli-0.3.4}/src/tlaplus_cli/config.py

@@ -1,4 +1,4 @@
-import shutil
+import importlib.resources
 from functools import lru_cache
 from pathlib import Path
 
@@ -37,9 +37,12 @@ def cache_dir() -> Path:
     return Path(platformdirs.user_cache_dir(_APP_NAME))
 
 
-def _default_config_path() -> Path:
-    """Path to the default config shipped with the package."""
-    return Path(__file__).parent / "resources" / "default_config.yaml"
+def _default_config_content() -> str:
+    """Read the default config shipped with the package."""
+    # Safer than __file__, correctly handles zipped wheels and zipapps.
+    return (
+        importlib.resources.files("tlaplus_cli.resources").joinpath("default_config.yaml").read_text(encoding="utf-8")
+    )
 
 
 def _ensure_config() -> Path:
@@ -47,7 +50,8 @@ def _ensure_config() -> Path:
     cp = config_path()
     if not cp.exists():
         cp.parent.mkdir(parents=True, exist_ok=True)
-        shutil.copy2(_default_config_path(), cp)
+        # Write default config to the newly created path
+        cp.write_text(_default_config_content(), encoding="utf-8")
     return cp
 
 

{tlaplus_cli-0.3.2 → tlaplus_cli-0.3.4}/src/tlaplus_cli/project.py

@@ -5,11 +5,7 @@ from pathlib import Path
 
 def _is_project_root(directory: Path, modules_dir: Path | str, classes_dir: Path | str, lib_dir: Path | str) -> bool:
     """Return True if directory contains at least one project structure marker."""
-    return (
-        (directory / classes_dir).is_dir()
-        or (directory / modules_dir).is_dir()
-        or (directory / lib_dir).is_dir()
-    )
+    return (directory / classes_dir).is_dir() or (directory / modules_dir).is_dir() or (directory / lib_dir).is_dir()
 
 
 def find_project_root(

tlaplus_cli-0.3.4/src/tlaplus_cli/resources/__init__.py

@@ -0,0 +1 @@
+"""Resources subpackage."""

{tlaplus_cli-0.3.2 → tlaplus_cli-0.3.4}/src/tlaplus_cli/run_tlc.py

@@ -69,8 +69,7 @@ def tlc(
 
     # Spec resolution logic
     spec_path = Path(spec)
-    candidates = [spec_path, spec_path.with_suffix(".tla"),
-                  spec_path.parent / "spec" / (spec_path.name + ".tla")]
+    candidates = [spec_path, spec_path.with_suffix(".tla"), spec_path.parent / "spec" / (spec_path.name + ".tla")]
 
     spec_file = next((c for c in candidates if c.is_file()), None)
     if not spec_file:
@@ -97,8 +96,15 @@ def tlc(
         if modules_path.is_dir():
             extra_jvm_opts.append(f"-DTLA-Library={modules_path}")
 
-    cmd = ["java", *config.java.opts, *extra_jvm_opts, "-cp", os.pathsep.join(classpath_parts),
-           config.tlc.java_class, spec_file.name]
+    cmd = [
+        "java",
+        *config.java.opts,
+        *extra_jvm_opts,
+        "-cp",
+        os.pathsep.join(classpath_parts),
+        config.tlc.java_class,
+        spec_file.name,
+    ]
 
     typer.echo(f"Running TLC on {spec_file.name} ...\nCommand: {' '.join(cmd)}")
     result = subprocess.run(cmd, cwd=str(spec_file.parent))

{tlaplus_cli-0.3.2 → tlaplus_cli-0.3.4}/src/tlaplus_cli/tools_manager.py

@@ -12,9 +12,11 @@ from tlaplus_cli.version_manager import (
     clear_cache,
     clear_pin,
     download_version,
+    download_version_from_url,
     fetch_remote_versions,
     get_pinned_version_dir,
     get_tools_dir,
+    is_url,
     list_local_versions,
     read_version_metadata,
     resolve_latest_version,
@@ -100,6 +102,25 @@ def install(
     version: str = typer.Argument(None),
     force: bool = typer.Option(False, "--force", "-f", help="Force re-download even if already installed."),
 ) -> None:
+    # --- URL install branch ---
+    if version and is_url(version):
+        try:
+            version_dir = download_version_from_url(version)
+            typer.echo("Download complete.")
+        except ValueError as e:
+            typer.echo(f"Error: {e}", err=True)
+            raise typer.Exit(1) from e
+        except Exception as e:
+            typer.echo(f"Error: Failed to download: {e}", err=True)
+            raise typer.Exit(1) from e
+
+        pinned_dir = get_pinned_version_dir()
+        if pinned_dir is None:
+            typer.echo(f"Auto-pinning newly installed version {version_dir.name}")
+            set_pin(version_dir)
+        return
+    # --- end URL branch ---
+
     config = load_config()
     versions, _ = fetch_remote_versions(config.tla.urls.tags, config.tla.urls.releases, config.tla.urls.per_page)
     if not versions:

{tlaplus_cli-0.3.2 → tlaplus_cli-0.3.4}/src/tlaplus_cli/version_manager.py

@@ -6,8 +6,10 @@ import shutil
 import subprocess
 import time
 from dataclasses import asdict, dataclass
+from datetime import UTC, datetime
 from enum import Enum
 from typing import TYPE_CHECKING, Any
+from urllib.parse import urlparse
 
 import requests
 import typer
@@ -22,6 +24,121 @@ if TYPE_CHECKING:
 _SEMVER_RE = re.compile(r"^v?(\d+)\.(\d+)\.(\d+)")
 
 
+def is_url(text: str) -> bool:
+    """Return True if *text* looks like an HTTP(S) URL."""
+    return text.lower().startswith(("http://", "https://"))
+
+
+def extract_version_from_url(url: str) -> str | None:
+    """Scan URL path segments for a semver-like segment (e.g. 'v1.8.0').
+
+    Returns the first matching segment, or None if none is found.
+    """
+    path = urlparse(url).path
+    for segment in path.split("/"):
+        if _SEMVER_RE.match(segment):
+            return segment
+    return None
+
+
+def _utc_now_iso() -> str:
+    """Return the current UTC time in ISO 8601 format, e.g. '2026-04-06T12:51:28Z'."""
+    now = datetime.now(tz=UTC)
+    return now.strftime("%Y-%m-%dT%H:%M:%SZ")
+
+
+def download_version_from_url(url: str) -> Path:
+    """Download tla2tools.jar from *url* and store it in a timestamped version directory.
+
+    The version name is extracted from URL path segments.  The tag (directory suffix) is
+    the ISO 8601 download timestamp.
+
+    Raises:
+        ValueError: if no semver segment can be found in the URL.
+    """
+    version_name = extract_version_from_url(url)
+    if version_name is None:
+        msg = (
+            'could not extract a version name from the URL. '
+            'The URL must contain a version segment (e.g. "v1.8.0").'
+        )
+        raise ValueError(msg)
+
+    tag = _utc_now_iso()
+    tools_dir = get_tools_dir()
+    version_dir = tools_dir / f"{version_name}-{tag}"
+    version_dir.mkdir(parents=True, exist_ok=True)
+    jar_path = version_dir / "tla2tools.jar"
+
+    try:
+        response = requests.get(
+            url,
+            stream=True,
+            timeout=30,
+            headers={"User-Agent": "tlaplus-cli"},
+        )
+        response.raise_for_status()
+        total = int(response.headers.get("content-length", 0))
+
+        with Progress(
+            "[progress.description]{task.description}",
+            BarColumn(),
+            DownloadColumn(),
+            TransferSpeedColumn(),
+        ) as progress:
+            task = progress.add_task(f"Downloading {version_name}...", total=total or None)
+            with jar_path.open("wb") as f:
+                for chunk in response.iter_content(chunk_size=8192):
+                    f.write(chunk)
+                    progress.update(task, advance=len(chunk))
+    except Exception:
+        shutil.rmtree(version_dir, ignore_errors=True)
+        raise
+
+    write_version_metadata_from_url(version_dir, version_name=version_name, tag=tag, url=url)
+    return version_dir
+
+
+def write_version_metadata_from_url(
+    version_dir: Path,
+    *,
+    version_name: str,
+    tag: str,
+    url: str,
+) -> None:
+    """Write meta-tla2tools.json for a URL-sourced install."""
+    tlc2_version_string = ""
+    try:
+        result = subprocess.run(
+            ["java", "-cp", "tla2tools.jar", "tlc2.TLC", "-version"],
+            cwd=version_dir,
+            capture_output=True,
+            text=True,
+            check=False,
+        )
+        if result.stdout:
+            tlc2_version_string = result.stdout.strip().split("\n")[0]
+    except Exception as e:
+        typer.echo(f"Warning: Failed to extract TLC version string: {e}", err=True)
+
+    meta_file = version_dir / "meta-tla2tools.json"
+    metadata = {
+        "tag_name": version_name,
+        "sha": "",
+        "published_at": "",
+        "tlc2_version_string": tlc2_version_string,
+        "prerelease": False,
+        "download_url": url,
+        "tag": tag,
+    }
+
+    try:
+        with meta_file.open("w") as f:
+            json.dump(metadata, f, indent=2)
+    except Exception as e:
+        typer.echo(f"Warning: Failed to write metadata: {e}", err=True)
+
+
 def _parse_semver(name: str) -> tuple[int, int, int] | None:
     """Try to extract (major, minor, patch) from a version name like 'v1.8.0'."""
     m = _SEMVER_RE.match(name)
@@ -173,7 +290,8 @@ def list_local_versions() -> list[LocalVersion]:
     result = []
     for d in tools_dir.iterdir():
         if d.is_dir() and not d.is_symlink():
-            parts = d.name.rsplit("-", 1)
+            # Split on the FIRST hyphen so timestamp suffixes are preserved whole
+            parts = d.name.split("-", 1)
             if len(parts) == 2:
                 result.append(LocalVersion(name=parts[0], short_sha=parts[1], path=d))
     return result

{tlaplus_cli-0.3.2 → tlaplus_cli-0.3.4/src/tlaplus_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tlaplus-cli
-Version: 0.3.2
+Version: 0.3.4
 Summary: TLA+ tools: download TLC, compile custom modules, run model checker
 Author-email: Denis Nikolskiy <codeomatics@gmail.com>
 License-Expression: MIT

{tlaplus_cli-0.3.2 → tlaplus_cli-0.3.4}/src/tlaplus_cli.egg-info/SOURCES.txt

@@ -19,6 +19,7 @@ src/tlaplus_cli.egg-info/dependency_links.txt
 src/tlaplus_cli.egg-info/entry_points.txt
 src/tlaplus_cli.egg-info/requires.txt
 src/tlaplus_cli.egg-info/top_level.txt
+src/tlaplus_cli/resources/__init__.py
 src/tlaplus_cli/resources/default_config.yaml
 tests/test_build_tlc_module.py
 tests/test_check_java.py

{tlaplus_cli-0.3.2 → tlaplus_cli-0.3.4}/tests/test_build_tlc_module.py

@@ -100,8 +100,8 @@ def test_build_with_explicit_path(mocker, tmp_path, base_settings):
     assert result.exit_code == 0
     args, _ = mock_run.call_args
     cmd = args[0]
-    assert str(project_dir / "classes") in cmd   # -d target
-    assert str(modules_dir / "Foo.java") in cmd   # source file
+    assert str(project_dir / "classes") in cmd  # -d target
+    assert str(modules_dir / "Foo.java") in cmd  # source file
 
 
 def test_build_without_path_uses_workspace_root(mocker, tmp_path, base_settings):

{tlaplus_cli-0.3.2 → tlaplus_cli-0.3.4}/tests/test_project.py

@@ -9,6 +9,7 @@ def test_project_root_at_spec_dir(tmp_path):
     root = find_project_root(spec, modules_dir="modules", classes_dir="classes", lib_dir="lib")
     assert root == tmp_path
 
+
 def test_project_root_at_parent_of_spec_dir(tmp_path):
     """Root found one level up when spec is inside a spec/ subdirectory."""
     spec_subdir = tmp_path / "spec"
@@ -19,6 +20,7 @@ def test_project_root_at_parent_of_spec_dir(tmp_path):
     root = find_project_root(spec, modules_dir="modules", classes_dir="classes", lib_dir="lib")
     assert root == tmp_path
 
+
 def test_project_root_none_when_no_structure(tmp_path):
     """Returns None if neither spec dir nor its parent contain project directories."""
     spec = tmp_path / "spec" / "queue.tla"
@@ -27,6 +29,7 @@ def test_project_root_none_when_no_structure(tmp_path):
     root = find_project_root(spec, modules_dir="modules", classes_dir="classes", lib_dir="lib")
     assert root is None
 
+
 def test_project_root_detected_by_lib(tmp_path):
     """Root found based on lib/ directory even without classes/."""
     spec = tmp_path / "tests" / "queue_test.tla"
@@ -36,6 +39,7 @@ def test_project_root_detected_by_lib(tmp_path):
     root = find_project_root(spec, modules_dir="modules", classes_dir="classes", lib_dir="lib")
     assert root == tmp_path
 
+
 def test_project_root_detected_by_modules(tmp_path):
     """Root found based on modules/ directory alone."""
     spec = tmp_path / "spec" / "queue.tla"

{tlaplus_cli-0.3.2 → tlaplus_cli-0.3.4}/tests/test_tools_manager.py

@@ -7,6 +7,7 @@ import pytest
 from typer.testing import CliRunner
 
 from tlaplus_cli.cli import app
+from tlaplus_cli.version_manager import download_version_from_url
 
 runner = CliRunner()
 
@@ -634,3 +635,196 @@ def test_uninstall_all_flag(mock_cache):
     assert result.exit_code == 0
     assert not v1.exists()
     assert not v2.exists()
+
+
+# ---------------------------------------------------------------------------
+# Custom URL install — unit tests for download_version_from_url
+# ---------------------------------------------------------------------------
+
+def test_download_version_from_url_creates_dir(mocker, mock_cache):
+    """A valid URL creates the expected version directory."""
+
+    url = "https://example.com/v1.9.0/tla2tools.jar"
+    fake_ts = "2026-04-06T12:51:28Z"
+
+    mocker.patch("tlaplus_cli.version_manager._utc_now_iso", return_value=fake_ts)
+    mock_response = mocker.MagicMock()
+    mock_response.raise_for_status = mocker.MagicMock()
+    mock_response.headers = {"content-length": "16"}
+    mock_response.iter_content.return_value = [b"fake jar content"]
+    mocker.patch("tlaplus_cli.version_manager.requests.get", return_value=mock_response)
+    mocker.patch("tlaplus_cli.version_manager.write_version_metadata_from_url")
+
+    result_dir = download_version_from_url(url)
+    tools_dir = mock_cache / "tools"
+    assert result_dir == tools_dir / f"v1.9.0-{fake_ts}"
+    assert result_dir.exists()
+
+
+def test_download_version_from_url_writes_jar(mocker, mock_cache):
+    """The jar file is written into the version directory."""
+
+    url = "https://example.com/v1.9.0/tla2tools.jar"
+    fake_ts = "2026-04-06T12:51:28Z"
+    mocker.patch("tlaplus_cli.version_manager._utc_now_iso", return_value=fake_ts)
+    mock_response = mocker.MagicMock()
+    mock_response.raise_for_status = mocker.MagicMock()
+    mock_response.headers = {"content-length": "16"}
+    mock_response.iter_content.return_value = [b"fake jar content"]
+    mocker.patch("tlaplus_cli.version_manager.requests.get", return_value=mock_response)
+    mocker.patch("tlaplus_cli.version_manager.write_version_metadata_from_url")
+
+    result_dir = download_version_from_url(url)
+    jar = result_dir / "tla2tools.jar"
+    assert jar.exists()
+    assert jar.read_bytes() == b"fake jar content"
+
+
+def test_download_version_from_url_no_version_raises(mocker, mock_cache):
+    """A URL with no semver segment raises ValueError."""
+
+    url = "https://example.com/latest/tla2tools.jar"
+    with pytest.raises(ValueError, match="version"):
+        download_version_from_url(url)
+
+
+def test_download_version_from_url_cleans_up_on_failure(mocker, mock_cache):
+    """The version directory is removed if the download fails."""
+
+    url = "https://example.com/v1.9.0/tla2tools.jar"
+    fake_ts = "2026-04-06T12:51:28Z"
+    mocker.patch("tlaplus_cli.version_manager._utc_now_iso", return_value=fake_ts)
+    mocker.patch(
+        "tlaplus_cli.version_manager.requests.get",
+        side_effect=Exception("network error"),
+    )
+
+    with pytest.raises(Exception, match="network error"):
+        download_version_from_url(url)
+
+    tools_dir = mock_cache / "tools"
+    version_dir = tools_dir / f"v1.9.0-{fake_ts}"
+    assert not version_dir.exists()
+
+
+# ---------------------------------------------------------------------------
+# Custom URL install — CLI integration tests
+# ---------------------------------------------------------------------------
+
+def test_install_from_url_success(mock_cache, mock_load_config, mocker):
+    """Installing from a valid URL echoes 'Download complete' and auto-pins."""
+    url = "https://example.com/v1.9.0/tla2tools.jar"
+    fake_ts = "2026-04-06T12:51:28Z"
+
+    def _fake_download_url(u):
+        tools_dir = mock_cache / "tools"
+        version_dir = tools_dir / f"v1.9.0-{fake_ts}"
+        version_dir.mkdir(parents=True, exist_ok=True)
+        (version_dir / "tla2tools.jar").write_bytes(b"jar")
+        return version_dir
+
+    mocker.patch(
+        "tlaplus_cli.tools_manager.download_version_from_url",
+        side_effect=_fake_download_url,
+    )
+
+    result = runner.invoke(app, ["tools", "install", url])
+    assert result.exit_code == 0
+    assert "Download complete" in result.stdout
+    assert "Auto-pinning" in result.stdout
+
+    pin_file = mock_cache / "tools" / "tools-pinned-version.txt"
+    assert pin_file.read_text().strip() == f"v1.9.0-{fake_ts}"
+
+
+def test_install_from_url_no_version_segment(mock_cache, mock_load_config, mocker):
+    """A URL without a semver segment prints an error and exits with code 1."""
+    url = "https://example.com/latest/tla2tools.jar"
+
+    mocker.patch(
+        "tlaplus_cli.tools_manager.download_version_from_url",
+        side_effect=ValueError(
+            'could not extract a version name from the URL. '
+            'The URL must contain a version segment (e.g. "v1.8.0").'
+        ),
+    )
+
+    result = runner.invoke(app, ["tools", "install", url])
+    assert result.exit_code == 1
+    assert "could not extract a version name" in result.output
+
+
+def test_install_from_url_does_not_move_existing_pin(mock_cache, mock_load_config, mocker):
+    """URL install does NOT auto-pin when a pin already exists."""
+    tools_dir = mock_cache / "tools"
+    tools_dir.mkdir(parents=True, exist_ok=True)
+    pin_file = tools_dir / "tools-pinned-version.txt"
+    pin_file.write_text("v1.8.0-aaaaaaa")
+    (tools_dir / "v1.8.0-aaaaaaa").mkdir()
+
+    url = "https://example.com/v1.9.0/tla2tools.jar"
+    fake_ts = "2026-04-06T12:51:28Z"
+
+    def _fake_download_url(u):
+        version_dir = tools_dir / f"v1.9.0-{fake_ts}"
+        version_dir.mkdir(parents=True, exist_ok=True)
+        (version_dir / "tla2tools.jar").write_bytes(b"jar")
+        return version_dir
+
+    mocker.patch(
+        "tlaplus_cli.tools_manager.download_version_from_url",
+        side_effect=_fake_download_url,
+    )
+
+    result = runner.invoke(app, ["tools", "install", url])
+    assert result.exit_code == 0
+    assert pin_file.read_text().strip() == "v1.8.0-aaaaaaa"
+    assert "Auto-pinning" not in result.stdout
+
+
+def test_install_from_url_network_error(mock_cache, mock_load_config, mocker):
+    """A network error during URL download prints the error and exits with code 1."""
+    url = "https://example.com/v1.9.0/tla2tools.jar"
+
+    mocker.patch(
+        "tlaplus_cli.tools_manager.download_version_from_url",
+        side_effect=Exception("connection refused"),
+    )
+
+    result = runner.invoke(app, ["tools", "install", url])
+    assert result.exit_code == 1
+    assert "Failed to download" in result.output
+
+
+def test_list_shows_url_installed_version(mock_github_api, mock_cache, mock_load_config):
+    """URL-installed version (timestamp tag) appears correctly in tla tools list."""
+    tools_dir = mock_cache / "tools"
+    tools_dir.mkdir(parents=True, exist_ok=True)
+
+    ts = "2026-04-06T12:51:28Z"
+    url_dir = tools_dir / f"v1.9.0-{ts}"
+    url_dir.mkdir()
+    (url_dir / "tla2tools.jar").write_bytes(b"jar")
+
+    result = runner.invoke(app, ["tools", "list"])
+    assert result.exit_code == 0
+    assert "v1.9.0" in result.stdout
+    assert ts in result.stdout
+    assert "local only" in result.stdout
+
+
+def test_meta_sync_skips_url_installed_version(mock_github_api, mock_cache, mock_load_config, mocker):
+    """meta sync gracefully skips versions not found in the remote list."""
+    tools_dir = mock_cache / "tools"
+    tools_dir.mkdir(parents=True, exist_ok=True)
+
+    ts = "2026-04-06T12:51:28Z"
+    url_dir = tools_dir / f"v1.9.0-{ts}"
+    url_dir.mkdir()
+    (url_dir / "tla2tools.jar").write_bytes(b"jar")
+
+    mocker.patch("tlaplus_cli.tools_manager.write_version_metadata")
+
+    result = runner.invoke(app, ["tools", "meta", "sync"])
+    assert result.exit_code == 0
+    assert "Could not find remote data for v1.9.0" in result.output

{tlaplus_cli-0.3.2 → tlaplus_cli-0.3.4}/tests/test_version_manager.py

@@ -7,8 +7,12 @@ from tlaplus_cli.version_manager import (
     LocalVersion,
     RemoteVersion,
     _process_remote_versions,
+    extract_version_from_url,
+    is_url,
+    list_local_versions,
     resolve_latest_version,
     write_version_metadata,
+    write_version_metadata_from_url,
 )
 
 
@@ -191,3 +195,128 @@ def test_write_version_metadata(tmp_path, mocker):
     assert data["tlc2_version_string"] == "TLC2 Version 2.18 of 27 March 2026 (revision 1.8.0)"
     assert data["prerelease"] is True
     assert data["download_url"] == "http://example.com/tla2tools.jar"
+
+
+# --- is_url ---
+
+def test_is_url_https():
+    assert is_url("https://example.com/v1.8.0/tla2tools.jar") is True
+
+def test_is_url_http():
+    assert is_url("http://example.com/tla2tools.jar") is True
+
+def test_is_url_version_string():
+    assert is_url("v1.8.0") is False
+
+def test_is_url_empty():
+    assert is_url("") is False
+
+
+# --- extract_version_from_url ---
+
+def test_extract_version_direct_parent():
+    url = "https://example.com/v1.8.0/tla2tools.jar"
+    assert extract_version_from_url(url) == "v1.8.0"
+
+def test_extract_version_nested():
+    url = "https://example.com/custom/v1.8.0/build/tla2tools.jar"
+    assert extract_version_from_url(url) == "v1.8.0"
+
+def test_extract_version_no_v_prefix():
+    url = "https://example.com/1.8.0/tla2tools.jar"
+    assert extract_version_from_url(url) == "1.8.0"
+
+def test_extract_version_not_found():
+    url = "https://example.com/custom/latest/tla2tools.jar"
+    assert extract_version_from_url(url) is None
+
+def test_extract_version_returns_first_match():
+    # Two version-like segments — must return the first one encountered
+    url = "https://example.com/v1.8.0/dist/v2.0.0/tla2tools.jar"
+    assert extract_version_from_url(url) == "v1.8.0"
+
+
+# --- write_version_metadata_from_url ---
+
+def test_write_version_metadata_from_url_creates_file(tmp_path, mocker):
+
+    mock_run = mocker.patch("tlaplus_cli.version_manager.subprocess.run")
+    mock_run.return_value.stdout = "TLC2 Version 2.20\nSome extra line"
+
+    write_version_metadata_from_url(
+        tmp_path,
+        version_name="v1.9.0",
+        tag="2026-04-06T12:51:28Z",
+        url="https://example.com/v1.9.0/tla2tools.jar",
+    )
+
+    meta_file = tmp_path / "meta-tla2tools.json"
+    assert meta_file.exists()
+
+    with meta_file.open() as f:
+        data = json.load(f)
+
+    assert data["tag_name"] == "v1.9.0"
+    assert data["tag"] == "2026-04-06T12:51:28Z"
+    assert data["download_url"] == "https://example.com/v1.9.0/tla2tools.jar"
+    assert data["sha"] == ""
+    assert data["published_at"] == ""
+    assert data["prerelease"] is False
+    assert data["tlc2_version_string"] == "TLC2 Version 2.20"
+
+
+def test_write_version_metadata_from_url_handles_subprocess_failure(tmp_path, mocker):
+
+    mocker.patch(
+        "tlaplus_cli.version_manager.subprocess.run",
+        side_effect=Exception("java not found"),
+    )
+
+    write_version_metadata_from_url(
+        tmp_path,
+        version_name="v1.9.0",
+        tag="2026-04-06T12:51:28Z",
+        url="https://example.com/v1.9.0/tla2tools.jar",
+    )
+
+    meta_file = tmp_path / "meta-tla2tools.json"
+    with meta_file.open() as f:
+        data = json.load(f)
+    assert data["tlc2_version_string"] == ""
+
+
+# --- list_local_versions with timestamp tag ---
+
+def test_list_local_versions_timestamp_tag(tmp_path, mocker):
+    """URL-installed versions whose suffix is a timestamp are parsed correctly."""
+
+    mocker.patch("tlaplus_cli.version_manager.cache_dir", return_value=tmp_path)
+    tools_dir = tmp_path / "tools"
+    tools_dir.mkdir()
+
+    ts_dir = tools_dir / "v1.9.0-2026-04-06T12:51:28Z"
+    ts_dir.mkdir()
+    (ts_dir / "tla2tools.jar").write_bytes(b"jar")
+
+    versions = list_local_versions()
+    assert len(versions) == 1
+    lv = versions[0]
+    assert lv.name == "v1.9.0"
+    assert lv.short_sha == "2026-04-06T12:51:28Z"
+
+
+def test_list_local_versions_sha_tag(tmp_path, mocker):
+    """Standard SHA-tagged versions still parse correctly after the split change."""
+
+    mocker.patch("tlaplus_cli.version_manager.cache_dir", return_value=tmp_path)
+    tools_dir = tmp_path / "tools"
+    tools_dir.mkdir()
+
+    sha_dir = tools_dir / "v1.8.0-aaaaaaa"
+    sha_dir.mkdir()
+    (sha_dir / "tla2tools.jar").write_bytes(b"jar")
+
+    versions = list_local_versions()
+    assert len(versions) == 1
+    assert versions[0].name == "v1.8.0"
+    assert versions[0].short_sha == "aaaaaaa"