The agent that grows with you
Python aiai-agentai-agentsanthropicchatgptclaudeclaude-codecodexhermeshermes-agentllmnous-researchopenai
"""Portable transfers keep user files, not machine-specific PM state."""
from argparse import Namespace
from pathlib import Path
import tarfile
import zipfile
import pytest
@pytest.fixture
def transfer_home(tmp_path, monkeypatch):
home = tmp_path / "source-home"
home.mkdir()
monkeypatch.setattr(Path, "home", lambda: tmp_path)
monkeypatch.setenv("HERMES_HOME", str(home))
from hermes_cli import backup, gateway, profiles
# Restoring data must not install host services or modify the test user's shell.
from hermes_cli import gateway_setup_service
monkeypatch.setattr(gateway_setup_service, "ensure_gateway_service", lambda *args, **kwargs: False)
monkeypatch.setattr(gateway, "_is_service_running", lambda: False)
monkeypatch.setattr(profiles, "check_alias_collision", lambda name: "test has no aliases")
monkeypatch.setattr(backup, "_collect_memory_provider_external_paths", list)
return home
def _write_files(root, files):
for rel, content in files.items():
target = root / rel
target.parent.mkdir(parents=True, exist_ok=True)
target.write_text(content, encoding="utf-8")
@pytest.mark.parametrize("route", ["backup", "default", "named", "distribution", "explicit"])
def test_transfers_preserve_user_files_without_porting_pm_state(
transfer_home, tmp_path, monkeypatch, route
):
from hermes_cli.backup import run_backup, run_import
from hermes_cli.profile_distribution import (
DistributionManifest, install_distribution, write_manifest,
)
from hermes_cli.profiles import export_profile, get_profile_dir, import_profile
portable = {
"config.yaml": "model:\n model: portable\n",
"SOUL.md": "Be kind.\n",
"plugins/example/facts.json": '{"owner": "plugin"}\n',
"skills/example/tools/helper.py": "print('portable tool')\n",
"skills/example/cache/notes.txt": "user-authored data\n",
}
runtime = {
"installs/install-id/facts.json": '{"environment": "C:/other-machine/generation"}\n',
"installs/install-id/environments/generation/pyvenv.cfg": "home = other-machine\n",
"tools/uv/bin/uv": "machine executable\n",
"cache/partials/transfer.partial": "unfinished transfer\n",
}
source = get_profile_dir("porter") if route == "named" else transfer_home
_write_files(source, portable | runtime)
if route == "backup":
portable |= {f"profiles/coder/{rel}": text for rel, text in list(portable.items())}
runtime |= {f"profiles/coder/{rel}": text for rel, text in list(runtime.items())}
_write_files(source, portable | runtime)
archive = tmp_path / "portable.zip"
run_backup(Namespace(output=str(archive)))
with zipfile.ZipFile(archive) as reader:
names = set(reader.namelist())
elif route in {"default", "named"}:
name = "porter" if route == "named" else "default"
archive = export_profile(name, str(tmp_path / "portable.tar.gz"))
with tarfile.open(archive) as reader:
names = {member.name.removeprefix(f"{name}/") for member in reader if member.isfile()}
else:
owned = sorted({Path(rel).parts[0] for rel in portable | runtime}) if route == "explicit" else []
write_manifest(source, DistributionManifest(name="portable", distribution_owned=owned))
names = None
if names is not None:
assert set(portable) <= names
assert not (set(runtime) & names)
target_home = tmp_path / "target-home"
target_home.mkdir()
monkeypatch.setenv("HERMES_HOME", str(target_home))
if route == "backup":
run_import(Namespace(zipfile=str(archive), force=True))
restored = target_home
elif route in {"default", "named"}:
restored = import_profile(str(archive), name="restored")
else:
restored = install_distribution(str(source), name="restored").target_dir
for rel, content in portable.items():
assert (restored / rel).read_text(encoding="utf-8") == content, (route, rel)
for rel, content in runtime.items():
assert not (restored / rel).exists(), (route, rel)
assert (source / rel).read_text(encoding="utf-8") == content
@pytest.mark.parametrize("route", ["backup", "profile", "profile-denied", "distribution", "explicit"])
def test_incoming_runtime_state_never_replaces_target_runtime(
transfer_home, tmp_path, monkeypatch, route
):
from hermes_cli.backup import run_import
from hermes_cli.profile_distribution import (
DistributionManifest, install_distribution, write_manifest,
)
from hermes_cli.profiles import get_profile_dir, import_profile
incoming = {
"config.yaml": "model:\n model: restored\n",
"plugins/example/facts.json": '{"owner": "plugin"}\n',
"skills/example/tools/helper.py": "print('user tool')\n",
"skills/example/cache/notes.txt": "keep user files\n",
}
machine = {
"installs/key/facts.json": "foreign generation\n",
"tools/uv/bin/uv": "foreign executable\n",
"cache": "foreign cache file\n",
}
if route == "backup":
incoming |= {f"profiles/coder/{rel}": text for rel, text in list(incoming.items())}
machine |= {f"profiles/coder/{rel}": text for rel, text in list(machine.items())}
staged = tmp_path / "archive-source"
_write_files(staged, incoming | machine)
target = transfer_home if route == "backup" else get_profile_dir("restored")
if not route.startswith("profile"):
_write_files(target, dict.fromkeys(machine, "target-owned runtime\n"))
if route == "backup":
archive = tmp_path / "legacy.zip"
with zipfile.ZipFile(archive, "w") as writer:
for rel, content in (incoming | machine).items():
writer.writestr(f".hermes/{rel}", content)
run_import(Namespace(zipfile=str(archive), force=True))
elif route.startswith("profile"):
archive = tmp_path / "legacy.tar.gz"
with tarfile.open(archive, "w:gz") as writer:
writer.add(staged, arcname="legacy")
if route == "profile-denied":
from hermes_cli import profiles
real_rmtree = profiles.shutil.rmtree
def deny_runtime_removal(path, *args, **kwargs):
if Path(path).name == "installs":
if kwargs.get("ignore_errors"):
return
raise PermissionError("staged runtime is locked")
return real_rmtree(path, *args, **kwargs)
with monkeypatch.context() as scoped:
scoped.setattr(profiles.shutil, "rmtree", deny_runtime_removal)
with pytest.raises(PermissionError, match="staged runtime is locked"):
import_profile(str(archive), name="restored")
assert not target.exists()
return
target = import_profile(str(archive), name="restored")
else:
owned = sorted({Path(rel).parts[0] for rel in incoming | machine}) if route == "explicit" else []
write_manifest(staged, DistributionManifest(name="legacy", distribution_owned=owned))
target = install_distribution(str(staged), name="restored", force=True).target_dir
for rel, content in incoming.items():
assert (target / rel).read_text(encoding="utf-8") == content, (route, rel)
for rel, content in machine.items():
if route == "profile":
assert not (target / rel).exists(), rel
else:
assert (target / rel).read_text(encoding="utf-8") == "target-owned runtime\n", (route, rel)
assert (staged / rel).read_text(encoding="utf-8") == content
if route == "explicit":
# Windows-authored manifests use separators that must not bypass ownership.
write_manifest(staged, DistributionManifest(
name="legacy", distribution_owned=[rel.replace("/", "\\") for rel in incoming | machine],
))
install_distribution(str(staged), name="restored", force=True)
for rel in machine:
assert (target / rel).read_text(encoding="utf-8") == "target-owned runtime\n", rel
elif route == "backup":
# An in-home traversal must not bypass the runtime-root classification.
with zipfile.ZipFile(archive, "w") as writer:
writer.writestr(".hermes/config.yaml", incoming["config.yaml"])
writer.writestr(".hermes/skills/../installs/key/facts.json", "foreign generation\n")
run_import(Namespace(zipfile=str(archive), force=True))
assert (target / "installs/key/facts.json").read_text(encoding="utf-8") == "target-owned runtime\n"