letify 1.2.2__tar.gz → 1.2.3__tar.gz

{letify-1.2.2 → letify-1.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: letify
-Version: 1.2.2
+Version: 1.2.3
 Summary: Declarations that become infrastructure.
 Project-URL: Homepage, https://github.com/DarkPyonix/letify
 Project-URL: Documentation, https://github.com/DarkPyonix/letify/tree/main/docs

{letify-1.2.2 → letify-1.2.3}/letify/__init__.py

@@ -62,7 +62,7 @@ remote: Final = Host.remote
 # The enum class stays importable from letify.declare.instance for letify's own use.
 del Host
 
-__version__ = "1.2.2"
+__version__ = "1.2.3"
 
 
 def fetch(tensor):  # type: ignore[no-untyped-def]

{letify-1.2.2 → letify-1.2.3}/letify/store/volume.py

@@ -89,14 +89,18 @@ def environment_volume(provider: Provider) -> Volume:
     """The automatic environment store when an ephemeral declaration names no volumes.
 
     Spec "Materializing into a runtime": reuse the account's data bucket, or keep the
-    archive on the client without requiring a bucket or a volume declaration.
+    archive on the client without requiring a bucket or a volume declaration. The client
+    store is the declared ``~/.letify/cache/storage/<name>`` root with the name
+    ``environments``, so it stays under the single local root while still reading archives
+    an earlier install left under ``~/.cache/letify/environments``.
     """
+    from ..paths import storage_cache_directory
     from .backends.filesystem import FilesystemBackend
     from .pathdata import data_bucket
 
     backend = data_bucket(provider)
     if backend is None:
-        root = Path.home() / ".cache" / "letify" / "environments" / provider.kind / provider.alias
+        root = storage_cache_directory("environments") / provider.kind / provider.alias
         backend = FilesystemBackend(root)
     return Volume(provider, "environments", _store=Store(backend))
 

{letify-1.2.2 → letify-1.2.3}/letify/transport/nat.py

@@ -382,11 +382,10 @@ def begin(request: dict):
             stderr=subprocess.STDOUT,
             text=True,
         )
-        for line in process.stdout:
-            found = re.search(r"address:\s*(tc\S+)", line)
-            if found:
-                return {"address": found.group(1)}, process.wait
-        raise RuntimeError("tailcat serve exited without printing its address")
+        address = _match_then_drain(process, process.stdout, r"address:\s*(tc\S+)")
+        if address is None:
+            raise RuntimeError("tailcat serve exited without printing its address")
+        return {"address": address}, process.wait
     if kind == "reverse_ssh":
         # The directory is under the account's workspace root, which may start with ~.
         key = Path(os.path.expanduser(request["key_directory"])) / "letify_reverse"
@@ -405,14 +404,47 @@ def begin(request: dict):
             stderr=subprocess.PIPE,
             text=True,
         )  # fmt: skip
-        for line in process.stderr:
-            found = re.search(r"Allocated port (\d+)", line)
-            if found:
-                return {"port": int(found.group(1))}, process.wait
-        raise RuntimeError("ssh -R exited without allocating a port")
+        allocated = _match_then_drain(process, process.stderr, r"Allocated port (\d+)")
+        if allocated is None:
+            raise RuntimeError("ssh -R exited without allocating a port")
+        return {"port": int(allocated)}, process.wait
     raise ValueError(f"unknown rendezvous request {kind!r}")
 
 
+def _match_then_drain(process, stream, pattern: str) -> str | None:
+    """First capture of ``pattern`` in ``stream``, then keep draining it in the background.
+
+    A helper letify starts and reads one line from keeps writing afterwards. Its pipe holds
+    about 64 KiB, so once nobody reads it the helper blocks on its next write and stops
+    moving bytes. ``tailcat serve`` carries the SSH connection itself, so that stall shows
+    up as a link that connects and then measures far below the link underneath it. Reading
+    on and discarding keeps the writer running, and keeps ``process.wait`` from deadlocking
+    against a full pipe.
+
+    Returns None when the stream ends before the pattern appears.
+    """
+    expression = re.compile(pattern)
+    found = None
+    for line in stream:
+        match = expression.search(line)
+        if match:
+            found = match.group(1)
+            break
+    if found is None:
+        return None
+
+    def drain() -> None:
+        try:
+            for _ in stream:
+                pass
+        except (OSError, ValueError):
+            # The process ended and the stream was closed under us, which is the normal end.
+            pass
+
+    threading.Thread(target=drain, name="letify-drain", daemon=True).start()
+    return found
+
+
 def _authorize(public_key: str) -> None:
     path = Path.home() / ".ssh" / "authorized_keys"
     path.parent.mkdir(mode=0o700, parents=True, exist_ok=True)

{letify-1.2.2 → letify-1.2.3}/letify-core/Cargo.lock

@@ -10,7 +10,7 @@ checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801"
 
 [[package]]
 name = "letify-agent"
-version = "1.2.2"
+version = "1.2.3"
 dependencies = [
  "letify-wire",
  "libloading",
@@ -18,14 +18,14 @@ dependencies = [
 
 [[package]]
 name = "letify-driver"
-version = "1.2.2"
+version = "1.2.3"
 dependencies = [
  "letify-wire",
 ]
 
 [[package]]
 name = "letify-wire"
-version = "1.2.2"
+version = "1.2.3"
 
 [[package]]
 name = "libloading"

{letify-1.2.2 → letify-1.2.3}/letify-core/Cargo.toml

@@ -8,7 +8,7 @@ resolver = "3"
 members = ["letify-wire", "letify-driver", "letify-agent"]
 
 [workspace.package]
-version = "1.2.2"
+version = "1.2.3"
 edition = "2024"
 license = "MIT"
 repository = "https://github.com/DarkPyonix/letify"

{letify-1.2.2 → letify-1.2.3}/letify-ext/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "letify-status",
-  "version": "1.2.2",
+  "version": "1.2.3",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "letify-status",
-      "version": "1.2.2",
+      "version": "1.2.3",
       "license": "SEE LICENSE IN LICENSE",
       "devDependencies": {
         "@types/node": "^18.19.0",

{letify-1.2.2 → letify-1.2.3}/letify-ext/package.json

@@ -2,7 +2,7 @@
   "name": "letify-status",
   "displayName": "letify Status",
   "description": "letify quota and GPU activity in the status bar, read from the letify CLI.",
-  "version": "1.2.2",
+  "version": "1.2.3",
   "publisher": "darkpyonix",
   "license": "SEE LICENSE IN LICENSE",
   "repository": {

{letify-1.2.2 → letify-1.2.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "letify"
-version = "1.2.2"
+version = "1.2.3"
 description = "Declarations that become infrastructure."
 readme = "README.md"
 requires-python = ">=3.11"

{letify-1.2.2 → letify-1.2.3}/tests/conftest.py

@@ -158,6 +158,13 @@ def uv_project(tmp_path: Path, monkeypatch) -> Path:
         subprocess.run([uv, "lock"], cwd=project, capture_output=True, check=True)
     monkeypatch.chdir(project)
     monkeypatch.setattr(bootstrap, "DEFAULT_WORKSPACE_ROOT", str(tmp_path / "runtime-workspace"))
+    # The automatic environment archive store lives under the user's own ~/.letify, so
+    # without this an archive a previous run published is found and a test that expects a
+    # sync sees "archive" instead. Spec "Materializing into a runtime".
+    from letify import paths
+
+    store = tmp_path / "storage"
+    monkeypatch.setattr(paths, "storage_cache_directory", lambda name: store / name)
     return project
 
 

{letify-1.2.2 → letify-1.2.3}/tests/test_paths.py

@@ -302,3 +302,38 @@ def test_compatibility_fallbacks_for_migrated_paths(
     Colab(ProviderConfig("colab_compat", "colab", {}, 0))
     # It should find the token via fallback
     assert (acct / ".config" / "colab-cli" / "token.json").is_file()
+
+
+# -- Spec: Local machine, the filesystem storage backend root ----------------------
+
+
+def test_the_automatic_environment_store_sits_under_the_declared_cache(monkeypatch, tmp_path):
+    # Spec "Materializing into a runtime": the automatic archive store is the
+    # ~/.letify/cache/storage/<name> row with the name "environments", not a directory of
+    # its own under ~/.cache.
+    from letify.config.schema import ProviderConfig
+    from letify.providers.local import Local
+    from letify.store.volume import environment_volume
+
+    monkeypatch.setattr(Path, "home", staticmethod(lambda: tmp_path))
+    provider = Local(ProviderConfig("lab", "local", {}, 0))
+    volume = environment_volume(provider)
+    root = volume._store.backend.root
+
+    assert root == tmp_path / ".letify" / "cache" / "storage" / "environments" / "local" / "lab"
+    assert ".cache" not in root.parts
+
+
+def test_an_existing_environment_store_outside_the_root_is_still_read(monkeypatch, tmp_path):
+    # Spec "Materializing into a runtime": archives an earlier install left under
+    # ~/.cache/letify/environments are read rather than abandoned.
+    from letify.config.schema import ProviderConfig
+    from letify.providers.local import Local
+    from letify.store.volume import environment_volume
+
+    legacy = tmp_path / ".cache" / "letify" / "environments"
+    legacy.mkdir(parents=True)
+    monkeypatch.setattr(Path, "home", staticmethod(lambda: tmp_path))
+    provider = Local(ProviderConfig("lab", "local", {}, 0))
+
+    assert environment_volume(provider)._store.backend.root == legacy / "local" / "lab"

{letify-1.2.2 → letify-1.2.3}/tests/test_strategies.py

@@ -592,3 +592,40 @@ def test_the_remote_half_starts_no_sshd_when_an_ssh_server_already_answers(
     finally:
         server.close()
     assert not any(str(binary) in command for command in recorder.commands)
+
+
+def _flooding_binary(directory, address: str, bytes_after: int) -> str:
+    """An executable that prints ``address`` the way tailcat does, then floods its output."""
+    import os
+    import sys
+    from pathlib import Path
+
+    path = Path(directory) / "flooding_tailcat"
+    path.write_text(
+        f"#!{sys.executable}\n"
+        "import sys\n"
+        f"print('Server listening with new address: {address}', flush=True)\n"
+        f"sys.stdout.write('x' * {bytes_after})\n"
+        "sys.stdout.flush()\n"
+    )
+    path.chmod(0o755)
+    return os.fspath(path)
+
+
+def test_the_remote_half_keeps_reading_what_tailcat_serve_prints_after_the_address(
+    tmp_path,
+) -> None:
+    # A pipe holds about 64 KiB, so a megabyte is far past the point where an unread
+    # pipe blocks the writer and the tunnel stops moving bytes.
+    binary = _flooding_binary(tmp_path, "tcReal1", 1 << 20)
+    answer, serve = nat.begin({"kind": "tailcat", "ssh_port": 22, "binary": binary})
+    assert answer == {"address": "tcReal1"}
+
+    import threading
+
+    waiter = threading.Thread(target=serve, daemon=True)
+    waiter.start()
+    waiter.join(30.0)
+    assert not waiter.is_alive(), (
+        "tailcat serve never finished, so it blocked writing to a pipe nobody reads"
+    )